mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
Optimize the performance of the memory pool. (#3414)
This commit is contained in:
@@ -29,11 +29,13 @@
|
||||
|
||||
namespace se {
|
||||
|
||||
cc::map<PoolType, BufferAllocator *> BufferAllocator::_pools;
|
||||
cc::vector<BufferAllocator *> BufferAllocator::pools(BUFFER_ALLOCATOR_SIZE);
|
||||
|
||||
BufferAllocator::BufferAllocator(PoolType type)
|
||||
: _type(type) {
|
||||
BufferAllocator::_pools[_type] = this;
|
||||
if (IS_BUFFER_ALLOCATOR_TYPE(type)) {
|
||||
BufferAllocator::pools[GET_ARRAY_POOL_ID(type)] = this;
|
||||
}
|
||||
}
|
||||
|
||||
BufferAllocator::~BufferAllocator() {
|
||||
@@ -41,7 +43,7 @@ BufferAllocator::~BufferAllocator() {
|
||||
buffer.second->decRef();
|
||||
}
|
||||
_buffers.clear();
|
||||
BufferAllocator::_pools.erase(_type);
|
||||
_caches.clear();
|
||||
}
|
||||
|
||||
Object *BufferAllocator::alloc(uint index, uint bytes) {
|
||||
@@ -53,6 +55,11 @@ Object *BufferAllocator::alloc(uint index, uint bytes) {
|
||||
obj->incRef();
|
||||
_buffers[index] = obj;
|
||||
|
||||
uint8_t *ret = nullptr;
|
||||
size_t len;
|
||||
obj->getArrayBufferData(static_cast<uint8_t **>(&ret), &len);
|
||||
_caches[index] = ret;
|
||||
|
||||
return obj;
|
||||
}
|
||||
|
||||
@@ -62,6 +69,10 @@ void BufferAllocator::free(uint index) {
|
||||
oldObj->decRef();
|
||||
_buffers.erase(index);
|
||||
}
|
||||
|
||||
if (_caches.count(index)) {
|
||||
_caches.erase(index);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace se
|
||||
|
||||
@@ -37,42 +37,58 @@ namespace se {
|
||||
class CC_DLL BufferAllocator final : public cc::Object {
|
||||
public:
|
||||
template <class T>
|
||||
CC_INLINE static T *getBuffer(PoolType type, uint index) {
|
||||
uint size = 0;
|
||||
return BufferAllocator::getBuffer<T>(type, index, &size);
|
||||
static T *getBuffer(PoolType type, uint index) {
|
||||
index &= BUFFER_MASK;
|
||||
const auto p = GET_ARRAY_POOL_ID(type);
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(BufferAllocator::pools[p] != nullptr, "BufferPool: Invalid buffer pool type");
|
||||
#endif
|
||||
|
||||
auto *const pool = BufferAllocator::pools[p];
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(pool->_caches.count(index) != 0, "BufferPool: Invalid buffer pool index");
|
||||
#endif
|
||||
|
||||
return reinterpret_cast<T *>(pool->_caches[index]);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static T *getBuffer(PoolType type, uint index, uint *size) {
|
||||
index &= _bufferMask;
|
||||
if (BufferAllocator::_pools.count(type) != 0) {
|
||||
const auto pool = BufferAllocator::_pools[type];
|
||||
if (pool->_buffers.count(index) != 0) {
|
||||
T *ret = nullptr;
|
||||
size_t len;
|
||||
pool->_buffers[index]->getArrayBufferData((uint8_t **)&ret, &len);
|
||||
*size = (uint)len;
|
||||
return ret;
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
index &= BUFFER_MASK;
|
||||
const auto p = GET_ARRAY_POOL_ID(type);
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(BufferAllocator::pools[p] != nullptr, "BufferPool: Invalid buffer pool type");
|
||||
#endif
|
||||
|
||||
auto *const pool = BufferAllocator::pools[p];
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(pool->_buffers.count(index) != 0, "BufferPool: Invalid buffer pool index");
|
||||
#endif
|
||||
|
||||
T * ret = nullptr;
|
||||
size_t len;
|
||||
pool->_buffers[index]->getArrayBufferData(static_cast<uint8_t **>(&ret), &len);
|
||||
*size = static_cast<uint>(len);
|
||||
return ret;
|
||||
}
|
||||
|
||||
BufferAllocator(PoolType type);
|
||||
~BufferAllocator();
|
||||
explicit BufferAllocator(PoolType type);
|
||||
~BufferAllocator() override;
|
||||
|
||||
Object *alloc(uint index, uint bytes);
|
||||
void free(uint index);
|
||||
void free(uint index);
|
||||
|
||||
private:
|
||||
static cc::map<PoolType, BufferAllocator *> _pools;
|
||||
static constexpr uint _bufferMask = ~(1 << 30);
|
||||
static cc::vector<BufferAllocator *> pools;
|
||||
static constexpr uint BUFFER_MASK = ~(1 << 30);
|
||||
|
||||
cc::map<uint, Object *> _buffers;
|
||||
PoolType _type = PoolType::UNKNOWN;
|
||||
cc::map<uint, Object *> _buffers;
|
||||
cc::map<uint, uint8_t *> _caches;
|
||||
PoolType _type = PoolType::UNKNOWN;
|
||||
};
|
||||
|
||||
} // namespace se
|
||||
|
||||
@@ -29,33 +29,29 @@
|
||||
|
||||
namespace se {
|
||||
|
||||
cc::map<PoolType, BufferPool *> BufferPool::_poolMap;
|
||||
cc::vector<BufferPool *> BufferPool::poolMap(BUFFER_POOL_SIZE);
|
||||
|
||||
BufferPool::BufferPool(PoolType type, uint entryBits, uint bytesPerEntry)
|
||||
: _allocator(type),
|
||||
_entryBits(entryBits),
|
||||
_bytesPerEntry(bytesPerEntry),
|
||||
_type(type) {
|
||||
CCASSERT(BufferPool::_poolMap.count(type) == 0, "The type of pool is already exist");
|
||||
|
||||
_entriesPerChunk = 1 << entryBits;
|
||||
_entryMask = _entriesPerChunk - 1;
|
||||
_chunkMask = 0xffffffff & ~(_entryMask | _poolFlag);
|
||||
_entryMask = _entriesPerChunk - 1;
|
||||
_chunkMask = 0xffffffff & ~(_entryMask | POOL_FLAG);
|
||||
|
||||
_bytesPerChunk = _bytesPerEntry * _entriesPerChunk;
|
||||
|
||||
BufferPool::_poolMap[type] = this;
|
||||
BufferPool::poolMap[GET_BUFFER_POOL_ID(type)] = this;
|
||||
}
|
||||
|
||||
BufferPool::~BufferPool() {
|
||||
BufferPool::_poolMap.erase(_type);
|
||||
}
|
||||
BufferPool::~BufferPool() = default;
|
||||
|
||||
Object *BufferPool::allocateNewChunk() {
|
||||
Object *jsObj = _allocator.alloc(static_cast<uint>(_chunks.size()), _bytesPerChunk);
|
||||
|
||||
uint8_t *realPtr = nullptr;
|
||||
size_t len = 0;
|
||||
size_t len = 0;
|
||||
jsObj->getArrayBufferData(&realPtr, &len);
|
||||
_chunks.push_back(realPtr);
|
||||
|
||||
|
||||
@@ -25,8 +25,8 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "PoolType.h"
|
||||
#include "BufferAllocator.h"
|
||||
#include "PoolType.h"
|
||||
#include "cocos/base/Macros.h"
|
||||
#include "cocos/base/Object.h"
|
||||
#include "cocos/base/TypeDef.h"
|
||||
@@ -39,11 +39,11 @@ class CC_DLL BufferPool final : public cc::Object {
|
||||
public:
|
||||
using Chunk = uint8_t *;
|
||||
|
||||
CC_INLINE static const cc::map<PoolType, BufferPool *> &getPoolMap() { return BufferPool::_poolMap; }
|
||||
CC_INLINE static const uint getPoolFlag() { return _poolFlag; }
|
||||
CC_INLINE static const cc::vector<BufferPool *> &getPoolMap() { return BufferPool::poolMap; }
|
||||
CC_INLINE static uint getPoolFlag() { return POOL_FLAG; }
|
||||
|
||||
BufferPool(PoolType type, uint entryBits, uint bytesPerEntry);
|
||||
~BufferPool();
|
||||
~BufferPool() override;
|
||||
|
||||
template <class T>
|
||||
T *getTypedObject(uint id) const {
|
||||
@@ -56,18 +56,18 @@ public:
|
||||
Object *allocateNewChunk();
|
||||
|
||||
private:
|
||||
static cc::map<PoolType, BufferPool *> _poolMap;
|
||||
static constexpr uint _poolFlag = 1 << 30;
|
||||
static cc::vector<BufferPool *> poolMap;
|
||||
static constexpr uint POOL_FLAG = 1 << 30;
|
||||
|
||||
BufferAllocator _allocator;
|
||||
BufferAllocator _allocator;
|
||||
cc::vector<Chunk> _chunks;
|
||||
uint _entryBits = 1 << 8;
|
||||
uint _chunkMask = 0;
|
||||
uint _entryMask = 0;
|
||||
uint _bytesPerChunk = 0;
|
||||
uint _entriesPerChunk = 0;
|
||||
uint _bytesPerEntry = 0;
|
||||
PoolType _type = PoolType::UNKNOWN;
|
||||
uint _entryBits = 1 << 8;
|
||||
uint _chunkMask = 0;
|
||||
uint _entryMask = 0;
|
||||
uint _bytesPerChunk = 0;
|
||||
uint _entriesPerChunk = 0;
|
||||
uint _bytesPerEntry = 0;
|
||||
PoolType _type = PoolType::UNKNOWN;
|
||||
};
|
||||
|
||||
} // namespace se
|
||||
|
||||
@@ -26,22 +26,29 @@
|
||||
#include "ObjectPool.h"
|
||||
#include "base/memory/Memory.h"
|
||||
|
||||
using namespace se;
|
||||
|
||||
cc::map<PoolType, ObjectPool *> ObjectPool::_poolMap;
|
||||
namespace se {
|
||||
cc::vector<ObjectPool *> ObjectPool::poolMap(CAST_POOL_TYPE(PoolType::FRAMEBUFFER));
|
||||
|
||||
ObjectPool::ObjectPool(PoolType type, Object *jsArr)
|
||||
: _type(type),
|
||||
_jsArr(jsArr) {
|
||||
CCASSERT(jsArr->isArray(), "ObjectPool: It must be initialized with a JavaScript array");
|
||||
CCASSERT(ObjectPool::_poolMap.count(type) == 0, "This type of ObjectPool already exists.");
|
||||
|
||||
_jsArr->incRef();
|
||||
_indexMask = 0xffffffff & ~_poolFlag;
|
||||
ObjectPool::_poolMap.emplace(type, this);
|
||||
_indexMask = 0xffffffff & ~_poolFlag;
|
||||
ObjectPool::poolMap[GET_OBJECT_POOL_ID(type)] = this;
|
||||
}
|
||||
|
||||
ObjectPool::~ObjectPool() {
|
||||
_jsArr->decRef();
|
||||
ObjectPool::_poolMap.erase(_type);
|
||||
_array.clear();
|
||||
}
|
||||
|
||||
void ObjectPool::bind(uint id, Object *obj) {
|
||||
if (id >= _array.size()) {
|
||||
_array.push_back(obj);
|
||||
} else {
|
||||
_array[id] = obj;
|
||||
}
|
||||
}
|
||||
} // namespace se
|
||||
|
||||
@@ -25,48 +25,43 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "cocos/base/Object.h"
|
||||
#include "cocos/bindings/jswrapper/Object.h"
|
||||
#include "cocos/base/memory/StlAlloc.h"
|
||||
#include "cocos/base/Macros.h"
|
||||
#include "cocos/base/TypeDef.h"
|
||||
#include "PoolType.h"
|
||||
#include "cocos/base/Macros.h"
|
||||
#include "cocos/base/Object.h"
|
||||
#include "cocos/base/TypeDef.h"
|
||||
#include "cocos/base/memory/StlAlloc.h"
|
||||
#include "cocos/bindings/jswrapper/Object.h"
|
||||
|
||||
namespace se {
|
||||
|
||||
class CC_DLL ObjectPool final : public cc::Object {
|
||||
public:
|
||||
CC_INLINE static const cc::map<PoolType, ObjectPool *> &getPoolMap() { return ObjectPool::_poolMap; }
|
||||
CC_INLINE static const cc::vector<ObjectPool *> &getPoolMap() { return ObjectPool::poolMap; }
|
||||
|
||||
ObjectPool(PoolType type, Object *jsArr);
|
||||
~ObjectPool();
|
||||
~ObjectPool() override;
|
||||
|
||||
template <class Type>
|
||||
Type *getTypedObject(uint id) const {
|
||||
id = _indexMask & id;
|
||||
bool ok = true;
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
uint len = 0;
|
||||
ok = _jsArr->getArrayLength(&len);
|
||||
CCASSERT(ok && id < len, "ObjectPool: Invalid buffer pool entry id");
|
||||
CCASSERT(id < _array.size(), "ObjectPool: Invalid buffer pool entry id");
|
||||
#endif
|
||||
|
||||
se::Value jsEntry;
|
||||
ok = _jsArr->getArrayElement(id, &jsEntry);
|
||||
if (!ok || !jsEntry.isObject()) {
|
||||
return nullptr;
|
||||
}
|
||||
Type *entry = (Type *)jsEntry.toObject()->getPrivateData();
|
||||
return entry;
|
||||
return static_cast<Type *>(_array[id]->getPrivateData());
|
||||
}
|
||||
|
||||
private:
|
||||
static cc::map<PoolType, ObjectPool *> _poolMap;
|
||||
void bind(uint id, Object *);
|
||||
|
||||
PoolType _type = PoolType::SHADER;
|
||||
Object *_jsArr = nullptr;
|
||||
uint _poolFlag = 1 << 29;
|
||||
uint _indexMask = 0;
|
||||
private:
|
||||
static cc::vector<ObjectPool *> poolMap;
|
||||
|
||||
cc::vector<Object *> _array;
|
||||
PoolType _type = PoolType::SHADER;
|
||||
Object * _jsArr = nullptr;
|
||||
uint _poolFlag = 1 << 29;
|
||||
uint _indexMask = 0;
|
||||
};
|
||||
|
||||
} // namespace se
|
||||
|
||||
@@ -26,6 +26,24 @@
|
||||
#pragma once
|
||||
|
||||
namespace se {
|
||||
|
||||
#define CAST_POOL_TYPE(type) static_cast<uint>(type)
|
||||
|
||||
#define BUFFER_POOL_BEGIN CAST_POOL_TYPE(se::PoolType::PASS)
|
||||
#define ARRAY_POOL_BEGIN CAST_POOL_TYPE(se::PoolType::SUB_MODEL_ARRAY)
|
||||
#define RAW_BUFFER_BEGIN CAST_POOL_TYPE(se::PoolType::RAW_BUFFER)
|
||||
|
||||
#define OBJECT_POOL_SIZE CAST_POOL_TYPE(se::PoolType::FRAMEBUFFER) + 1
|
||||
#define BUFFER_POOL_SIZE CAST_POOL_TYPE(se::PoolType::PIPELINE_SHARED_SCENE_DATA) - BUFFER_POOL_BEGIN + 1
|
||||
#define ARRAY_POOL_SIZE CAST_POOL_TYPE(se::PoolType::UI_BATCH_ARRAY) - ARRAY_POOL_BEGIN + 1
|
||||
#define RAW_BUFFER_SIZE CAST_POOL_TYPE(se::PoolType::RAW_BUFFER) - CAST_POOL_TYPE(se::PoolType::RAW_BUFFER) + 1
|
||||
#define BUFFER_ALLOCATOR_SIZE (ARRAY_POOL_SIZE + RAW_BUFFER_SIZE)
|
||||
|
||||
#define GET_OBJECT_POOL_ID(type) CAST_POOL_TYPE(type)
|
||||
#define GET_BUFFER_POOL_ID(type) CAST_POOL_TYPE(type) - BUFFER_POOL_BEGIN
|
||||
#define GET_ARRAY_POOL_ID(type) CAST_POOL_TYPE(type) >= RAW_BUFFER_BEGIN ? (CAST_POOL_TYPE(type) - RAW_BUFFER_BEGIN + ARRAY_POOL_SIZE) : CAST_POOL_TYPE(type) - ARRAY_POOL_BEGIN
|
||||
#define IS_BUFFER_ALLOCATOR_TYPE(type) CAST_POOL_TYPE(type) >= ARRAY_POOL_BEGIN
|
||||
|
||||
enum class PoolType {
|
||||
// objects
|
||||
ATTRIBUTE,
|
||||
@@ -76,4 +94,4 @@ enum class PoolType {
|
||||
RAW_BUFFER = 300,
|
||||
UNKNOWN
|
||||
};
|
||||
}
|
||||
} // namespace se
|
||||
|
||||
@@ -25,20 +25,20 @@
|
||||
|
||||
#include "jsb_dop.h"
|
||||
|
||||
#include "BufferAllocator.h"
|
||||
#include "BufferPool.h"
|
||||
#include "ObjectPool.h"
|
||||
#include "BufferAllocator.h"
|
||||
#include "cocos/bindings/manual/jsb_global.h"
|
||||
#include "cocos/bindings/manual/jsb_classtype.h"
|
||||
#include "cocos/bindings/manual/jsb_conversions.h"
|
||||
#include "cocos/bindings/manual/jsb_global.h"
|
||||
|
||||
/********************************************************
|
||||
BufferPool binding
|
||||
*******************************************************/
|
||||
se::Class *jsb_BufferPool_class = nullptr;
|
||||
se::Class *jsb_BufferPool_class = nullptr; // NOLINT
|
||||
|
||||
static bool jsb_BufferPool_allocateNewChunk(se::State &s) {
|
||||
se::BufferPool *pool = (se::BufferPool *)s.nativeThisObject();
|
||||
static bool jsb_BufferPool_allocateNewChunk(se::State &s) { // NOLINT
|
||||
auto *pool = static_cast<se::BufferPool *>(s.nativeThisObject());
|
||||
SE_PRECONDITION2(pool, false, "jsb_BufferPool_allocateNewChunk : Invalid Native Object");
|
||||
s.rval().setObject(pool->allocateNewChunk());
|
||||
return true;
|
||||
@@ -47,12 +47,12 @@ SE_BIND_FUNC(jsb_BufferPool_allocateNewChunk);
|
||||
|
||||
SE_DECLARE_FINALIZE_FUNC(jsb_BufferPool_finalize)
|
||||
|
||||
static bool jsb_BufferPool_constructor(se::State &s) {
|
||||
static bool jsb_BufferPool_constructor(se::State &s) { // NOLINT
|
||||
const auto &args = s.args();
|
||||
size_t argc = args.size();
|
||||
size_t argc = args.size();
|
||||
if (argc == 3) {
|
||||
uint poolType = 0;
|
||||
uint entryBits = 0;
|
||||
uint poolType = 0;
|
||||
uint entryBits = 0;
|
||||
uint bytesPerEntry = 0;
|
||||
|
||||
bool ok = true;
|
||||
@@ -73,27 +73,27 @@ static bool jsb_BufferPool_constructor(se::State &s) {
|
||||
SE_REPORT_ERROR("jsb_BufferPool_constructor: wrong number of arguments: %d", (int)argc);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_CTOR(jsb_BufferPool_constructor, jsb_BufferPool_class, jsb_BufferPool_finalize)
|
||||
SE_BIND_CTOR(jsb_BufferPool_constructor, jsb_BufferPool_class, jsb_BufferPool_finalize) // NOLINT
|
||||
|
||||
static bool jsb_BufferPool_finalize(se::State &s) {
|
||||
static bool jsb_BufferPool_finalize(se::State &s) { // NOLINT
|
||||
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
|
||||
if (iter != se::NonRefNativePtrCreatedByCtorMap::end()) {
|
||||
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
|
||||
se::BufferPool *cobj = (se::BufferPool *)s.nativeThisObject();
|
||||
auto *cobj = static_cast<se::BufferPool *>(s.nativeThisObject());
|
||||
JSB_FREE(cobj);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
SE_BIND_FINALIZE_FUNC(jsb_BufferPool_finalize)
|
||||
|
||||
static bool js_register_se_BufferPool(se::Object *obj) {
|
||||
static bool js_register_se_BufferPool(se::Object *obj) { // NOLINT
|
||||
se::Class *cls = se::Class::create("NativeBufferPool", obj, nullptr, _SE(jsb_BufferPool_constructor));
|
||||
|
||||
cls->defineFunction("allocateNewChunk", _SE(jsb_BufferPool_allocateNewChunk));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<se::BufferPool>(cls);
|
||||
|
||||
jsb_BufferPool_class = cls;
|
||||
jsb_BufferPool_class = cls; // NOLINT
|
||||
|
||||
se::ScriptEngine::getInstance()->clearException();
|
||||
return true;
|
||||
@@ -102,16 +102,16 @@ static bool js_register_se_BufferPool(se::Object *obj) {
|
||||
/***************************************************
|
||||
ObjectPool binding
|
||||
*****************************************************/
|
||||
static se::Class *jsb_ObjectPool_class = nullptr;
|
||||
static se::Class *jsb_ObjectPool_class = nullptr; // NOLINT
|
||||
|
||||
SE_DECLARE_FINALIZE_FUNC(jsb_ObjectPool_finalize)
|
||||
|
||||
static bool jsb_ObjectPool_constructor(se::State &s) {
|
||||
static bool jsb_ObjectPool_constructor(se::State &s) { // NOLINT
|
||||
const auto &args = s.args();
|
||||
size_t argc = args.size();
|
||||
size_t argc = args.size();
|
||||
if (argc == 2) {
|
||||
uint poolType = 0;
|
||||
bool ok = true;
|
||||
bool ok = true;
|
||||
ok &= seval_to_uint(args[0], &poolType);
|
||||
|
||||
if (!args[1].isObject()) {
|
||||
@@ -131,23 +131,48 @@ static bool jsb_ObjectPool_constructor(se::State &s) {
|
||||
}
|
||||
SE_BIND_CTOR(jsb_ObjectPool_constructor, jsb_ObjectPool_class, jsb_ObjectPool_finalize)
|
||||
|
||||
static bool jsb_ObjectPool_finalize(se::State &s) {
|
||||
static bool jsb_ObjectPool_finalize(se::State &s) { // NOLINT
|
||||
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
|
||||
if (iter != se::NonRefNativePtrCreatedByCtorMap::end()) {
|
||||
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
|
||||
se::ObjectPool *cobj = (se::ObjectPool *)s.nativeThisObject();
|
||||
auto *cobj = static_cast<se::ObjectPool *>(s.nativeThisObject());
|
||||
JSB_FREE(cobj);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
SE_BIND_FINALIZE_FUNC(jsb_ObjectPool_finalize)
|
||||
|
||||
static bool js_register_se_ObjectPool(se::Object *obj) {
|
||||
static bool js_ObjectPool_bind(se::State &s) { // NOLINT
|
||||
auto *cobj = SE_THIS_OBJECT<se::ObjectPool>(s);
|
||||
SE_PRECONDITION2(cobj, false, "js_ObjectPool_bind : Invalid Native Object");
|
||||
const auto & args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 2) {
|
||||
bool ok = true;
|
||||
uint id = 0;
|
||||
ok &= seval_to_uint(args[0], &id);
|
||||
SE_PRECONDITION2(ok, false, "jsb_ObjectPool_bind : Error processing arguments");
|
||||
|
||||
if (!args[1].isObject()) {
|
||||
SE_REPORT_ERROR("jsb_ObjectPool_bind: parameter 2 wants a Object");
|
||||
return false;
|
||||
}
|
||||
se::Object *value = args[1].toObject();
|
||||
cobj->bind(id, value);
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("jsb_ObjectPool_bind: wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
||||
}
|
||||
SE_BIND_FUNC(js_ObjectPool_bind)
|
||||
|
||||
static bool js_register_se_ObjectPool(se::Object *obj) { // NOLINT
|
||||
se::Class *cls = se::Class::create("NativeObjectPool", obj, nullptr, _SE(jsb_ObjectPool_constructor));
|
||||
cls->defineFunction("bind", _SE(js_ObjectPool_bind));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<se::ObjectPool>(cls);
|
||||
|
||||
jsb_ObjectPool_class = cls;
|
||||
jsb_ObjectPool_class = cls; // NOLINT
|
||||
|
||||
se::ScriptEngine::getInstance()->clearException();
|
||||
return true;
|
||||
@@ -156,20 +181,20 @@ static bool js_register_se_ObjectPool(se::Object *obj) {
|
||||
/*****************************************************
|
||||
Array binding
|
||||
******************************************************/
|
||||
static se::Class *jsb_BufferAllocator_class = nullptr;
|
||||
static se::Class *jsb_BufferAllocator_class = nullptr; // NOLINT
|
||||
|
||||
SE_DECLARE_FINALIZE_FUNC(jsb_BufferAllocator_finalize)
|
||||
|
||||
static bool jsb_BufferAllocator_constructor(se::State &s) {
|
||||
static bool jsb_BufferAllocator_constructor(se::State &s) { // NOLINT
|
||||
const auto &args = s.args();
|
||||
size_t argc = args.size();
|
||||
size_t argc = args.size();
|
||||
if (argc == 1) {
|
||||
uint type = 0;
|
||||
bool ok = seval_to_uint(args[0], &type);
|
||||
bool ok = seval_to_uint(args[0], &type);
|
||||
|
||||
se::BufferAllocator *BufferAllocator = JSB_ALLOC(se::BufferAllocator, static_cast<se::PoolType>(type));
|
||||
s.thisObject()->setPrivateData(BufferAllocator);
|
||||
se::NonRefNativePtrCreatedByCtorMap::emplace(BufferAllocator);
|
||||
se::BufferAllocator *bufferAllocator = JSB_ALLOC(se::BufferAllocator, static_cast<se::PoolType>(type));
|
||||
s.thisObject()->setPrivateData(bufferAllocator);
|
||||
se::NonRefNativePtrCreatedByCtorMap::emplace(bufferAllocator);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -178,23 +203,23 @@ static bool jsb_BufferAllocator_constructor(se::State &s) {
|
||||
}
|
||||
SE_BIND_CTOR(jsb_BufferAllocator_constructor, jsb_BufferAllocator_class, jsb_BufferAllocator_finalize)
|
||||
|
||||
static bool jsb_BufferAllocator_finalize(se::State &s) {
|
||||
static bool jsb_BufferAllocator_finalize(se::State &s) { // NOLINT
|
||||
auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
|
||||
if (iter != se::NonRefNativePtrCreatedByCtorMap::end()) {
|
||||
se::NonRefNativePtrCreatedByCtorMap::erase(iter);
|
||||
se::BufferAllocator *cobj = (se::BufferAllocator *)s.nativeThisObject();
|
||||
auto *cobj = static_cast<se::BufferAllocator *>(s.nativeThisObject());
|
||||
JSB_FREE(cobj);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
SE_BIND_FINALIZE_FUNC(jsb_BufferAllocator_finalize)
|
||||
|
||||
static bool jsb_BufferAllocator_alloc(se::State &s) {
|
||||
se::BufferAllocator *bufferAllocator = (se::BufferAllocator *)s.nativeThisObject();
|
||||
static bool jsb_BufferAllocator_alloc(se::State &s) { // NOLINT
|
||||
auto *bufferAllocator = static_cast<se::BufferAllocator *>(s.nativeThisObject());
|
||||
SE_PRECONDITION2(bufferAllocator, false, "jsb_Array_alloc : Invalid Native Object");
|
||||
|
||||
const auto &args = s.args();
|
||||
size_t argc = args.size();
|
||||
size_t argc = args.size();
|
||||
if (argc == 2) {
|
||||
uint index = 0;
|
||||
seval_to_uint(args[0], &index);
|
||||
@@ -209,12 +234,12 @@ static bool jsb_BufferAllocator_alloc(se::State &s) {
|
||||
}
|
||||
SE_BIND_FUNC(jsb_BufferAllocator_alloc);
|
||||
|
||||
static bool jsb_BufferAllocator_free(se::State &s) {
|
||||
se::BufferAllocator *bufferAllocator = (se::BufferAllocator *)s.nativeThisObject();
|
||||
static bool jsb_BufferAllocator_free(se::State &s) { // NOLINT
|
||||
auto *bufferAllocator = static_cast<se::BufferAllocator *>(s.nativeThisObject());
|
||||
SE_PRECONDITION2(bufferAllocator, false, "jsb_Array_alloc : Invalid Native Object");
|
||||
|
||||
const auto &args = s.args();
|
||||
size_t argc = args.size();
|
||||
size_t argc = args.size();
|
||||
if (argc == 1) {
|
||||
uint index = 0;
|
||||
seval_to_uint(args[0], &index);
|
||||
@@ -227,21 +252,21 @@ static bool jsb_BufferAllocator_free(se::State &s) {
|
||||
}
|
||||
SE_BIND_FUNC(jsb_BufferAllocator_free);
|
||||
|
||||
static bool js_register_se_BufferAllocator(se::Object *obj) {
|
||||
static bool js_register_se_BufferAllocator(se::Object *obj) { // NOLINT
|
||||
se::Class *cls = se::Class::create("NativeBufferAllocator", obj, nullptr, _SE(jsb_BufferAllocator_constructor));
|
||||
cls->defineFunction("alloc", _SE(jsb_BufferAllocator_alloc));
|
||||
cls->defineFunction("free", _SE(jsb_BufferAllocator_free));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<se::BufferAllocator>(cls);
|
||||
|
||||
jsb_BufferAllocator_class = cls;
|
||||
jsb_BufferAllocator_class = cls; // NOLINT
|
||||
|
||||
se::ScriptEngine::getInstance()->clearException();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool register_all_dop_bindings(se::Object *obj) {
|
||||
// TODO: Don't make dop into jsb namespace. Currently put it into jsb namesapce just to test codes.
|
||||
bool register_all_dop_bindings(se::Object *obj) { // NOLINT
|
||||
// TODO(liuhang): Don't make dop into jsb namespace. Currently put it into jsb namesapce just to test codes.
|
||||
se::Value nsVal;
|
||||
if (!obj->getProperty("jsb", &nsVal)) {
|
||||
se::HandleObject jsobj(se::Object::createPlainObject());
|
||||
@@ -250,8 +275,8 @@ bool register_all_dop_bindings(se::Object *obj) {
|
||||
}
|
||||
se::Object *ns = nsVal.toObject();
|
||||
|
||||
js_register_se_BufferAllocator(ns);
|
||||
js_register_se_BufferPool(ns);
|
||||
js_register_se_ObjectPool(ns);
|
||||
js_register_se_BufferAllocator(ns); // NOLINT
|
||||
js_register_se_BufferPool(ns); // NOLINT
|
||||
js_register_se_ObjectPool(ns); // NOLINT
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -29,4 +29,4 @@ namespace se {
|
||||
class Object;
|
||||
}
|
||||
|
||||
bool register_all_dop_bindings(se::Object *obj);
|
||||
bool register_all_dop_bindings(se::Object *obj); // NOLINT
|
||||
|
||||
@@ -66,17 +66,19 @@ void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel
|
||||
}
|
||||
|
||||
void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel, uint passIdx, gfx::Shader *shaderImplant) {
|
||||
uint stride = 0;
|
||||
uint stride = 0;
|
||||
const auto *const instancedBuffer = model->getInstancedBuffer(&stride);
|
||||
|
||||
if (!stride) return; // we assume per-instance attributes are always present
|
||||
auto *sourceIA = subModel->getInputAssembler();
|
||||
auto *lightingMap = subModel->getDescriptorSet()->getTexture(LIGHTMAP_TEXTURE::BINDING);
|
||||
auto *shader = shaderImplant;
|
||||
if (!shader) { shader = subModel->getShader(passIdx); }
|
||||
|
||||
auto *descriptorSet = subModel->getDescriptorSet();
|
||||
for (auto & instance : _instances) {
|
||||
auto *lightingMap = descriptorSet->getTexture(LIGHTMAP_TEXTURE::BINDING);
|
||||
auto *shader = shaderImplant;
|
||||
if (!shader) {
|
||||
shader = subModel->getShader(passIdx);
|
||||
}
|
||||
|
||||
for (auto &instance : _instances) {
|
||||
if (instance.ia->getIndexBuffer() != sourceIA->getIndexBuffer() || instance.count >= MAX_CAPACITY) {
|
||||
continue;
|
||||
}
|
||||
@@ -91,9 +93,9 @@ void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel
|
||||
}
|
||||
if (instance.count >= instance.capacity) { // resize buffers
|
||||
instance.capacity <<= 1;
|
||||
const auto newSize = instance.stride * instance.capacity;
|
||||
const auto newSize = instance.stride * instance.capacity;
|
||||
auto *const oldData = instance.data;
|
||||
instance.data = static_cast<uint8_t *>(CC_MALLOC(newSize));
|
||||
instance.data = static_cast<uint8_t *>(CC_MALLOC(newSize));
|
||||
memcpy(instance.data, oldData, instance.vb->getSize());
|
||||
instance.vb->resize(newSize);
|
||||
CC_FREE(oldData);
|
||||
@@ -110,7 +112,7 @@ void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel
|
||||
}
|
||||
|
||||
// Create a new instance
|
||||
auto newSize = stride * INITIAL_CAPACITY;
|
||||
auto newSize = stride * INITIAL_CAPACITY;
|
||||
auto *vb = _device->createBuffer({
|
||||
gfx::BufferUsageBit::VERTEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE,
|
||||
@@ -118,14 +120,14 @@ void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel
|
||||
static_cast<uint>(stride),
|
||||
});
|
||||
|
||||
auto vertexBuffers = sourceIA->getVertexBuffers();
|
||||
auto attributes = sourceIA->getAttributes();
|
||||
auto vertexBuffers = sourceIA->getVertexBuffers();
|
||||
auto attributes = sourceIA->getAttributes();
|
||||
auto *indexBuffer = sourceIA->getIndexBuffer();
|
||||
|
||||
const auto *const attributesID = model->getInstancedAttributeID();
|
||||
const auto lenght = attributesID[0];
|
||||
const auto lenght = attributesID[0];
|
||||
for (uint i = 1; i <= lenght; i++) {
|
||||
auto *const attribute = model->getInstancedAttribute(attributesID[i]);
|
||||
auto *const attribute = ModelView::getInstancedAttribute(attributesID[i]);
|
||||
gfx::Attribute newAttr = {attribute->name, attribute->format, attribute->isNormalized, static_cast<uint>(vertexBuffers.size()), true, attribute->location};
|
||||
attributes.emplace_back(std::move(newAttr));
|
||||
}
|
||||
@@ -134,7 +136,7 @@ void InstancedBuffer::merge(const ModelView *model, const SubModelView *subModel
|
||||
memcpy(data, instancedBuffer, stride);
|
||||
vertexBuffers.emplace_back(vb);
|
||||
gfx::InputAssemblerInfo iaInfo = {attributes, vertexBuffers, indexBuffer};
|
||||
auto * ia = _device->createInputAssembler(iaInfo);
|
||||
auto * ia = _device->createInputAssembler(iaInfo);
|
||||
InstancedItem item = {1, INITIAL_CAPACITY, vb, data, ia, stride, shader, descriptorSet, lightingMap};
|
||||
_instances.emplace_back(item);
|
||||
_hasPendingModels = true;
|
||||
|
||||
@@ -25,65 +25,69 @@
|
||||
|
||||
#include <array>
|
||||
|
||||
#include "PlanarShadowQueue.h"
|
||||
#include "RenderPipeline.h"
|
||||
#include "Define.h"
|
||||
#include "InstancedBuffer.h"
|
||||
#include "PipelineStateManager.h"
|
||||
#include "PlanarShadowQueue.h"
|
||||
#include "RenderInstancedQueue.h"
|
||||
#include "RenderPipeline.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "helper/SharedMemory.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "gfx-base/GFXShader.h"
|
||||
#include "helper/SharedMemory.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
|
||||
PlanarShadowQueue::PlanarShadowQueue(RenderPipeline *pipeline)
|
||||
:_pipeline(pipeline){
|
||||
: _pipeline(pipeline) {
|
||||
_instancedQueue = CC_NEW(RenderInstancedQueue);
|
||||
}
|
||||
|
||||
void PlanarShadowQueue::gatherShadowPasses(Camera *camera, gfx::CommandBuffer *cmdBufferer) {
|
||||
clear();
|
||||
const auto sceneData = _pipeline->getPipelineSceneData();
|
||||
const auto sharedData = sceneData->getSharedData();
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
const auto *shadowInfo = sharedData->getShadows();
|
||||
if (!shadowInfo->enabled || shadowInfo->getShadowType() != ShadowType::PLANAR) { return; }
|
||||
if (!shadowInfo->enabled || shadowInfo->getShadowType() != ShadowType::PLANAR) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto pipelineUBO = _pipeline->getPipelineUBO();
|
||||
auto *const pipelineUBO = _pipeline->getPipelineUBO();
|
||||
pipelineUBO->updateShadowUBO(camera);
|
||||
const auto *scene = camera->getScene();
|
||||
const bool shadowVisible = camera->visibility & static_cast<uint>(LayerList::DEFAULT);
|
||||
const auto *scene = camera->getScene();
|
||||
const bool shadowVisible = camera->visibility & static_cast<uint>(LayerList::DEFAULT);
|
||||
|
||||
if (!scene->getMainLight() || !shadowVisible) { return; }
|
||||
if (!scene->getMainLight() || !shadowVisible) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
auto *instancedBuffer = InstancedBuffer::get(shadowInfo->instancePass);
|
||||
const auto *const models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
auto * instancedBuffer = InstancedBuffer::get(shadowInfo->instancePass);
|
||||
|
||||
uint visibility = 0, lenght = 0;
|
||||
uint visibility = 0;
|
||||
uint lenght = 0;
|
||||
for (uint i = 1; i <= modelCount; i++) {
|
||||
const auto *model = scene->getModelView(models[i]);
|
||||
const auto *node = model->getNode();
|
||||
const auto *model = cc::pipeline::Scene::getModelView(models[i]);
|
||||
const auto *node = model->getNode();
|
||||
if (model->enabled && model->castShadow) {
|
||||
visibility = camera->visibility;
|
||||
if ((model->nodeID && ((visibility & node->layer) == node->layer)) ||
|
||||
(visibility & model->visFlags)) {
|
||||
|
||||
// frustum culling
|
||||
if ((model->worldBoundsID) && !aabb_frustum(model->getWorldBounds(), camera->getFrustum())) {
|
||||
if ((model->worldBoundsID) && !aabbFrustum(model->getWorldBounds(), camera->getFrustum())) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto *attributesID = model->getInstancedAttributeID();
|
||||
lenght = attributesID[0];
|
||||
lenght = attributesID[0];
|
||||
if (lenght > 0) {
|
||||
const auto *subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
const auto *subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (uint m = 1; m <= subModelCount; ++m) {
|
||||
const auto *subModel = model->getSubModelView(subModelID[m]);
|
||||
const auto *subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
instancedBuffer->merge(model, subModel, m - 1, subModel->getPlanarInstanceShader());
|
||||
_instancedQueue->add(instancedBuffer);
|
||||
}
|
||||
@@ -103,26 +107,30 @@ void PlanarShadowQueue::clear() {
|
||||
}
|
||||
|
||||
void PlanarShadowQueue::recordCommandBuffer(gfx::Device *device, gfx::RenderPass *renderPass, gfx::CommandBuffer *cmdBuffer) {
|
||||
const auto sceneData = _pipeline->getPipelineSceneData();
|
||||
const auto sharedData = sceneData->getSharedData();
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
const auto *shadowInfo = sharedData->getShadows();
|
||||
if (!shadowInfo->enabled || shadowInfo->getShadowType() != ShadowType::PLANAR) { return; }
|
||||
if (!shadowInfo->enabled || shadowInfo->getShadowType() != ShadowType::PLANAR) {
|
||||
return;
|
||||
}
|
||||
|
||||
_instancedQueue->recordCommandBuffer(device, renderPass, cmdBuffer);
|
||||
|
||||
if (_pendingModels.empty()) { return; }
|
||||
if (_pendingModels.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto *pass = shadowInfo->getPlanarShadowPass();
|
||||
cmdBuffer->bindDescriptorSet(MATERIAL_SET, pass->getDescriptorSet());
|
||||
|
||||
for (auto model : _pendingModels) {
|
||||
const auto subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (const auto *model : _pendingModels) {
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (unsigned m = 1; m <= subModelCount; ++m) {
|
||||
const auto subModel = model->getSubModelView(subModelID[m]);
|
||||
const auto shader = subModel->getPlanarShader();
|
||||
const auto ia = subModel->getInputAssembler();
|
||||
const auto pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
const auto *const subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
auto *const shader = subModel->getPlanarShader();
|
||||
auto *const ia = subModel->getInputAssembler();
|
||||
auto *const pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
|
||||
cmdBuffer->bindPipelineState(pso);
|
||||
cmdBuffer->bindDescriptorSet(LOCAL_SET, subModel->getDescriptorSet());
|
||||
@@ -135,5 +143,5 @@ void PlanarShadowQueue::recordCommandBuffer(gfx::Device *device, gfx::RenderPass
|
||||
void PlanarShadowQueue::destroy() {
|
||||
CC_SAFE_DELETE(_instancedQueue);
|
||||
}
|
||||
}
|
||||
} // namespace pipeline
|
||||
} // namespace cc
|
||||
|
||||
@@ -97,12 +97,12 @@ void RenderAdditiveLightQueue::recordCommandBuffer(gfx::Device *device, gfx::Ren
|
||||
for (const auto &lightPass : _lightPasses) {
|
||||
const auto *const subModel = lightPass.subModel;
|
||||
const auto *const pass = lightPass.pass;
|
||||
const auto &dynamicOffsets = lightPass.dynamicOffsets;
|
||||
auto * shader = lightPass.shader;
|
||||
const auto lights = lightPass.lights;
|
||||
auto * ia = subModel->getInputAssembler();
|
||||
auto * pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
auto * descriptorSet = subModel->getDescriptorSet();
|
||||
const auto & dynamicOffsets = lightPass.dynamicOffsets;
|
||||
auto * shader = lightPass.shader;
|
||||
const auto lights = lightPass.lights;
|
||||
auto * ia = subModel->getInputAssembler();
|
||||
auto * pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
auto * descriptorSet = subModel->getDescriptorSet();
|
||||
|
||||
cmdBuffer->bindPipelineState(pso);
|
||||
cmdBuffer->bindDescriptorSet(MATERIAL_SET, pass->getDescriptorSet());
|
||||
@@ -139,7 +139,7 @@ void RenderAdditiveLightQueue::gatherLightPasses(const Camera *camera, gfx::Comm
|
||||
_lightIndices.clear();
|
||||
for (size_t i = 0; i < _validLights.size(); i++) {
|
||||
const auto *const light = _validLights[i];
|
||||
const bool isCulled = cullingLight(light, model);
|
||||
const bool isCulled = cullingLight(light, model);
|
||||
if (!isCulled) {
|
||||
_lightIndices.emplace_back(i);
|
||||
}
|
||||
@@ -147,7 +147,7 @@ void RenderAdditiveLightQueue::gatherLightPasses(const Camera *camera, gfx::Comm
|
||||
|
||||
if (_lightIndices.empty()) continue;
|
||||
const auto *const subModelArrayID = model->getSubModelID();
|
||||
const auto subModelCount = subModelArrayID[0];
|
||||
const auto subModelCount = subModelArrayID[0];
|
||||
for (unsigned j = 1; j <= subModelCount; j++) {
|
||||
const auto lightPassIdx = lightPassIndices[j - 1];
|
||||
if (lightPassIdx == UINT_MAX) continue;
|
||||
@@ -192,8 +192,8 @@ void RenderAdditiveLightQueue::clear() {
|
||||
void RenderAdditiveLightQueue::gatherValidLights(const Camera *camera) {
|
||||
const auto *const scene = camera->getScene();
|
||||
const auto *const sphereLightArrayID = scene->getSphereLightArrayID();
|
||||
auto count = sphereLightArrayID ? sphereLightArrayID[0] : 0;
|
||||
Sphere sphere;
|
||||
auto count = sphereLightArrayID ? sphereLightArrayID[0] : 0;
|
||||
Sphere sphere;
|
||||
for (unsigned i = 1; i <= count; i++) {
|
||||
const auto *const light = scene->getSphereLight(sphereLightArrayID[i]);
|
||||
sphere.setCenter(light->position);
|
||||
@@ -204,7 +204,7 @@ void RenderAdditiveLightQueue::gatherValidLights(const Camera *camera) {
|
||||
}
|
||||
}
|
||||
const auto *const spotLightArrayID = scene->getSpotLightArrayID();
|
||||
count = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
count = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
for (unsigned i = 1; i <= count; i++) {
|
||||
const auto *const light = scene->getSpotLight(spotLightArrayID[i]);
|
||||
sphere.setCenter(light->position);
|
||||
@@ -219,9 +219,9 @@ void RenderAdditiveLightQueue::gatherValidLights(const Camera *camera) {
|
||||
bool RenderAdditiveLightQueue::cullingLight(const Light *light, const ModelView *model) {
|
||||
switch (light->getType()) {
|
||||
case LightType::SPHERE:
|
||||
return model->worldBoundsID && !aabb_aabb(model->getWorldBounds(), light->getAABB());
|
||||
return model->worldBoundsID && !aabbAabb(model->getWorldBounds(), light->getAABB());
|
||||
case LightType::SPOT:
|
||||
return model->worldBoundsID && (!aabb_aabb(model->getWorldBounds(), light->getAABB()) || !aabb_frustum(model->getWorldBounds(), light->getFrustum()));
|
||||
return model->worldBoundsID && (!aabbAabb(model->getWorldBounds(), light->getAABB()) || !aabbFrustum(model->getWorldBounds(), light->getFrustum()));
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
@@ -260,8 +260,8 @@ void RenderAdditiveLightQueue::addRenderQueue(const PassView *pass, const SubMod
|
||||
}
|
||||
|
||||
void RenderAdditiveLightQueue::updateUBOs(const Camera *camera, gfx::CommandBuffer *cmdBuffer) {
|
||||
const auto exposure = camera->exposure;
|
||||
const auto validLightCount = _validLights.size();
|
||||
const auto exposure = camera->exposure;
|
||||
const auto validLightCount = _validLights.size();
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
if (validLightCount > _lightBufferCount) {
|
||||
@@ -327,9 +327,9 @@ void RenderAdditiveLightQueue::updateUBOs(const Camera *camera, gfx::CommandBuff
|
||||
|
||||
void RenderAdditiveLightQueue::updateLightDescriptorSet(const Camera *camera, gfx::CommandBuffer *cmdBuffer) {
|
||||
auto *const sceneData = _pipeline->getPipelineSceneData();
|
||||
auto * shadowInfo = sceneData->getSharedData()->getShadows();
|
||||
auto * shadowInfo = sceneData->getSharedData()->getShadows();
|
||||
const auto *const scene = camera->getScene();
|
||||
const Light *mainLight = nullptr;
|
||||
const Light * mainLight = nullptr;
|
||||
if (scene->mainLightID) mainLight = scene->getMainLight();
|
||||
|
||||
for (const auto *light : _validLights) {
|
||||
@@ -398,10 +398,10 @@ bool RenderAdditiveLightQueue::getLightPassIndex(const ModelView *model, vector<
|
||||
bool hasValidLightPass = false;
|
||||
|
||||
const auto *const subModelArrayID = model->getSubModelID();
|
||||
const auto count = subModelArrayID[0];
|
||||
const auto count = subModelArrayID[0];
|
||||
for (unsigned i = 1; i <= count; i++) {
|
||||
const auto *const subModel = model->getSubModelView(subModelArrayID[i]);
|
||||
uint lightPassIndex = UINT_MAX;
|
||||
uint lightPassIndex = UINT_MAX;
|
||||
for (unsigned passIdx = 0; passIdx < subModel->passCount; passIdx++) {
|
||||
const auto *const pass = subModel->getPassView(passIdx);
|
||||
if (pass->phase == _phaseID) {
|
||||
|
||||
@@ -27,11 +27,11 @@
|
||||
#include <vector>
|
||||
|
||||
#include "Define.h"
|
||||
#include "helper/SharedMemory.h"
|
||||
#include "RenderPipeline.h"
|
||||
#include "SceneCulling.h"
|
||||
#include "gfx-base/GFXBuffer.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
#include "helper/SharedMemory.h"
|
||||
#include "math/Quaternion.h"
|
||||
#include "platform/Application.h"
|
||||
|
||||
@@ -43,8 +43,8 @@ AABB castWorldBounds;
|
||||
RenderObject genRenderObject(const ModelView *model, const Camera *camera) {
|
||||
float depth = 0;
|
||||
if (model->nodeID) {
|
||||
const auto node = model->getTransform();
|
||||
cc::Vec3 position;
|
||||
const auto *const node = model->getTransform();
|
||||
cc::Vec3 position;
|
||||
cc::Vec3::subtract(node->worldPosition, camera->position, &position);
|
||||
depth = position.dot(camera->forward);
|
||||
}
|
||||
@@ -64,76 +64,76 @@ void getShadowWorldMatrix(const Sphere *sphere, const cc::Vec4 &rotation, const
|
||||
}
|
||||
|
||||
void updateSphereLight(Shadows *shadows, const Light *light, std::array<float, UBOShadow::COUNT> &shadowUBO) {
|
||||
const auto node = light->getNode();
|
||||
const auto *const node = light->getNode();
|
||||
if (!node->flagsChanged && !shadows->dirty) {
|
||||
return;
|
||||
}
|
||||
|
||||
shadows->dirty = false;
|
||||
const auto position = node->worldPosition;
|
||||
const auto &normal = shadows->normal;
|
||||
const auto distance = shadows->distance + 0.001f; // avoid z-fighting
|
||||
const auto NdL = normal.dot(position);
|
||||
const auto lx = position.x;
|
||||
const auto ly = position.y;
|
||||
const auto lz = position.z;
|
||||
const auto nx = normal.x;
|
||||
const auto ny = normal.y;
|
||||
const auto nz = normal.z;
|
||||
auto &matLight = shadows->matLight;
|
||||
matLight.m[0] = NdL - distance - lx * nx;
|
||||
matLight.m[1] = -ly * nx;
|
||||
matLight.m[2] = -lz * nx;
|
||||
matLight.m[3] = -nx;
|
||||
matLight.m[4] = -lx * ny;
|
||||
matLight.m[5] = NdL - distance - ly * ny;
|
||||
matLight.m[6] = -lz * ny;
|
||||
matLight.m[7] = -ny;
|
||||
matLight.m[8] = -lx * nz;
|
||||
matLight.m[9] = -ly * nz;
|
||||
matLight.m[10] = NdL - distance - lz * nz;
|
||||
matLight.m[11] = -nz;
|
||||
matLight.m[12] = lx * distance;
|
||||
matLight.m[13] = ly * distance;
|
||||
matLight.m[14] = lz * distance;
|
||||
matLight.m[15] = NdL;
|
||||
shadows->dirty = false;
|
||||
const auto position = node->worldPosition;
|
||||
const auto &normal = shadows->normal;
|
||||
const auto distance = shadows->distance + 0.001F; // avoid z-fighting
|
||||
const auto ndL = normal.dot(position);
|
||||
const auto lx = position.x;
|
||||
const auto ly = position.y;
|
||||
const auto lz = position.z;
|
||||
const auto nx = normal.x;
|
||||
const auto ny = normal.y;
|
||||
const auto nz = normal.z;
|
||||
auto & matLight = shadows->matLight;
|
||||
matLight.m[0] = ndL - distance - lx * nx;
|
||||
matLight.m[1] = -ly * nx;
|
||||
matLight.m[2] = -lz * nx;
|
||||
matLight.m[3] = -nx;
|
||||
matLight.m[4] = -lx * ny;
|
||||
matLight.m[5] = ndL - distance - ly * ny;
|
||||
matLight.m[6] = -lz * ny;
|
||||
matLight.m[7] = -ny;
|
||||
matLight.m[8] = -lx * nz;
|
||||
matLight.m[9] = -ly * nz;
|
||||
matLight.m[10] = ndL - distance - lz * nz;
|
||||
matLight.m[11] = -nz;
|
||||
matLight.m[12] = lx * distance;
|
||||
matLight.m[13] = ly * distance;
|
||||
matLight.m[14] = lz * distance;
|
||||
matLight.m[15] = ndL;
|
||||
|
||||
memcpy(shadowUBO.data() + UBOShadow::MAT_LIGHT_PLANE_PROJ_OFFSET, matLight.m, sizeof(matLight));
|
||||
}
|
||||
|
||||
void updateDirLight(Shadows *shadows, const Light *light, std::array<float, UBOShadow::COUNT> &shadowUBO) {
|
||||
const auto node = light->getNode();
|
||||
const auto rotation = node->worldRotation;
|
||||
Quaternion _qt(rotation.x, rotation.y, rotation.z, rotation.w);
|
||||
Vec3 forward(0, 0, -1.0f);
|
||||
forward.transformQuat(_qt);
|
||||
const auto &normal = shadows->normal;
|
||||
const auto distance = shadows->distance + 0.001f; // avoid z-fighting
|
||||
const auto NdL = normal.dot(forward);
|
||||
const auto scale = 1.0f / NdL;
|
||||
const auto lx = forward.x * scale;
|
||||
const auto ly = forward.y * scale;
|
||||
const auto lz = forward.z * scale;
|
||||
const auto nx = normal.x;
|
||||
const auto ny = normal.y;
|
||||
const auto nz = normal.z;
|
||||
auto &matLight = shadows->matLight;
|
||||
matLight.m[0] = 1 - nx * lx;
|
||||
matLight.m[1] = -nx * ly;
|
||||
matLight.m[2] = -nx * lz;
|
||||
matLight.m[3] = 0;
|
||||
matLight.m[4] = -ny * lx;
|
||||
matLight.m[5] = 1 - ny * ly;
|
||||
matLight.m[6] = -ny * lz;
|
||||
matLight.m[7] = 0;
|
||||
matLight.m[8] = -nz * lx;
|
||||
matLight.m[9] = -nz * ly;
|
||||
matLight.m[10] = 1 - nz * lz;
|
||||
matLight.m[11] = 0;
|
||||
matLight.m[12] = lx * distance;
|
||||
matLight.m[13] = ly * distance;
|
||||
matLight.m[14] = lz * distance;
|
||||
matLight.m[15] = 1;
|
||||
const auto *const node = light->getNode();
|
||||
const auto rotation = node->worldRotation;
|
||||
Quaternion qt(rotation.x, rotation.y, rotation.z, rotation.w);
|
||||
Vec3 forward(0, 0, -1.0F);
|
||||
forward.transformQuat(qt);
|
||||
const auto &normal = shadows->normal;
|
||||
const auto distance = shadows->distance + 0.001F; // avoid z-fighting
|
||||
const auto ndL = normal.dot(forward);
|
||||
const auto scale = 1.0F / ndL;
|
||||
const auto lx = forward.x * scale;
|
||||
const auto ly = forward.y * scale;
|
||||
const auto lz = forward.z * scale;
|
||||
const auto nx = normal.x;
|
||||
const auto ny = normal.y;
|
||||
const auto nz = normal.z;
|
||||
auto & matLight = shadows->matLight;
|
||||
matLight.m[0] = 1 - nx * lx;
|
||||
matLight.m[1] = -nx * ly;
|
||||
matLight.m[2] = -nx * lz;
|
||||
matLight.m[3] = 0;
|
||||
matLight.m[4] = -ny * lx;
|
||||
matLight.m[5] = 1 - ny * ly;
|
||||
matLight.m[6] = -ny * lz;
|
||||
matLight.m[7] = 0;
|
||||
matLight.m[8] = -nz * lx;
|
||||
matLight.m[9] = -nz * ly;
|
||||
matLight.m[10] = 1 - nz * lz;
|
||||
matLight.m[11] = 0;
|
||||
matLight.m[12] = lx * distance;
|
||||
matLight.m[13] = ly * distance;
|
||||
matLight.m[14] = lz * distance;
|
||||
matLight.m[15] = 1;
|
||||
|
||||
memcpy(shadowUBO.data() + UBOShadow::MAT_LIGHT_PLANE_PROJ_OFFSET, matLight.m, sizeof(matLight));
|
||||
memcpy(shadowUBO.data() + UBOShadow::SHADOW_COLOR_OFFSET, &shadows->color, sizeof(Vec4));
|
||||
@@ -141,16 +141,16 @@ void updateDirLight(Shadows *shadows, const Light *light, std::array<float, UBOS
|
||||
|
||||
void lightCollecting(Camera *camera, std::vector<const Light *> &validLights) {
|
||||
validLights.clear();
|
||||
auto *sphere = CC_NEW(Sphere);
|
||||
const auto scene = camera->getScene();
|
||||
const Light *mainLight = nullptr;
|
||||
auto * sphere = CC_NEW(Sphere);
|
||||
const auto *const scene = camera->getScene();
|
||||
const Light * mainLight = nullptr;
|
||||
if (scene->mainLightID) mainLight = scene->getMainLight();
|
||||
validLights.emplace_back(mainLight);
|
||||
|
||||
const auto spotLightArrayID = scene->getSpotLightArrayID();
|
||||
const auto count = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
const auto *const spotLightArrayID = scene->getSpotLightArrayID();
|
||||
const auto count = spotLightArrayID ? spotLightArrayID[0] : 0;
|
||||
for (uint32_t i = 1; i <= count; ++i) {
|
||||
const auto *spotLight = scene->getSpotLight(spotLightArrayID[i]);
|
||||
const auto *spotLight = cc::pipeline::Scene::getSpotLight(spotLightArrayID[i]);
|
||||
sphere->center.set(spotLight->position);
|
||||
sphere->radius = spotLight->range;
|
||||
if (sphere->interset(*camera->getFrustum())) {
|
||||
@@ -162,28 +162,28 @@ void lightCollecting(Camera *camera, std::vector<const Light *> &validLights) {
|
||||
}
|
||||
|
||||
void shadowCollecting(RenderPipeline *pipeline, Camera *camera) {
|
||||
const auto scene = camera->getScene();
|
||||
const auto sceneData = pipeline->getPipelineSceneData();
|
||||
const auto *const scene = camera->getScene();
|
||||
auto *const sceneData = pipeline->getPipelineSceneData();
|
||||
|
||||
castBoundsInitialized = false;
|
||||
|
||||
RenderObjectList shadowObjects;
|
||||
|
||||
const auto models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
const auto *const models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
for (size_t i = 1; i <= modelCount; i++) {
|
||||
const auto model = scene->getModelView(models[i]);
|
||||
const auto *const model = cc::pipeline::Scene::getModelView(models[i]);
|
||||
|
||||
// filter model by view visibility
|
||||
if (model->enabled) {
|
||||
const auto visibility = camera->visibility;
|
||||
const auto node = model->getNode();
|
||||
const auto visibility = camera->visibility;
|
||||
const auto *const node = model->getNode();
|
||||
if ((model->nodeID && ((visibility & node->layer) == node->layer)) ||
|
||||
(visibility & model->visFlags)) {
|
||||
// shadow render Object
|
||||
if (model->castShadow && model->getWorldBounds()) {
|
||||
if (!castBoundsInitialized) {
|
||||
castWorldBounds = *model->getWorldBounds();
|
||||
castWorldBounds = *model->getWorldBounds();
|
||||
castBoundsInitialized = true;
|
||||
}
|
||||
castWorldBounds.merge(*model->getWorldBounds());
|
||||
@@ -199,11 +199,11 @@ void shadowCollecting(RenderPipeline *pipeline, Camera *camera) {
|
||||
}
|
||||
|
||||
void sceneCulling(RenderPipeline *pipeline, Camera *camera) {
|
||||
const auto sceneData = pipeline->getPipelineSceneData();
|
||||
const auto sharedData = sceneData->getSharedData();
|
||||
const auto shadows = sharedData->getShadows();
|
||||
const auto skyBox = sharedData->getSkybox();
|
||||
const auto scene = camera->getScene();
|
||||
auto *const sceneData = pipeline->getPipelineSceneData();
|
||||
auto *const sharedData = sceneData->getSharedData();
|
||||
auto *const shadows = sharedData->getShadows();
|
||||
auto *const skyBox = sharedData->getSkybox();
|
||||
const auto *const scene = camera->getScene();
|
||||
|
||||
const Light *mainLight = nullptr;
|
||||
if (scene->mainLightID) mainLight = scene->getMainLight();
|
||||
@@ -213,20 +213,19 @@ void sceneCulling(RenderPipeline *pipeline, Camera *camera) {
|
||||
renderObjects.emplace_back(genRenderObject(skyBox->getModel(), camera));
|
||||
}
|
||||
|
||||
const auto models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
const auto *const models = scene->getModels();
|
||||
const auto modelCount = models[0];
|
||||
for (size_t i = 1; i <= modelCount; i++) {
|
||||
const auto model = scene->getModelView(models[i]);
|
||||
const auto *const model = cc::pipeline::Scene::getModelView(models[i]);
|
||||
|
||||
// filter model by view visibility
|
||||
if (model->enabled) {
|
||||
const auto visibility = camera->visibility;
|
||||
const auto node = model->getNode();
|
||||
const auto visibility = camera->visibility;
|
||||
const auto *const node = model->getNode();
|
||||
if ((model->nodeID && ((visibility & node->layer) == node->layer)) ||
|
||||
(visibility & model->visFlags)) {
|
||||
|
||||
// frustum culling
|
||||
if ((model->worldBoundsID) && !aabb_frustum(model->getWorldBounds(), camera->getFrustum())) {
|
||||
if ((model->worldBoundsID) && !aabbFrustum(model->getWorldBounds(), camera->getFrustum())) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
@@ -28,34 +28,34 @@
|
||||
#include "BatchedBuffer.h"
|
||||
#include "Define.h"
|
||||
#include "InstancedBuffer.h"
|
||||
#include "PipelineSceneData.h"
|
||||
#include "PipelineStateManager.h"
|
||||
#include "PipelineUBO.h"
|
||||
#include "RenderBatchedQueue.h"
|
||||
#include "RenderInstancedQueue.h"
|
||||
#include "SceneCulling.h"
|
||||
#include "ShadowMapBatchedQueue.h"
|
||||
#include "forward/ForwardPipeline.h"
|
||||
#include "SceneCulling.h"
|
||||
#include "gfx-base/GFXCommandBuffer.h"
|
||||
#include "gfx-base/GFXDescriptorSet.h"
|
||||
#include "gfx-base/GFXDevice.h"
|
||||
#include "helper/SharedMemory.h"
|
||||
#include "PipelineSceneData.h"
|
||||
#include "PipelineUBO.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
ShadowMapBatchedQueue::ShadowMapBatchedQueue(ForwardPipeline *pipeline)
|
||||
: _phaseID(getPhaseID("shadow-caster")) {
|
||||
_pipeline = pipeline;
|
||||
_buffer = pipeline->getDescriptorSet()->getBuffer(UBOShadow::BINDING);
|
||||
_pipeline = pipeline;
|
||||
_buffer = pipeline->getDescriptorSet()->getBuffer(UBOShadow::BINDING);
|
||||
_instancedQueue = CC_NEW(RenderInstancedQueue);
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
_batchedQueue = CC_NEW(RenderBatchedQueue);
|
||||
}
|
||||
|
||||
void ShadowMapBatchedQueue::gatherLightPasses(const Light *light, gfx::CommandBuffer *cmdBufferer) {
|
||||
clear();
|
||||
|
||||
const auto *sceneData = _pipeline->getPipelineSceneData();
|
||||
const auto *shadowInfo = sceneData->getSharedData()->getShadows();
|
||||
const auto *sceneData = _pipeline->getPipelineSceneData();
|
||||
const auto *shadowInfo = sceneData->getSharedData()->getShadows();
|
||||
const auto &shadowObjects = sceneData->getShadowObjects();
|
||||
if (light && shadowInfo->enabled && shadowInfo->getShadowType() == ShadowType::SHADOWMAP) {
|
||||
_pipeline->getPipelineUBO()->updateShadowUBOLight(light);
|
||||
@@ -69,8 +69,8 @@ void ShadowMapBatchedQueue::gatherLightPasses(const Light *light, gfx::CommandBu
|
||||
break;
|
||||
case LightType::SPOT:
|
||||
if (model->getWorldBounds() &&
|
||||
(aabb_aabb(model->getWorldBounds(), light->getAABB()) ||
|
||||
aabb_frustum(model->getWorldBounds(), light->getFrustum()))) {
|
||||
(aabbAabb(model->getWorldBounds(), light->getAABB()) ||
|
||||
aabbFrustum(model->getWorldBounds(), light->getFrustum()))) {
|
||||
add(model, cmdBufferer);
|
||||
}
|
||||
break;
|
||||
@@ -95,12 +95,12 @@ void ShadowMapBatchedQueue::add(const ModelView *model, gfx::CommandBuffer *cmdB
|
||||
return;
|
||||
}
|
||||
|
||||
const auto subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
const auto *const subModelID = model->getSubModelID();
|
||||
const auto subModelCount = subModelID[0];
|
||||
for (unsigned m = 1; m <= subModelCount; ++m) {
|
||||
const auto subModel = model->getSubModelView(subModelID[m]);
|
||||
const auto pass = subModel->getPassView(shadowPassIdx);
|
||||
const auto batchingScheme = pass->getBatchingScheme();
|
||||
const auto *const subModel = cc::pipeline::ModelView::getSubModelView(subModelID[m]);
|
||||
const auto *const pass = subModel->getPassView(shadowPassIdx);
|
||||
const auto batchingScheme = pass->getBatchingScheme();
|
||||
|
||||
if (batchingScheme == BatchingSchemes::INSTANCING) {
|
||||
auto *instancedBuffer = InstancedBuffer::get(subModel->passID[shadowPassIdx]);
|
||||
@@ -126,11 +126,11 @@ void ShadowMapBatchedQueue::recordCommandBuffer(gfx::Device *device, gfx::Render
|
||||
_batchedQueue->recordCommandBuffer(device, renderPass, cmdBuffer);
|
||||
|
||||
for (size_t i = 0; i < _subModels.size(); i++) {
|
||||
const auto subModel = _subModels[i];
|
||||
const auto shader = _shaders[i];
|
||||
const auto pass = _passes[i];
|
||||
const auto ia = subModel->getInputAssembler();
|
||||
const auto pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
const auto *const subModel = _subModels[i];
|
||||
auto *const shader = _shaders[i];
|
||||
const auto *const pass = _passes[i];
|
||||
auto *const ia = subModel->getInputAssembler();
|
||||
auto *const pso = PipelineStateManager::getOrCreatePipelineState(pass, shader, ia, renderPass);
|
||||
|
||||
cmdBuffer->bindPipelineState(pso);
|
||||
cmdBuffer->bindDescriptorSet(MATERIAL_SET, pass->getDescriptorSet());
|
||||
@@ -149,14 +149,14 @@ void ShadowMapBatchedQueue::destroy() {
|
||||
}
|
||||
|
||||
int ShadowMapBatchedQueue::getShadowPassIndex(const ModelView *model) const {
|
||||
const auto subModelArrayID = model->getSubModelID();
|
||||
const auto count = subModelArrayID[0];
|
||||
const auto *const subModelArrayID = model->getSubModelID();
|
||||
const auto count = subModelArrayID[0];
|
||||
for (unsigned i = 1; i <= count; i++) {
|
||||
const auto subModel = model->getSubModelView(subModelArrayID[i]);
|
||||
const auto *const subModel = cc::pipeline::ModelView::getSubModelView(subModelArrayID[i]);
|
||||
for (unsigned passIdx = 0; passIdx < subModel->passCount; passIdx++) {
|
||||
const auto pass = subModel->getPassView(passIdx);
|
||||
const auto *const pass = subModel->getPassView(passIdx);
|
||||
if (pass->phase == _phaseID) {
|
||||
return passIdx;
|
||||
return static_cast<int>(passIdx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -43,14 +43,14 @@
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
namespace {
|
||||
#define TO_VEC3(dst, src, offset) \
|
||||
dst[offset] = (src).x; \
|
||||
(dst)[(offset) + 1] = (src).y; \
|
||||
#define TO_VEC3(dst, src, offset) \
|
||||
dst[offset] = (src).x; \
|
||||
(dst)[(offset) + 1] = (src).y; \
|
||||
(dst)[(offset) + 2] = (src).z;
|
||||
#define TO_VEC4(dst, src, offset) \
|
||||
dst[offset] = (src).x; \
|
||||
(dst)[(offset) + 1] = (src).y; \
|
||||
(dst)[(offset) + 2] = (src).z; \
|
||||
#define TO_VEC4(dst, src, offset) \
|
||||
dst[offset] = (src).x; \
|
||||
(dst)[(offset) + 1] = (src).y; \
|
||||
(dst)[(offset) + 2] = (src).z; \
|
||||
(dst)[(offset) + 3] = (src).w;
|
||||
} // namespace
|
||||
|
||||
@@ -59,7 +59,7 @@ gfx::RenderPass *DeferredPipeline::getOrCreateRenderPass(gfx::ClearFlags clearFl
|
||||
return _renderPasses[clearFlags];
|
||||
}
|
||||
|
||||
auto * device = gfx::Device::getInstance();
|
||||
auto * device = gfx::Device::getInstance();
|
||||
gfx::ColorAttachment colorAttachment;
|
||||
gfx::DepthStencilAttachment depthStencilAttachment;
|
||||
colorAttachment.format = device->getColorFormat();
|
||||
@@ -82,7 +82,7 @@ gfx::RenderPass *DeferredPipeline::getOrCreateRenderPass(gfx::ClearFlags clearFl
|
||||
depthStencilAttachment.beginAccesses = {gfx::AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE};
|
||||
}
|
||||
|
||||
auto *renderPass = device->createRenderPass({
|
||||
auto *renderPass = device->createRenderPass({
|
||||
{colorAttachment},
|
||||
depthStencilAttachment,
|
||||
});
|
||||
@@ -144,17 +144,17 @@ void DeferredPipeline::render(const vector<uint> &cameras) {
|
||||
}
|
||||
|
||||
void DeferredPipeline::updateQuadVertexData(const gfx::Rect &renderArea) {
|
||||
if (_lastUsedRenderArea == renderArea) {
|
||||
return;
|
||||
}
|
||||
if (_lastUsedRenderArea == renderArea) {
|
||||
return;
|
||||
}
|
||||
|
||||
_lastUsedRenderArea = renderArea;
|
||||
float vbData[16] = {0};
|
||||
genQuadVertexData(gfx::SurfaceTransform::IDENTITY, renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOffscreen, vbData);
|
||||
_lastUsedRenderArea = renderArea;
|
||||
float vbData[16] = {0};
|
||||
genQuadVertexData(gfx::SurfaceTransform::IDENTITY, renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOffscreen, vbData);
|
||||
|
||||
genQuadVertexData(_device->getSurfaceTransform(), renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOnscreen, vbData);
|
||||
genQuadVertexData(_device->getSurfaceTransform(), renderArea, vbData);
|
||||
_commandBuffers[0]->updateBuffer(_quadVBOnscreen, vbData);
|
||||
}
|
||||
|
||||
void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform, const gfx::Rect &renderArea, float *vbData) {
|
||||
@@ -163,13 +163,13 @@ void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform,
|
||||
float minY = float(renderArea.y) / _device->getHeight();
|
||||
float maxY = float(renderArea.y + renderArea.height) / _device->getHeight();
|
||||
|
||||
int n = 0;
|
||||
int n = 0;
|
||||
switch (surfaceTransform) {
|
||||
case (gfx::SurfaceTransform::IDENTITY):
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
@@ -188,7 +188,7 @@ void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform,
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = maxX; // uv
|
||||
vbData[n++] = maxX; // uv
|
||||
vbData[n++] = maxY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
@@ -207,7 +207,7 @@ void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform,
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
@@ -226,7 +226,7 @@ void DeferredPipeline::genQuadVertexData(gfx::SurfaceTransform surfaceTransform,
|
||||
n = 0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = -1.0;
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minX; // uv
|
||||
vbData[n++] = minY;
|
||||
vbData[n++] = 1.0;
|
||||
vbData[n++] = -1.0;
|
||||
@@ -253,7 +253,7 @@ bool DeferredPipeline::createQuadInputAssembler(gfx::Buffer **quadIB, gfx::Buffe
|
||||
|
||||
if (*quadVB == nullptr) {
|
||||
*quadVB = _device->createBuffer({gfx::BufferUsageBit::VERTEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE, vbSize, vbStride});
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE, vbSize, vbStride});
|
||||
}
|
||||
|
||||
if (*quadVB == nullptr) {
|
||||
@@ -265,7 +265,7 @@ bool DeferredPipeline::createQuadInputAssembler(gfx::Buffer **quadIB, gfx::Buffe
|
||||
uint ibSize = ibStride * 6;
|
||||
if (*quadIB == nullptr) {
|
||||
*quadIB = _device->createBuffer({gfx::BufferUsageBit::INDEX | gfx::BufferUsageBit::TRANSFER_DST,
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE, ibSize, ibStride});
|
||||
gfx::MemoryUsageBit::HOST | gfx::MemoryUsageBit::DEVICE, ibSize, ibStride});
|
||||
}
|
||||
|
||||
if (*quadIB == nullptr) {
|
||||
@@ -281,7 +281,7 @@ bool DeferredPipeline::createQuadInputAssembler(gfx::Buffer **quadIB, gfx::Buffe
|
||||
info.attributes.push_back({"a_texCoord", gfx::Format::RG32F});
|
||||
info.vertexBuffers.push_back(*quadVB);
|
||||
info.indexBuffer = *quadIB;
|
||||
*quadIA = _device->createInputAssembler(info);
|
||||
*quadIA = _device->createInputAssembler(info);
|
||||
return (*quadIA) != nullptr;
|
||||
}
|
||||
|
||||
@@ -343,7 +343,7 @@ bool DeferredPipeline::activeRenderer() {
|
||||
gfx::Address::CLAMP,
|
||||
gfx::Address::CLAMP,
|
||||
};
|
||||
const auto samplerHash = SamplerLib::genSamplerHash(info);
|
||||
const auto samplerHash = SamplerLib::genSamplerHash(info);
|
||||
auto *const sampler = SamplerLib::getSampler(samplerHash);
|
||||
|
||||
// Main light sampler binding
|
||||
|
||||
@@ -27,10 +27,10 @@
|
||||
|
||||
#include <array>
|
||||
|
||||
#include "pipeline/RenderPipeline.h"
|
||||
#include "pipeline/helper/SharedMemory.h"
|
||||
#include "gfx-base/GFXBuffer.h"
|
||||
#include "gfx-base/GFXInputAssembler.h"
|
||||
#include "pipeline/RenderPipeline.h"
|
||||
#include "pipeline/helper/SharedMemory.h"
|
||||
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
@@ -45,16 +45,16 @@ struct Sphere;
|
||||
struct Camera;
|
||||
|
||||
struct CC_DLL DeferredRenderData {
|
||||
gfx::TextureList gbufferRenderTargets;
|
||||
gfx::Framebuffer *gbufferFrameBuffer = nullptr;
|
||||
gfx::Framebuffer *lightingFrameBuff = nullptr;
|
||||
gfx::Texture *lightingRenderTarget = nullptr;
|
||||
gfx::Texture *depthTex = nullptr;
|
||||
gfx::TextureList gbufferRenderTargets;
|
||||
gfx::Framebuffer *gbufferFrameBuffer = nullptr;
|
||||
gfx::Framebuffer *lightingFrameBuff = nullptr;
|
||||
gfx::Texture * lightingRenderTarget = nullptr;
|
||||
gfx::Texture * depthTex = nullptr;
|
||||
};
|
||||
|
||||
class CC_DLL DeferredPipeline : public RenderPipeline {
|
||||
public:
|
||||
DeferredPipeline() = default;
|
||||
DeferredPipeline() = default;
|
||||
~DeferredPipeline() override = default;
|
||||
|
||||
bool initialize(const RenderPipelineInfo &info) override;
|
||||
@@ -70,12 +70,12 @@ public:
|
||||
CC_INLINE const gfx::BufferList &getLightBuffers() const { return _lightBuffers; }
|
||||
CC_INLINE const UintList &getLightIndexOffsets() const { return _lightIndexOffsets; }
|
||||
CC_INLINE const UintList &getLightIndices() const { return _lightIndices; }
|
||||
gfx::InputAssembler *getQuadIAOnScreen(){return _quadIAOnscreen;}
|
||||
gfx::InputAssembler *getQuadIAOffScreen(){return _quadIAOffscreen;}
|
||||
gfx::Rect getRenderArea(Camera *camera, bool onScreen);
|
||||
CC_INLINE DeferredRenderData *getDeferredRenderData(){return _deferredRenderData; };
|
||||
void updateQuadVertexData(const gfx::Rect &renderArea);
|
||||
void genQuadVertexData(gfx::SurfaceTransform surfaceTransform, const gfx::Rect &renderArea, float *data);
|
||||
gfx::InputAssembler * getQuadIAOnScreen() { return _quadIAOnscreen; }
|
||||
gfx::InputAssembler * getQuadIAOffScreen() { return _quadIAOffscreen; }
|
||||
gfx::Rect getRenderArea(Camera *camera, bool onScreen);
|
||||
CC_INLINE DeferredRenderData *getDeferredRenderData() { return _deferredRenderData; };
|
||||
void updateQuadVertexData(const gfx::Rect &renderArea);
|
||||
void genQuadVertexData(gfx::SurfaceTransform surfaceTransform, const gfx::Rect &renderArea, float *data);
|
||||
|
||||
private:
|
||||
bool activeRenderer();
|
||||
@@ -84,27 +84,26 @@ private:
|
||||
void destroyDeferredData();
|
||||
void generateDeferredRenderData();
|
||||
|
||||
|
||||
gfx::Buffer *_lightsUBO = nullptr;
|
||||
LightList _validLights;
|
||||
gfx::BufferList _lightBuffers;
|
||||
UintList _lightIndexOffsets;
|
||||
UintList _lightIndices;
|
||||
gfx::Buffer * _lightsUBO = nullptr;
|
||||
LightList _validLights;
|
||||
gfx::BufferList _lightBuffers;
|
||||
UintList _lightIndexOffsets;
|
||||
UintList _lightIndices;
|
||||
map<gfx::ClearFlags, gfx::RenderPass *> _renderPasses;
|
||||
gfx::Rect _lastUsedRenderArea;
|
||||
gfx::Rect _lastUsedRenderArea;
|
||||
|
||||
// light stage
|
||||
gfx::Buffer *_quadIB = nullptr;
|
||||
gfx::Buffer *_quadVBOnscreen = nullptr;
|
||||
gfx::Buffer *_quadVBOffscreen = nullptr;
|
||||
gfx::InputAssembler *_quadIAOnscreen = nullptr;
|
||||
gfx::Buffer * _quadIB = nullptr;
|
||||
gfx::Buffer * _quadVBOnscreen = nullptr;
|
||||
gfx::Buffer * _quadVBOffscreen = nullptr;
|
||||
gfx::InputAssembler *_quadIAOnscreen = nullptr;
|
||||
gfx::InputAssembler *_quadIAOffscreen = nullptr;
|
||||
|
||||
DeferredRenderData *_deferredRenderData = nullptr;
|
||||
gfx::RenderPass *_gbufferRenderPass = nullptr;
|
||||
gfx::RenderPass *_lightingRenderPass = nullptr;
|
||||
uint _width;
|
||||
uint _height;
|
||||
gfx::RenderPass * _gbufferRenderPass = nullptr;
|
||||
gfx::RenderPass * _lightingRenderPass = nullptr;
|
||||
uint _width;
|
||||
uint _height;
|
||||
};
|
||||
|
||||
} // namespace pipeline
|
||||
|
||||
@@ -30,27 +30,27 @@
|
||||
namespace cc {
|
||||
namespace pipeline {
|
||||
|
||||
const se::PoolType ModelView::type = se::PoolType::MODEL;
|
||||
const se::PoolType SubModelView::type = se::PoolType::SUB_MODEL;
|
||||
const se::PoolType PassView::type = se::PoolType::PASS;
|
||||
const se::PoolType Camera::type = se::PoolType::CAMERA;
|
||||
const se::PoolType AABB::type = se::PoolType::AABB;
|
||||
const se::PoolType Frustum::type = se::PoolType::FRUSTUM;
|
||||
const se::PoolType Scene::type = se::PoolType::SCENE;
|
||||
const se::PoolType Light::type = se::PoolType::LIGHT;
|
||||
const se::PoolType Ambient::type = se::PoolType::AMBIENT;
|
||||
const se::PoolType Fog::type = se::PoolType::FOG;
|
||||
const se::PoolType Skybox::type = se::PoolType::SKYBOX;
|
||||
const se::PoolType InstancedAttributeView::type = se::PoolType::INSTANCED_ATTRIBUTE;
|
||||
const se::PoolType FlatBufferView::type = se::PoolType::FLAT_BUFFER;
|
||||
const se::PoolType RenderingSubMesh::type = se::PoolType::SUB_MESH;
|
||||
const se::PoolType Node::type = se::PoolType::NODE;
|
||||
const se::PoolType Root::type = se::PoolType::ROOT;
|
||||
const se::PoolType RenderWindow::type = se::PoolType::RENDER_WINDOW;
|
||||
const se::PoolType Shadows::type = se::PoolType::SHADOW;
|
||||
const se::PoolType Sphere::type = se::PoolType::SPHERE;
|
||||
const se::PoolType UIBatch::type = se::PoolType::UI_BATCH;
|
||||
const se::PoolType PipelineSharedSceneData::type = se::PoolType::PIPELINE_SHARED_SCENE_DATA;
|
||||
const se::PoolType ModelView::TYPE = se::PoolType::MODEL;
|
||||
const se::PoolType SubModelView::TYPE = se::PoolType::SUB_MODEL;
|
||||
const se::PoolType PassView::TYPE = se::PoolType::PASS;
|
||||
const se::PoolType Camera::TYPE = se::PoolType::CAMERA;
|
||||
const se::PoolType AABB::TYPE = se::PoolType::AABB;
|
||||
const se::PoolType Frustum::TYPE = se::PoolType::FRUSTUM;
|
||||
const se::PoolType Scene::TYPE = se::PoolType::SCENE;
|
||||
const se::PoolType Light::TYPE = se::PoolType::LIGHT;
|
||||
const se::PoolType Ambient::TYPE = se::PoolType::AMBIENT;
|
||||
const se::PoolType Fog::TYPE = se::PoolType::FOG;
|
||||
const se::PoolType Skybox::TYPE = se::PoolType::SKYBOX;
|
||||
const se::PoolType InstancedAttributeView::TYPE = se::PoolType::INSTANCED_ATTRIBUTE;
|
||||
const se::PoolType FlatBufferView::TYPE = se::PoolType::FLAT_BUFFER;
|
||||
const se::PoolType RenderingSubMesh::TYPE = se::PoolType::SUB_MESH;
|
||||
const se::PoolType Node::TYPE = se::PoolType::NODE;
|
||||
const se::PoolType Root::TYPE = se::PoolType::ROOT;
|
||||
const se::PoolType RenderWindow::TYPE = se::PoolType::RENDER_WINDOW;
|
||||
const se::PoolType Shadows::TYPE = se::PoolType::SHADOW;
|
||||
const se::PoolType Sphere::TYPE = se::PoolType::SPHERE;
|
||||
const se::PoolType UIBatch::TYPE = se::PoolType::UI_BATCH;
|
||||
const se::PoolType PipelineSharedSceneData::TYPE = se::PoolType::PIPELINE_SHARED_SCENE_DATA;
|
||||
|
||||
void AABB::getBoundary(cc::Vec3 &minPos, cc::Vec3 &maxPos) const {
|
||||
minPos = center - halfExtents;
|
||||
@@ -62,14 +62,15 @@ void AABB::merge(const AABB &aabb) {
|
||||
cc::Vec3 minB = aabb.center - aabb.halfExtents;
|
||||
cc::Vec3 maxA = center + halfExtents;
|
||||
cc::Vec3 maxB = aabb.center + aabb.halfExtents;
|
||||
cc::Vec3 maxP, minP;
|
||||
cc::Vec3 maxP;
|
||||
cc::Vec3 minP;
|
||||
cc::Vec3::max(maxA, maxB, &maxP);
|
||||
cc::Vec3::min(minA, minB, &minP);
|
||||
|
||||
cc::Vec3 addP = maxP + minP;
|
||||
cc::Vec3 subP = maxP - minP;
|
||||
center = addP * 0.5f;
|
||||
halfExtents = subP * 0.5f;
|
||||
center = addP * 0.5F;
|
||||
halfExtents = subP * 0.5F;
|
||||
}
|
||||
|
||||
int Sphere::interset(const Plane &plane) const {
|
||||
@@ -87,7 +88,7 @@ int Sphere::interset(const Plane &plane) const {
|
||||
}
|
||||
|
||||
bool Sphere::interset(const Frustum &frustum) const {
|
||||
for (const auto &plane : frustum.planes) {
|
||||
for (const auto &plane : frustum.planes) { // NOLINT
|
||||
if (this->interset(plane) == -1) {
|
||||
return false;
|
||||
}
|
||||
@@ -97,7 +98,7 @@ bool Sphere::interset(const Frustum &frustum) const {
|
||||
}
|
||||
|
||||
void Sphere::mergePoint(const cc::Vec3 &point) {
|
||||
if (radius < 0.0f) {
|
||||
if (radius < 0.0F) {
|
||||
center = point;
|
||||
radius = 0.0;
|
||||
return;
|
||||
@@ -107,7 +108,7 @@ void Sphere::mergePoint(const cc::Vec3 &point) {
|
||||
auto distance = offset.length();
|
||||
|
||||
if (distance > radius) {
|
||||
auto half = (distance - radius) * 0.5f;
|
||||
auto half = (distance - radius) * 0.5F;
|
||||
radius += half;
|
||||
offset.scale(half / distance);
|
||||
center += offset;
|
||||
@@ -115,52 +116,58 @@ void Sphere::mergePoint(const cc::Vec3 &point) {
|
||||
}
|
||||
|
||||
void Sphere::define(const AABB &aabb) {
|
||||
cc::Vec3 minPos, maxPos;
|
||||
cc::Vec3 minPos;
|
||||
cc::Vec3 maxPos;
|
||||
aabb.getBoundary(minPos, maxPos);
|
||||
|
||||
// Initialize sphere
|
||||
center.set(minPos);
|
||||
radius = 0.0f;
|
||||
radius = 0.0F;
|
||||
|
||||
// Calculate sphere
|
||||
const cc::Vec3 offset = maxPos - center;
|
||||
const float dist = offset.length();
|
||||
|
||||
const float half = dist * 0.5f;
|
||||
radius += dist * 0.5f;
|
||||
const float half = dist * 0.5F;
|
||||
radius += dist * 0.5F;
|
||||
center += (half / dist) * offset;
|
||||
}
|
||||
|
||||
void Sphere::mergeAABB(const AABB *aabb) {
|
||||
cc::Vec3 minPos, maxPos;
|
||||
cc::Vec3 minPos;
|
||||
cc::Vec3 maxPos;
|
||||
aabb->getBoundary(minPos, maxPos);
|
||||
mergePoint(minPos);
|
||||
mergePoint(maxPos);
|
||||
}
|
||||
|
||||
int sphere_plane(const Sphere *sphere, const Plane *plane) {
|
||||
int spherePlane(const Sphere *sphere, const Plane *plane) {
|
||||
const auto dot = cc::Vec3::dot(plane->normal, sphere->center);
|
||||
const auto r = sphere->radius * plane->normal.length();
|
||||
if (dot + r < plane->distance) {
|
||||
return -1;
|
||||
} else if (dot - r > plane->distance) {
|
||||
}
|
||||
if (dot - r > plane->distance) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
};
|
||||
|
||||
bool sphere_frustum(const Sphere *sphere, const Frustum *frustum) {
|
||||
for (auto i = 0; i < PLANE_LENGTH; i++) {
|
||||
bool sphere_frustum(const Sphere *sphere, const Frustum *frustum) { // NOLINT
|
||||
for (const auto &plane : frustum->planes) {
|
||||
// frustum plane normal points to the inside
|
||||
if (sphere_plane(sphere, &frustum->planes[i]) == -1) {
|
||||
if (spherePlane(sphere, &plane) == -1) {
|
||||
return false;
|
||||
}
|
||||
} // completely outside
|
||||
return true;
|
||||
}
|
||||
|
||||
bool aabb_aabb(const AABB *aabb1, const AABB *aabb2) {
|
||||
cc::Vec3 aMin, aMax, bMin, bMax;
|
||||
bool aabbAabb(const AABB *aabb1, const AABB *aabb2) {
|
||||
cc::Vec3 aMin;
|
||||
cc::Vec3 aMax;
|
||||
cc::Vec3 bMin;
|
||||
cc::Vec3 bMax;
|
||||
cc::Vec3::subtract(aabb1->center, aabb1->halfExtents, &aMin);
|
||||
cc::Vec3::add(aabb1->center, aabb1->halfExtents, &aMax);
|
||||
cc::Vec3::subtract(aabb2->center, aabb2->halfExtents, &bMin);
|
||||
@@ -170,7 +177,7 @@ bool aabb_aabb(const AABB *aabb1, const AABB *aabb2) {
|
||||
(aMin.z <= bMax.z && aMax.z >= bMin.z);
|
||||
}
|
||||
|
||||
int aabb_plane(const AABB *aabb, const Plane *plane) {
|
||||
int aabbPlane(const AABB *aabb, const Plane *plane) {
|
||||
const auto &halfExtents = aabb->halfExtents;
|
||||
auto r = halfExtents.x * std::abs(plane->normal.x) +
|
||||
halfExtents.y * std::abs(plane->normal.y) +
|
||||
@@ -178,31 +185,32 @@ int aabb_plane(const AABB *aabb, const Plane *plane) {
|
||||
auto dot = Vec3::dot(plane->normal, aabb->center);
|
||||
if (dot + r < plane->distance) {
|
||||
return -1;
|
||||
} else if (dot - r > plane->distance) {
|
||||
}
|
||||
if (dot - r > plane->distance) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
};
|
||||
|
||||
bool aabb_frustum(const AABB *aabb, const Frustum *frustum) {
|
||||
for (size_t i = 0; i < PLANE_LENGTH; i++) {
|
||||
bool aabbFrustum(const AABB *aabb, const Frustum *frustum) {
|
||||
for (const auto &plane : frustum->planes) {
|
||||
// frustum plane normal points to the inside
|
||||
if (aabb_plane(aabb, &frustum->planes[i]) == -1) {
|
||||
return 0;
|
||||
if (aabbPlane(aabb, &plane) == -1) {
|
||||
return false;
|
||||
}
|
||||
} // completely outside
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
gfx::BlendState *getBlendStateImpl(uint index) {
|
||||
static gfx::BlendState blendState;
|
||||
auto buffer = SharedMemory::getBuffer<uint32_t>(se::PoolType::BLEND_STATE, index);
|
||||
memcpy(&blendState, buffer, 24);
|
||||
auto * buffer = SharedMemory::getBuffer<uint32_t>(se::PoolType::BLEND_STATE, index);
|
||||
memcpy(&blendState, buffer, 24); // NOLINT
|
||||
|
||||
uint32_t targetArrayHandle = *(buffer + 6);
|
||||
const auto targetsHandle = GET_BLEND_TARGET_ARRAY(targetArrayHandle);
|
||||
uint32_t targetLen = targetsHandle[0];
|
||||
auto & targets = blendState.targets;
|
||||
uint32_t targetArrayHandle = *(buffer + 6);
|
||||
auto *const targetsHandle = GET_BLEND_TARGET_ARRAY(targetArrayHandle);
|
||||
uint32_t targetLen = targetsHandle[0];
|
||||
auto & targets = blendState.targets;
|
||||
targets.resize(targetLen);
|
||||
for (uint32_t i = 1; i <= targetLen; ++i) {
|
||||
memcpy(&targets[i - 1], GET_BLEND_TARGET(targetsHandle[i]), sizeof(gfx::BlendTarget));
|
||||
|
||||
@@ -29,6 +29,7 @@
|
||||
#include "bindings/dop/BufferAllocator.h"
|
||||
#include "bindings/dop/BufferPool.h"
|
||||
#include "bindings/dop/ObjectPool.h"
|
||||
#include "bindings/dop/PoolType.h"
|
||||
#include "math/Vec2.h"
|
||||
#include "math/Vec3.h"
|
||||
#include "math/Vec4.h"
|
||||
@@ -43,31 +44,31 @@ namespace pipeline {
|
||||
extern gfx::BlendState *getBlendStateImpl(uint index);
|
||||
|
||||
//Get buffer pool data
|
||||
#define GET_SUBMODEL(index) SharedMemory::getBuffer<SubModelView>(index)
|
||||
#define GET_PASS(index) SharedMemory::getBuffer<PassView>(index)
|
||||
#define GET_MODEL(index) SharedMemory::getBuffer<ModelView>(index)
|
||||
#define GET_FLAT_BUFFER(index) SharedMemory::getBuffer<FlatBufferView>(index)
|
||||
#define GET_INSTANCE_ATTRIBUTE(index) SharedMemory::getBuffer<InstancedAttributeView>(index)
|
||||
#define GET_RENDER_SUBMESH(index) SharedMemory::getBuffer<RenderingSubMesh>(index)
|
||||
#define GET_BUFFERVIEW(index) SharedMemory::getBuffer<BufferView>(index)
|
||||
#define GET_NODE(index) SharedMemory::getBuffer<Node>(index)
|
||||
#define GET_ROOT() SharedMemory::getBuffer<Root>(se::BufferPool::getPoolFlag())
|
||||
#define GET_CAMERA(index) SharedMemory::getBuffer<Camera>(index)
|
||||
#define GET_SCENE(index) SharedMemory::getBuffer<Scene>(index)
|
||||
#define GET_LIGHT(index) SharedMemory::getBuffer<Light>(index)
|
||||
#define GET_AMBIENT(index) SharedMemory::getBuffer<Ambient>(index)
|
||||
#define GET_FOG(index) SharedMemory::getBuffer<Fog>(index)
|
||||
#define GET_SKYBOX(index) SharedMemory::getBuffer<Skybox>(index)
|
||||
#define GET_FRUSTUM(index) SharedMemory::getBuffer<Frustum>(index)
|
||||
#define GET_AABB(index) SharedMemory::getBuffer<AABB>(index)
|
||||
#define GET_WINDOW(index) SharedMemory::getBuffer<RenderWindow>(index)
|
||||
#define GET_SHADOWS(index) SharedMemory::getBuffer<Shadows>(index)
|
||||
#define GET_SPHERE(index) SharedMemory::getBuffer<Sphere>(index)
|
||||
#define GET_RASTERIZER_STATE(index) SharedMemory::getBuffer<gfx::RasterizerState>(se::PoolType::RASTERIZER_STATE, index)
|
||||
#define GET_DEPTH_STENCIL_STATE(index) SharedMemory::getBuffer<gfx::DepthStencilState>(se::PoolType::DEPTH_STENCIL_STATE, index)
|
||||
#define GET_BLEND_TARGET(index) SharedMemory::getBuffer<gfx::BlendTarget>(se::PoolType::BLEND_TARGET, index)
|
||||
#define GET_BLEND_STATE(index) getBlendStateImpl(index)
|
||||
#define GET_UI_BATCH(index) SharedMemory::getBuffer<UIBatch>(index)
|
||||
#define GET_SUBMODEL(index) SharedMemory::getBuffer<SubModelView>(index)
|
||||
#define GET_PASS(index) SharedMemory::getBuffer<PassView>(index)
|
||||
#define GET_MODEL(index) SharedMemory::getBuffer<ModelView>(index)
|
||||
#define GET_FLAT_BUFFER(index) SharedMemory::getBuffer<FlatBufferView>(index)
|
||||
#define GET_INSTANCE_ATTRIBUTE(index) SharedMemory::getBuffer<InstancedAttributeView>(index)
|
||||
#define GET_RENDER_SUBMESH(index) SharedMemory::getBuffer<RenderingSubMesh>(index)
|
||||
#define GET_BUFFERVIEW(index) SharedMemory::getBuffer<BufferView>(index)
|
||||
#define GET_NODE(index) SharedMemory::getBuffer<Node>(index)
|
||||
#define GET_ROOT() SharedMemory::getBuffer<Root>(se::BufferPool::getPoolFlag())
|
||||
#define GET_CAMERA(index) SharedMemory::getBuffer<Camera>(index)
|
||||
#define GET_SCENE(index) SharedMemory::getBuffer<Scene>(index)
|
||||
#define GET_LIGHT(index) SharedMemory::getBuffer<Light>(index)
|
||||
#define GET_AMBIENT(index) SharedMemory::getBuffer<Ambient>(index)
|
||||
#define GET_FOG(index) SharedMemory::getBuffer<Fog>(index)
|
||||
#define GET_SKYBOX(index) SharedMemory::getBuffer<Skybox>(index)
|
||||
#define GET_FRUSTUM(index) SharedMemory::getBuffer<Frustum>(index)
|
||||
#define GET_AABB(index) SharedMemory::getBuffer<AABB>(index)
|
||||
#define GET_WINDOW(index) SharedMemory::getBuffer<RenderWindow>(index)
|
||||
#define GET_SHADOWS(index) SharedMemory::getBuffer<Shadows>(index)
|
||||
#define GET_SPHERE(index) SharedMemory::getBuffer<Sphere>(index)
|
||||
#define GET_RASTERIZER_STATE(index) SharedMemory::getBuffer<gfx::RasterizerState>(se::PoolType::RASTERIZER_STATE, index)
|
||||
#define GET_DEPTH_STENCIL_STATE(index) SharedMemory::getBuffer<gfx::DepthStencilState>(se::PoolType::DEPTH_STENCIL_STATE, index)
|
||||
#define GET_BLEND_TARGET(index) SharedMemory::getBuffer<gfx::BlendTarget>(se::PoolType::BLEND_TARGET, index)
|
||||
#define GET_BLEND_STATE(index) getBlendStateImpl(index)
|
||||
#define GET_UI_BATCH(index) SharedMemory::getBuffer<UIBatch>(index)
|
||||
#define GET_PIPELINE_SHARED_SCENE_DATA(index) SharedMemory::getBuffer<PipelineSharedSceneData>(index)
|
||||
|
||||
//Get object pool data
|
||||
@@ -91,42 +92,48 @@ extern gfx::BlendState *getBlendStateImpl(uint index);
|
||||
// Get raw buffer or gfx object.
|
||||
#define GET_RAW_BUFFER(index, size) SharedMemory::getRawBuffer<uint8_t>(se::PoolType::RAW_BUFFER, index, size)
|
||||
|
||||
static const float SHADOW_CAMERA_MAX_FAR = 2000.0f;
|
||||
static const float COEFFICIENT_OF_EXPANSION = 2.0f * std::sqrtf(3.0f);
|
||||
static const float SHADOW_CAMERA_MAX_FAR = 2000.0F;
|
||||
static const float COEFFICIENT_OF_EXPANSION = 2.0F * std::sqrtf(3.0F);
|
||||
|
||||
class CC_DLL SharedMemory : public Object {
|
||||
public:
|
||||
template <typename T>
|
||||
static T *getBuffer(uint index) {
|
||||
const auto &bufferMap = se::BufferPool::getPoolMap();
|
||||
if (bufferMap.count(T::type) != 0) {
|
||||
const se::BufferPool *bufferPool = bufferMap.at(T::type);
|
||||
return bufferPool->getTypedObject<T>(index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
const auto type = GET_BUFFER_POOL_ID(T::TYPE);
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(bufferMap[type] != nullptr, "BufferPool: Invalid buffer pool type");
|
||||
#endif
|
||||
|
||||
const se::BufferPool *bufferPool = bufferMap[type];
|
||||
return bufferPool->getTypedObject<T>(index);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
static T *getBuffer(se::PoolType poolType, uint index) {
|
||||
const auto &bufferMap = se::BufferPool::getPoolMap();
|
||||
if (bufferMap.count(poolType) != 0) {
|
||||
const se::BufferPool *bufferPool = bufferMap.at(poolType);
|
||||
return bufferPool->getTypedObject<T>(index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
const auto type = GET_BUFFER_POOL_ID(poolType);
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(bufferMap[type] != nullptr, "BufferPool: Invalid buffer pool type");
|
||||
#endif
|
||||
|
||||
const se::BufferPool *bufferPool = bufferMap[type];
|
||||
return bufferPool->getTypedObject<T>(index);
|
||||
}
|
||||
|
||||
template <typename T, se::PoolType p>
|
||||
static T *getObject(uint index) {
|
||||
const auto &poolMap = se::ObjectPool::getPoolMap();
|
||||
if (poolMap.count(p) != 0) {
|
||||
const se::ObjectPool *objectPool = poolMap.at(p);
|
||||
return objectPool->getTypedObject<T>(index);
|
||||
} else {
|
||||
return nullptr;
|
||||
}
|
||||
const auto type = GET_OBJECT_POOL_ID(p);
|
||||
|
||||
#ifdef CC_DEBUG
|
||||
CCASSERT(poolMap[type] != nullptr, "BufferPool: Invalid buffer pool type");
|
||||
#endif
|
||||
|
||||
const se::ObjectPool *objectPool = poolMap[type];
|
||||
return objectPool->getTypedObject<T>(index);
|
||||
}
|
||||
|
||||
static uint32_t *getHandleArray(se::PoolType type, uint index) {
|
||||
@@ -146,39 +153,39 @@ public:
|
||||
|
||||
struct CC_DLL Node {
|
||||
uint32_t flagsChanged = 0;
|
||||
uint32_t layer = 0;
|
||||
uint32_t layer = 0;
|
||||
cc::Vec3 worldScale;
|
||||
cc::Vec3 worldPosition;
|
||||
cc::Vec4 worldRotation;
|
||||
cc::Mat4 worldMatrix;
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL AABB {
|
||||
cc::Vec3 center;
|
||||
cc::Vec3 halfExtents;
|
||||
|
||||
void getBoundary(cc::Vec3 &minPos, cc::Vec3 &maxPos) const;
|
||||
void getBoundary(cc::Vec3 &minPos, cc::Vec3 &maxPos) const; // NOLINT
|
||||
void merge(const AABB &aabb);
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
bool aabb_aabb(const AABB *, const AABB *);
|
||||
bool aabbAabb(const AABB *, const AABB *);
|
||||
|
||||
struct CC_DLL Plane {
|
||||
cc::Vec3 normal;
|
||||
float distance;
|
||||
float distance;
|
||||
};
|
||||
|
||||
constexpr uint PLANE_LENGTH = 6;
|
||||
struct CC_DLL Frustum {
|
||||
struct CC_DLL Frustum {
|
||||
cc::Vec3 vertices[8];
|
||||
Plane planes[PLANE_LENGTH];
|
||||
Plane planes[PLANE_LENGTH];
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
bool aabb_frustum(const AABB *, const Frustum *);
|
||||
bool aabbFrustum(const AABB *, const Frustum *);
|
||||
|
||||
enum class LightType {
|
||||
DIRECTIONAL,
|
||||
@@ -188,56 +195,56 @@ enum class LightType {
|
||||
};
|
||||
struct CC_DLL Light {
|
||||
uint32_t useColorTemperature = 0;
|
||||
float luminance = 0;
|
||||
uint32_t nodeID = 0;
|
||||
float range = 0;
|
||||
uint32_t lightType = 0;
|
||||
uint32_t aabbID = 0;
|
||||
uint32_t frustumID = 0;
|
||||
float size = 0.15f;
|
||||
float spotAngle = 0.0f;
|
||||
float aspect = 1.0f;
|
||||
float luminance = 0;
|
||||
uint32_t nodeID = 0;
|
||||
float range = 0;
|
||||
uint32_t lightType = 0;
|
||||
uint32_t aabbID = 0;
|
||||
uint32_t frustumID = 0;
|
||||
float size = 0.15F;
|
||||
float spotAngle = 0.0F;
|
||||
float aspect = 1.0F;
|
||||
cc::Vec3 direction;
|
||||
cc::Vec3 color;
|
||||
cc::Vec3 colorTemperatureRGB;
|
||||
cc::Vec3 position;
|
||||
|
||||
CC_INLINE const Node *getNode() const { return GET_NODE(nodeID); }
|
||||
CC_INLINE LightType getType() const { return static_cast<LightType>(lightType); }
|
||||
CC_INLINE LightType getType() const { return static_cast<LightType>(lightType); }
|
||||
CC_INLINE const AABB *getAABB() const { return GET_AABB(aabbID); }
|
||||
CC_INLINE const Frustum *getFrustum() const { return GET_FRUSTUM(frustumID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL FlatBufferView {
|
||||
uint32_t stride = 0;
|
||||
uint32_t count = 0;
|
||||
uint32_t stride = 0;
|
||||
uint32_t count = 0;
|
||||
uint32_t bufferID = 0; // raw buffer id
|
||||
|
||||
CC_INLINE uint8_t *getBuffer(uint *size) const { return GET_RAW_BUFFER(bufferID, size); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL InstancedAttributeView {
|
||||
uint32_t nameID = 0;
|
||||
uint32_t format = 0;
|
||||
uint32_t nameID = 0;
|
||||
uint32_t format = 0;
|
||||
uint32_t isNormalized = 0;
|
||||
uint32_t bufferID = 0;
|
||||
uint32_t bufferID = 0;
|
||||
|
||||
CC_INLINE const uint8_t *getBuffer(uint *size) const { return GET_RAW_BUFFER(bufferID, size); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL RenderingSubMesh {
|
||||
uint32_t flatBuffersID = 0; // array pool id
|
||||
|
||||
CC_INLINE const uint *getFlatBufferArrayID() const { return GET_FLAT_BUFFER_ARRAY(flatBuffersID); }
|
||||
CC_INLINE const FlatBufferView *getFlatBuffer(uint idx) const { return GET_FLAT_BUFFER(idx); }
|
||||
CC_INLINE const uint * getFlatBufferArrayID() const { return GET_FLAT_BUFFER_ARRAY(flatBuffersID); }
|
||||
static CC_INLINE const FlatBufferView *getFlatBuffer(uint idx) { return GET_FLAT_BUFFER(idx); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
enum class CC_DLL BatchingSchemes {
|
||||
@@ -246,18 +253,18 @@ enum class CC_DLL BatchingSchemes {
|
||||
};
|
||||
|
||||
struct CC_DLL PassView {
|
||||
uint32_t priority = 0;
|
||||
uint32_t stage = 0;
|
||||
uint32_t phase = 0;
|
||||
uint32_t batchingScheme = 0;
|
||||
uint32_t primitive = 0;
|
||||
uint32_t dynamicState = 0;
|
||||
uint32_t hash = 0;
|
||||
uint32_t rasterizerStateID = 0;
|
||||
uint32_t priority = 0;
|
||||
uint32_t stage = 0;
|
||||
uint32_t phase = 0;
|
||||
uint32_t batchingScheme = 0;
|
||||
uint32_t primitive = 0;
|
||||
uint32_t dynamicState = 0;
|
||||
uint32_t hash = 0;
|
||||
uint32_t rasterizerStateID = 0;
|
||||
uint32_t depthStencilStateID = 0;
|
||||
uint32_t blendStateID = 0;
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t pipelineLayoutID = 0;
|
||||
uint32_t blendStateID = 0;
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t pipelineLayoutID = 0;
|
||||
|
||||
CC_INLINE BatchingSchemes getBatchingScheme() const { return static_cast<BatchingSchemes>(batchingScheme); }
|
||||
CC_INLINE gfx::PrimitiveMode getPrimitive() const { return static_cast<gfx::PrimitiveMode>(primitive); }
|
||||
@@ -268,19 +275,19 @@ struct CC_DLL PassView {
|
||||
CC_INLINE gfx::DescriptorSet *getDescriptorSet() const { return GET_DESCRIPTOR_SET(descriptorSetID); }
|
||||
CC_INLINE gfx::PipelineLayout *getPipelineLayout() const { return GET_PIPELINE_LAYOUT(pipelineLayoutID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL SubModelView {
|
||||
uint32_t priority = 0;
|
||||
uint32_t passCount = 0;
|
||||
uint32_t passID[4] = {0, 0, 0, 0};
|
||||
uint32_t shaderID[4] = {0, 0, 0, 0};
|
||||
uint32_t planarShaderID = 0;
|
||||
uint32_t priority = 0;
|
||||
uint32_t passCount = 0;
|
||||
uint32_t passID[4] = {0, 0, 0, 0};
|
||||
uint32_t shaderID[4] = {0, 0, 0, 0};
|
||||
uint32_t planarShaderID = 0;
|
||||
uint32_t planarInstanceShaderID = 0;
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t inputAssemblerID = 0;
|
||||
uint32_t subMeshID = 0;
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t inputAssemblerID = 0;
|
||||
uint32_t subMeshID = 0;
|
||||
|
||||
CC_INLINE const PassView *getPassView(uint idx) const { return GET_PASS(passID[idx]); }
|
||||
CC_INLINE gfx::Shader *getShader(uint idx) const { return GET_SHADER(shaderID[idx]); }
|
||||
@@ -290,38 +297,38 @@ struct CC_DLL SubModelView {
|
||||
CC_INLINE gfx::InputAssembler *getInputAssembler() const { return GET_IA(inputAssemblerID); }
|
||||
CC_INLINE const RenderingSubMesh *getSubMesh() const { return GET_RENDER_SUBMESH(subMeshID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL ModelView {
|
||||
uint32_t enabled = 0;
|
||||
uint32_t visFlags = 0;
|
||||
uint32_t castShadow = 0;
|
||||
uint32_t receiveShadow = 0;
|
||||
uint32_t worldBoundsID = 0; // aabb
|
||||
uint32_t nodeID = 0;
|
||||
uint32_t transformID = 0;
|
||||
uint32_t subModelsID = 0; // array pool id
|
||||
uint32_t enabled = 0;
|
||||
uint32_t visFlags = 0;
|
||||
uint32_t castShadow = 0;
|
||||
uint32_t receiveShadow = 0;
|
||||
uint32_t worldBoundsID = 0; // aabb
|
||||
uint32_t nodeID = 0;
|
||||
uint32_t transformID = 0;
|
||||
uint32_t subModelsID = 0; // array pool id
|
||||
uint32_t instancedBufferID = 0; // raw buffer id
|
||||
uint32_t instancedAttrsID = 0; // array pool id
|
||||
uint32_t instancedAttrsID = 0; // array pool id
|
||||
|
||||
CC_INLINE const AABB *getWorldBounds() const { return GET_AABB(worldBoundsID); }
|
||||
CC_INLINE const Node *getNode() const { return GET_NODE(nodeID); }
|
||||
CC_INLINE const Node *getTransform() const { return GET_NODE(transformID); }
|
||||
CC_INLINE const uint *getSubModelID() const { return GET_SUBMODEL_ARRAY(subModelsID); }
|
||||
CC_INLINE const SubModelView *getSubModelView(uint idx) const { return GET_SUBMODEL(idx); }
|
||||
CC_INLINE const uint * getSubModelID() const { return GET_SUBMODEL_ARRAY(subModelsID); }
|
||||
static CC_INLINE const SubModelView *getSubModelView(uint idx) { return GET_SUBMODEL(idx); }
|
||||
CC_INLINE const uint8_t *getInstancedBuffer(uint *size) const { return GET_RAW_BUFFER(instancedBufferID, size); }
|
||||
CC_INLINE const uint *getInstancedAttributeID() const { return GET_ATTRIBUTE_ARRAY(instancedAttrsID); }
|
||||
CC_INLINE gfx::Attribute *getInstancedAttribute(uint idx) const { return GET_ATTRIBUTE(idx); }
|
||||
const static se::PoolType type;
|
||||
static CC_INLINE gfx::Attribute *getInstancedAttribute(uint idx) { return GET_ATTRIBUTE(idx); }
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL UIBatch {
|
||||
uint32_t visFlags = 0;
|
||||
uint32_t passCount = 0;
|
||||
uint32_t passID[4] = {0, 0, 0, 0};
|
||||
uint32_t shaderID[4] = {0, 0, 0, 0};
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t visFlags = 0;
|
||||
uint32_t passCount = 0;
|
||||
uint32_t passID[4] = {0, 0, 0, 0};
|
||||
uint32_t shaderID[4] = {0, 0, 0, 0};
|
||||
uint32_t descriptorSetID = 0;
|
||||
uint32_t inputAssemblerID = 0;
|
||||
|
||||
CC_INLINE const PassView *getPassView(uint idx) const { return GET_PASS(passID[idx]); }
|
||||
@@ -329,134 +336,134 @@ struct CC_DLL UIBatch {
|
||||
CC_INLINE gfx::DescriptorSet *getDescriptorSet() const { return GET_DESCRIPTOR_SET(descriptorSetID); }
|
||||
CC_INLINE gfx::InputAssembler *getInputAssembler() const { return GET_IA(inputAssemblerID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Scene {
|
||||
uint32_t mainLightID = 0;
|
||||
uint32_t modelsID = 0; // array pool
|
||||
uint32_t sphereLights; // array pool
|
||||
uint32_t spotLights; // array pool
|
||||
uint32_t uiBatches; // array pool
|
||||
uint32_t modelsID = 0; // array pool
|
||||
uint32_t sphereLights; // array pool
|
||||
uint32_t spotLights; // array pool
|
||||
uint32_t uiBatches; // array pool
|
||||
|
||||
CC_INLINE const Light *getMainLight() const { return GET_LIGHT(mainLightID); }
|
||||
CC_INLINE const uint *getSphereLightArrayID() const { return GET_LIGHT_ARRAY(sphereLights); }
|
||||
CC_INLINE const Light *getSphereLight(uint idx) const { return GET_LIGHT(idx); }
|
||||
CC_INLINE const uint *getSpotLightArrayID() const { return GET_LIGHT_ARRAY(spotLights); }
|
||||
CC_INLINE const Light *getSpotLight(uint idx) const { return GET_LIGHT(idx); }
|
||||
CC_INLINE const uint *getModels() const { return GET_MODEL_ARRAY(modelsID); }
|
||||
CC_INLINE const ModelView *getModelView(uint idx) const { return GET_MODEL(idx); }
|
||||
CC_INLINE const uint *getUIBatches() const {return GET_UI_BATCH_ARRAY(uiBatches);}
|
||||
CC_INLINE const uint * getSphereLightArrayID() const { return GET_LIGHT_ARRAY(sphereLights); }
|
||||
static CC_INLINE const Light *getSphereLight(uint idx) { return GET_LIGHT(idx); }
|
||||
CC_INLINE const uint * getSpotLightArrayID() const { return GET_LIGHT_ARRAY(spotLights); }
|
||||
static CC_INLINE const Light *getSpotLight(uint idx) { return GET_LIGHT(idx); }
|
||||
CC_INLINE const uint * getModels() const { return GET_MODEL_ARRAY(modelsID); }
|
||||
static CC_INLINE const ModelView *getModelView(uint idx) { return GET_MODEL(idx); }
|
||||
CC_INLINE const uint *getUIBatches() const { return GET_UI_BATCH_ARRAY(uiBatches); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL RenderWindow {
|
||||
uint32_t hasOnScreenAttachments = 0;
|
||||
uint32_t hasOnScreenAttachments = 0;
|
||||
uint32_t hasOffScreenAttachments = 0;
|
||||
uint32_t framebufferID = 0;
|
||||
uint32_t framebufferID = 0;
|
||||
|
||||
CC_INLINE gfx::Framebuffer *getFramebuffer() const { return GET_FRAMEBUFFER(framebufferID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Camera {
|
||||
uint32_t width = 0;
|
||||
uint32_t height = 0;
|
||||
float exposure = 0;
|
||||
uint32_t clearFlag = 0;
|
||||
float clearDepth = 0;
|
||||
uint32_t clearStencil = 0;
|
||||
uint32_t visibility = 0;
|
||||
uint32_t nodeID = 0;
|
||||
uint32_t sceneID = 0;
|
||||
uint32_t frustumID = 0;
|
||||
uint32_t windowID = 0;
|
||||
cc::Vec3 forward;
|
||||
cc::Vec3 position;
|
||||
float viewportX = 0;
|
||||
float viewportY = 0;
|
||||
float viewportWidth = 0;
|
||||
float viewportHeight = 0;
|
||||
uint32_t width = 0;
|
||||
uint32_t height = 0;
|
||||
float exposure = 0;
|
||||
uint32_t clearFlag = 0;
|
||||
float clearDepth = 0;
|
||||
uint32_t clearStencil = 0;
|
||||
uint32_t visibility = 0;
|
||||
uint32_t nodeID = 0;
|
||||
uint32_t sceneID = 0;
|
||||
uint32_t frustumID = 0;
|
||||
uint32_t windowID = 0;
|
||||
cc::Vec3 forward;
|
||||
cc::Vec3 position;
|
||||
float viewportX = 0;
|
||||
float viewportY = 0;
|
||||
float viewportWidth = 0;
|
||||
float viewportHeight = 0;
|
||||
gfx::Color clearColor;
|
||||
cc::Mat4 matView;
|
||||
cc::Mat4 matViewProj;
|
||||
cc::Mat4 matViewProjInv;
|
||||
cc::Mat4 matProj;
|
||||
cc::Mat4 matProjInv;
|
||||
cc::Mat4 matViewProjOffscreen;
|
||||
cc::Mat4 matViewProjInvOffscreen;
|
||||
cc::Mat4 matProjOffscreen;
|
||||
cc::Mat4 matProjInvOffscreen;
|
||||
cc::Mat4 matView;
|
||||
cc::Mat4 matViewProj;
|
||||
cc::Mat4 matViewProjInv;
|
||||
cc::Mat4 matProj;
|
||||
cc::Mat4 matProjInv;
|
||||
cc::Mat4 matViewProjOffscreen;
|
||||
cc::Mat4 matViewProjInvOffscreen;
|
||||
cc::Mat4 matProjOffscreen;
|
||||
cc::Mat4 matProjInvOffscreen;
|
||||
|
||||
CC_INLINE const Node *getNode() const { return GET_NODE(nodeID); }
|
||||
CC_INLINE const Scene *getScene() const { return GET_SCENE(sceneID); }
|
||||
CC_INLINE const Frustum *getFrustum() const { return GET_FRUSTUM(frustumID); }
|
||||
CC_INLINE const RenderWindow *getWindow() const { return GET_WINDOW(windowID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Ambient {
|
||||
uint32_t enabled = 0;
|
||||
float skyIllum = 0;
|
||||
uint32_t enabled = 0;
|
||||
float skyIllum = 0;
|
||||
cc::Vec4 skyColor;
|
||||
cc::Vec4 groundAlbedo;
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Fog {
|
||||
uint32_t enabled = 0;
|
||||
uint32_t fogType = 0;
|
||||
float fogDensity = 0;
|
||||
float fogStart = 0;
|
||||
float fogEnd = 0;
|
||||
float fogAtten = 0;
|
||||
float fogTop = 0;
|
||||
float fogRange = 0;
|
||||
uint32_t enabled = 0;
|
||||
uint32_t fogType = 0;
|
||||
float fogDensity = 0;
|
||||
float fogStart = 0;
|
||||
float fogEnd = 0;
|
||||
float fogAtten = 0;
|
||||
float fogTop = 0;
|
||||
float fogRange = 0;
|
||||
cc::Vec4 fogColor;
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Sphere {
|
||||
float radius = 0;
|
||||
float radius = 0;
|
||||
cc::Vec3 center;
|
||||
|
||||
CC_INLINE void setCenter(const cc::Vec3 &val) { center = val; }
|
||||
CC_INLINE void setRadius(float val) { radius = val; }
|
||||
void define(const AABB &aabb);
|
||||
void mergeAABB(const AABB *aabb);
|
||||
void mergePoint(const cc::Vec3 &point);
|
||||
bool interset(const Frustum &frustum) const;
|
||||
int interset(const Plane &plane) const;
|
||||
void define(const AABB &aabb);
|
||||
void mergeAABB(const AABB *aabb);
|
||||
void mergePoint(const cc::Vec3 &point);
|
||||
bool interset(const Frustum &frustum) const;
|
||||
int interset(const Plane &plane) const;
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
bool sphere_frustum(const Sphere *sphere, const Frustum *frustum);
|
||||
bool sphere_frustum(const Sphere *sphere, const Frustum *frustum); //NOLINT
|
||||
|
||||
enum class CC_DLL ShadowType {
|
||||
PLANAR = 0,
|
||||
PLANAR = 0,
|
||||
SHADOWMAP = 1
|
||||
};
|
||||
|
||||
struct CC_DLL Shadows {
|
||||
uint32_t enabled = 0;
|
||||
uint32_t dirty = 0;
|
||||
uint32_t shadowType = 0;
|
||||
float distance = 0.0f;
|
||||
uint32_t instancePass = 0;
|
||||
uint32_t planarPass = 0;
|
||||
float nearValue = 0.0f;
|
||||
float farValue = 0.0f;
|
||||
float aspect = 0.0f;
|
||||
uint32_t pcfType = 0;
|
||||
uint32_t enabled = 0;
|
||||
uint32_t dirty = 0;
|
||||
uint32_t shadowType = 0;
|
||||
float distance = 0.0F;
|
||||
uint32_t instancePass = 0;
|
||||
uint32_t planarPass = 0;
|
||||
float nearValue = 0.0F;
|
||||
float farValue = 0.0F;
|
||||
float aspect = 0.0F;
|
||||
uint32_t pcfType = 0;
|
||||
uint32_t shadowMapDirty = 0;
|
||||
float bias = 0.0f;
|
||||
float orthoSize = 0.0f;
|
||||
uint32_t autoAdapt = 0;
|
||||
float bias = 0.0F;
|
||||
float orthoSize = 0.0F;
|
||||
uint32_t autoAdapt = 0;
|
||||
|
||||
cc::Vec4 color;
|
||||
cc::Vec2 size;
|
||||
@@ -467,50 +474,50 @@ struct CC_DLL Shadows {
|
||||
CC_INLINE PassView *getPlanarShadowPass() const { return GET_PASS(planarPass); }
|
||||
CC_INLINE PassView *getInstancePass() const { return GET_PASS(instancePass); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Skybox {
|
||||
uint32_t enabled = 0;
|
||||
uint32_t isRGBE = 0;
|
||||
uint32_t useIBL = 0;
|
||||
uint32_t isRGBE = 0;
|
||||
uint32_t useIBL = 0;
|
||||
uint32_t modelID = 0;
|
||||
|
||||
CC_INLINE const ModelView *getModel() const { return GET_MODEL(modelID); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL PipelineSharedSceneData {
|
||||
uint32_t shadow = 0;
|
||||
uint32_t skybox = 0;
|
||||
uint32_t ambient = 0;
|
||||
uint32_t fog = 0;
|
||||
uint32_t isHDR = 0;
|
||||
uint32_t shadingScale = 0;
|
||||
uint32_t fpScale = 0;
|
||||
uint32_t deferredLightPass = 0;
|
||||
uint32_t shadow = 0;
|
||||
uint32_t skybox = 0;
|
||||
uint32_t ambient = 0;
|
||||
uint32_t fog = 0;
|
||||
uint32_t isHDR = 0;
|
||||
uint32_t shadingScale = 0;
|
||||
uint32_t fpScale = 0;
|
||||
uint32_t deferredLightPass = 0;
|
||||
uint32_t deferredLightPassShader = 0;
|
||||
uint32_t deferredPostPass = 0;
|
||||
uint32_t deferredPostPassShader = 0;
|
||||
uint32_t deferredPostPass = 0;
|
||||
uint32_t deferredPostPassShader = 0;
|
||||
|
||||
CC_INLINE Shadows* getShadows() const {return GET_SHADOWS(shadow);}
|
||||
CC_INLINE Skybox* getSkybox() const {return GET_SKYBOX(skybox);}
|
||||
CC_INLINE Ambient* getAmbient() const {return GET_AMBIENT(ambient);}
|
||||
CC_INLINE Fog* getFog() const {return GET_FOG(fog);}
|
||||
CC_INLINE PassView* getDeferredLightPass() const {return GET_PASS(deferredLightPass);}
|
||||
CC_INLINE gfx::Shader* getDeferredLightPassShader() const {return GET_SHADER(deferredLightPassShader);}
|
||||
CC_INLINE PassView* getDeferredPostPass() const {return GET_PASS(deferredPostPass);}
|
||||
CC_INLINE gfx::Shader* getDeferredPostPassShader() const {return GET_SHADER(deferredPostPassShader);}
|
||||
CC_INLINE Shadows *getShadows() const { return GET_SHADOWS(shadow); }
|
||||
CC_INLINE Skybox *getSkybox() const { return GET_SKYBOX(skybox); }
|
||||
CC_INLINE Ambient *getAmbient() const { return GET_AMBIENT(ambient); }
|
||||
CC_INLINE Fog *getFog() const { return GET_FOG(fog); }
|
||||
CC_INLINE PassView *getDeferredLightPass() const { return GET_PASS(deferredLightPass); }
|
||||
CC_INLINE gfx::Shader *getDeferredLightPassShader() const { return GET_SHADER(deferredLightPassShader); }
|
||||
CC_INLINE PassView *getDeferredPostPass() const { return GET_PASS(deferredPostPass); }
|
||||
CC_INLINE gfx::Shader *getDeferredPostPassShader() const { return GET_SHADER(deferredPostPassShader); }
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
struct CC_DLL Root {
|
||||
float cumulativeTime = 0;
|
||||
float frameTime = 0;
|
||||
float frameTime = 0;
|
||||
|
||||
const static se::PoolType type;
|
||||
const static se::PoolType TYPE;
|
||||
};
|
||||
|
||||
} //namespace pipeline
|
||||
|
||||
Reference in New Issue
Block a user