void DRBPointLightData::updateRange(const glm::mat4 &transformation) { float errorRate = 0.01f; glm::vec3 lightRange; glm::vec3 equation(_range.z, _range.y, _range.x); // if the value of equation.z + equation.y * dist + equation.x * dist * dist == 256 // then the pixels are not lighted anymore (pxlColor = final_color / attenuation) equation.z -= 256; if (equation.x == 0) // first degree { // infinite range if there is no distance attenuation AGE_ASSERT(equation.y != 0); lightRange = glm::vec3(-equation.z / equation.y); } else // second degree { float d = Mathematic::secondDegreeDiscriminant(equation); glm::vec2 res = Mathematic::resolveSecondDegree(equation, d); lightRange = glm::vec3(glm::max(res.x, res.y)); } AGE_ASSERT(lightRange.x > 0); _sphereTransform = glm::scale(transformation, lightRange + lightRange * errorRate); _positionLightProperty->autoSet(glm::vec3(_sphereTransform[3])); setTransformation(_sphereTransform); }
LFListBase::LFListBase(std::size_t nextPtrPadding) : _nextPtrPadding(nextPtrPadding) { AGE_ASSERT(nextPtrPadding != 0); AGE_ASSERT(nextPtrPadding % 8 == 0); _datas.head = nullptr; _datas.size = 0; }
void BFCBlock::deleteItem(ItemID itemId) { AGE_ASSERT(itemId < MaxItemID); _items[itemId].setDrawable(nullptr); _free.push(itemId); }
void ComponentRegistrationManager::serializeBinary(ComponentBase *c, cereal::PortableBinaryOutputArchive &ar) { auto id = c->getType(); auto find = _binarySaveMap.find(id); AGE_ASSERT(find != std::end(_binarySaveMap)); find->second(c, ar); }
void ComponentRegistrationManager::serializeJson(ComponentBase *c, cereal::JSONOutputArchive &ar) { auto id = c->getType(); auto find = _jsonSaveMap.find(id); AGE_ASSERT(find != std::end(_jsonSaveMap)); find->second(c, ar); }
void TextureBuffer::set(GLvoid const *data, GLsizeiptr count) { SCOPE_profile_cpu_function("TextureBuffer"); AGE_ASSERT(count <= _count); bindBuffer(); glBufferSubData(GL_TEXTURE_BUFFER, 0, _size * count, data); }
bool RenderThread::update() { /* - Tant qu'il n'y a pas de command -> je pop des task - Une fois que j'ai mes commandes -> pour chacunes d'elles -> je regarde si c'est a moi de les traiter (ex : changement de scene) -> si ca n'est pas a moi de les traiter -> je les passe au render context actif -> si il n'y a pas de render context actif, c'est que j'ai fait une erreur, et j'assert dans ta face :D */ _registerId(); _run = true; _insideRun = true; DWORD threadId = GetThreadId(static_cast<HANDLE>(_threadHandle.native_handle())); SetThreadName(threadId, this->_name.c_str()); TMQ::MessageBase *task = nullptr; while (_run && _insideRun) { SCOPE_profile_cpu_i("RenderTimer", "Update"); if (TMQ::TaskManager::RenderThreadGetTask(task)) { SCOPE_profile_cpu_i("RenderTimer", "Execute task"); auto success = execute(task); // we receive a task that we cannot treat AGE_ASSERT(success); } } return true; }
void ArchetypeEditorManager::spawn(Entity &entity, const std::string &name) { auto it = _archetypesCollection.find(name); AGE_ASSERT(it != std::end(_archetypesCollection)); loadFromFile(it->second); entity->getScene()->internalCopyEntity(it->second->root, entity, true, false); auto representation = entity->getComponent<EntityRepresentation>(); representation->editorOnly = false; representation->_archetypeLinked = it->second; std::vector<Entity*> tmpEntitiesList; std::vector<const char*> tmpEntitiesNameList; listEntityTree(entity, tmpEntitiesNameList, tmpEntitiesList); it->second->entities.insert(entity); for (auto &en: tmpEntitiesList) { auto &e = *en; if (e->haveComponent<ArchetypeComponent>() == false) { e->addComponent<ArchetypeComponent>(name); } if (e != entity) { e->getComponent<ArchetypeComponent>()->parentIsAnArchetype = true; } } }
DepthMapHandle::DepthMapHandle(DepthMapManager *managerPtr, DepthMap *map, std::size_t index, DepthMapManager::Status status) : _manager(managerPtr) , _map(map) , _index(index) , _status(status) { AGE_ASSERT(_manager != nullptr); }
void BFCLinkTracker::removeLink(std::size_t index) { SCOPE_profile_cpu_function("BFC"); AGE_ASSERT(index != -1 && index < _links.size()); _links[index] = nullptr; _free.push(index); }
ComponentBase *ComponentRegistrationManager::copyComponent(ComponentBase *src, AScene *scene) { AGE_ASSERT(scene != nullptr); AGE_ASSERT(src != nullptr); auto id = src->getType(); auto find = _copyMap.find(id); if (find == std::end(_copyMap)) { #ifdef _DEBUG // can be normal for component who generates other components //std::cerr << "Component not copyable\n"; #endif // _DEBUG return nullptr; } auto voidCpt = scene->allocateComponent(id); find->second(voidCpt, src); return static_cast<ComponentBase*>(voidCpt); }
ComponentBase *ComponentRegistrationManager::loadBinary(std::size_t componentHashId, Entity &e, cereal::PortableBinaryInputArchive &ar) { AGE_ASSERT(_typeIds.find(componentHashId) != std::end(_typeIds) && "Component type has not been registered. Use REGISTER_COMPONENT_TYPE"); auto id = _typeIds[componentHashId]; auto voidCpt = e->getScene()->allocateComponent(id); auto find = _binaryLoadMap.find(id); AGE_ASSERT(find != std::end(_binaryLoadMap)); find->second(voidCpt, ar, e); auto cpt = (AGE::ComponentBase*)voidCpt; cpt->_typeId = id; cpt->entity = e; e->addComponentPtr(cpt); return cpt; }
void LFListBase::push(void *element) { void *elementNext = (void*)((std::size_t)element + _nextPtrPadding); while (true) { Data datas; while (true) { datas = _datas; __int64 cr[2]; cr[0] = (__int64)datas.size; /* low */ cr[1] = (__int64)datas.head; /* high */ if (_InterlockedCompareExchange128(&_datas.size, (__int64)datas.head, datas.size, &cr[0]) == 1) { break; } } Data oldDatas = datas; *(std::size_t*)(elementNext) = (std::size_t)datas.head; AGE_ASSERT((std::size_t)(elementNext) % 8 == 0); AGE_ASSERT(datas.head != elementNext); datas.head = element; datas.size += 1; __int64 comparandResult[2]; comparandResult[0] = (__int64)oldDatas.size; /* low */ comparandResult[1] = (__int64)oldDatas.head; /* high */ if (_InterlockedCompareExchange128( &_datas.size, (__int64)datas.head, datas.size, &comparandResult[0] ) == 1) { return; } } }
void RenderThread::getCube(Key<Vertices> &v, Key<Painter> &p) { static const std::vector<glm::vec3> positions = { glm::vec3(-1.0f, 1.0f, 1.0f), glm::vec3(-1.0f, -1.0f, 1.0f), glm::vec3(1.0f, -1.0f, 1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(-1.0f, 1.0f, -1.0f), glm::vec3(-1.0f, -1.0f, -1.0f), glm::vec3(1.0f, -1.0f, -1.0f), glm::vec3(1.0f, 1.0f, -1.0f) }; static const std::vector<unsigned int> indices = { 0, 1, 2, 3, 0, 3, 7, 4, 4, 7, 6, 5, 6, 5, 1, 2, 2, 3, 7, 6, 4, 0, 1, 5 }; // to be sure that this function is only called in render thread AGE_ASSERT(CurrentThread() == (AGE::Thread*)GetRenderThread()); if (SimpleGeometry::cubeMesh.verticesKey.isValid() && SimpleGeometry::cubeMesh.painterKey.isValid()) { v = SimpleGeometry::cubeMesh.verticesKey; p = SimpleGeometry::cubeMesh.painterKey; return; } auto type = std::make_pair<GLenum, StringID>(GL_FLOAT_VEC3, StringID("position", 0x4cbf3a26fca1d74a)); std::vector<std::pair < GLenum, StringID > > types; types.push_back(type); if (!paintingManager->has_painter(types)) { SimpleGeometry::cubeMesh.painterKey = paintingManager->add_painter(std::move(types)); } else { SimpleGeometry::cubeMesh.painterKey = paintingManager->get_painter(types); } auto &painterPtr = paintingManager->get_painter(SimpleGeometry::cubeMesh.painterKey); SimpleGeometry::cubeMesh.verticesKey = painterPtr->add_vertices(positions.size(), indices.size()); auto vertices = painterPtr->get_vertices(SimpleGeometry::cubeMesh.verticesKey); vertices->set_data<glm::vec3>(positions, StringID("position", 0x4cbf3a26fca1d74a)); vertices->set_indices(indices); v = SimpleGeometry::cubeMesh.verticesKey; p = SimpleGeometry::cubeMesh.painterKey; }
void RenderThread::_initPipelines() { // to be sure that this function is only called in render thread AGE_ASSERT(CurrentThread() == (AGE::Thread*)GetRenderThread()); for (auto &e : pipelines) { if (!e) { continue; } e->init(); } }
void Library::close(void) { AGE_ASSERT(handle && "Library not opened"); if (handle) { #if defined(AGE_PLATFORM_WINDOWS) FreeLibrary(handle); #else dlclose(handle); #endif handle = nullptr; pluginName.clear(); } }
void ArchetypeEditorManager::loadFromFile(std::shared_ptr<ArchetypeEditorRepresentation> ptr) { AGE_ASSERT(ptr != nullptr); if (ptr->loaded == false) { auto path = _libraryFolder + "/" + ptr->name + ".raw_archetype"; ReadableEntityPack pack; pack.scene = getScene(); pack.loadFromFile(path); ptr->root = pack.entities.front().entity; ptr->loaded = true; } }
bool TextureBuffer::init(GLsizeiptr count, GLenum internal_format /*GL_R32F */, GLsizeiptr size, GLenum usage /* GL_STATIC_DRAW ...*/) { SCOPE_profile_cpu_function("TextureBuffer"); AGE_ASSERT(_bufferHandle == -1 && _textureHandle == -1 && _count == 0 && _size == 0 && _buffer == nullptr); _count = count; _size = size; glGenBuffers(1, &_bufferHandle); bindBuffer(); glBufferData(GL_TEXTURE_BUFFER, size * count, nullptr, usage); glGenTextures(1, &_textureHandle); bind(); glTexBuffer(GL_TEXTURE_BUFFER, internal_format, _bufferHandle); _buffer = (char*)AGE_MALLOC(size * count); return true; }
void ArchetypeManager::spawn(Entity &entity, const std::string &name) { auto it = _archetypesCollection.find(name); if (it == std::end(_archetypesCollection)) { load(); it = _archetypesCollection.find(name); } AGE_ASSERT(it != std::end(_archetypesCollection)); entity->getScene()->internalCopyEntity(it->second, entity, true, false); //if (entity->haveComponent<AGE::ArchetypeComponent>()) //{ // entity->removeComponent<AGE::ArchetypeComponent>(); //} }
bool Library::load(const std::string &name) { AGE_ASSERT(handle == nullptr && "Library is not closed"); std::string libraryName = Library::GenerateName(name); if (libraryName.empty()) { #if defined(AGE_PLATFORM_WINDOWS) handle = GetModuleHandle(nullptr); #else handle = dlopen(nullptr, 0); #endif } else { #if defined(AGE_PLATFORM_WINDOWS) handle = LoadLibrary(libraryName.c_str()); #else handle = dlopen(libraryName.c_str(), RTLD_LAZY); #endif if (!handle) { libraryName = name; #if defined(AGE_PLATFORM_WINDOWS) handle = LoadLibrary(libraryName.c_str()); #else handle = dlopen(libraryName.c_str(), RTLD_LAZY); #endif } } if (handle != nullptr) { if (libraryName.empty()) { pluginName = "CurrentProcess"; } else { pluginName = libraryName; } return true; } else { AGE_ERROR("Impossible to load \"", libraryName, "\" library"); return false; } }
DeferredShadowBuffering::DeferredShadowBuffering(glm::uvec2 const &screenSize, std::shared_ptr<PaintingManager> painterManager) : FrameBufferRender(screenSize.x, screenSize.y, painterManager) { // We dont want to take the skinned or transparent meshes _forbidden[AGE_SKINNED] = true; _forbidden[AGE_SEMI_TRANSPARENT] = true; _programs.resize(PROGRAM_NBR); auto confManager = GetEngine()->getInstance<ConfigurationManager>(); auto shaderPath = confManager->getConfiguration<std::string>("ShadersPath"); // you have to set shader directory in configuration path AGE_ASSERT(shaderPath != nullptr); auto vertexShaderPath = shaderPath->getValue() + DEFERRED_SHADING_SHADOW_BUFFERING_VERTEX; auto fragmentShaderPath = shaderPath->getValue() + DEFERRED_SHADING_SHADOW_BUFFERING_FRAG; _programs[PROGRAM_BUFFERING] = std::make_shared<Program>(Program(std::string("program_shadow_buffering"), { std::make_shared<UnitProg>(vertexShaderPath, GL_VERTEX_SHADER), std::make_shared<UnitProg>(fragmentShaderPath, GL_FRAGMENT_SHADER) })); }
void BinaryEntityPack::load(cereal::PortableBinaryInputArchive &ar, const std::uint32_t version) { AGE_ASSERT(scene != nullptr); std::size_t entityNumber; ar(componentsIdReferenceTable); ar(entityNumber); entities.resize(entityNumber); for (std::size_t i = 0; i < entities.size(); ++i) { entities[i].entity = scene->createEntity(); entities[i].typesMap = &componentsIdReferenceTable; ar(entities[i]); } for (auto &e : entities) { for (auto &c : e.children) { e.entity->getLink().attachChild(entities[c].entity.getLinkPtr()); } } for (auto &e : entities) { if (e.entity->getLink().hasChildren()) { e.entity->getLink().isUserModified(); e.entity->getLink().setTransform(e.entity->getLink().getLocalTransform(), true); } } for (auto &e : entities) { if (e.entity->getComponent<ArchetypeComponent>()) { continue; } for (auto &c : e.entity->getComponentList()) { if (c) { c->postUnserialization(); } } } }
void BFCBlockManager::createItem(BFCCullableObject *object, BlockID &blockID, ItemID &itemId) { if (_blocksNotFull.empty() == false) { auto b = *(_blocksNotFull.begin()); auto &block = _blocks[b]; itemId = block->createItem(object); blockID = std::uint8_t(b); if (block->isFull()) { _blocksNotFull.erase(_blocksNotFull.begin()); } return; } _blocks.push_back(std::make_shared<BFCBlock>()); AGE_ASSERT(_blocks.size() < MaxBlockID); _blocksNotFull.insert(_blocks.size() - 1); createItem(object, blockID, itemId); }
void ArchetypeEditorManager::load() { Directory dir; const bool success = dir.open(_libraryFolder.c_str()); AGE_ASSERT(success); for (auto it = dir.recursive_begin(); it != dir.recursive_end(); ++it) { if (Directory::IsFile(*it)) { auto extension = FileUtils::GetExtension(*it); if (extension != "raw_archetype") { continue; } loadOne(FileUtils::RemoveExtension(FileUtils::GetName(*it))); } } dir.close(); }
void RenderThread::getIcoSphereGeometry(Key<Vertices> &v, Key<Painter> &p, uint32_t recursion) { std::vector<glm::vec3> positions; std::vector<unsigned int> indices; // to be sure that this function is only called in render thread AGE_ASSERT(CurrentThread() == (AGE::Thread*)GetRenderThread()); if (SimpleGeometry::icosphereMeshes[recursion].verticesKey.isValid() && SimpleGeometry::icosphereMeshes[recursion].painterKey.isValid()) { v = SimpleGeometry::icosphereMeshes[recursion].verticesKey; p = SimpleGeometry::icosphereMeshes[recursion].painterKey; return; } SimpleGeometry::generateIcoSphere(recursion, positions, indices); auto type = std::make_pair<GLenum, StringID>(GL_FLOAT_VEC3, StringID("position", 0x4cbf3a26fca1d74a)); std::vector<std::pair < GLenum, StringID > > types; types.push_back(type); if (!paintingManager->has_painter(types)) { SimpleGeometry::icosphereMeshes[recursion].painterKey = paintingManager->add_painter(std::move(types)); } else { SimpleGeometry::icosphereMeshes[recursion].painterKey = paintingManager->get_painter(types); } auto &painterPtr = paintingManager->get_painter(SimpleGeometry::icosphereMeshes[recursion].painterKey); SimpleGeometry::icosphereMeshes[recursion].verticesKey = painterPtr->add_vertices(positions.size(), indices.size()); auto vertices = painterPtr->get_vertices(SimpleGeometry::icosphereMeshes[recursion].verticesKey); vertices->set_data<glm::vec3>(positions, StringID("position", 0x4cbf3a26fca1d74a)); vertices->set_indices(indices); v = SimpleGeometry::icosphereMeshes[recursion].verticesKey; p = SimpleGeometry::icosphereMeshes[recursion].painterKey; }
void ReadableEntityPack::load(cereal::JSONInputArchive &ar, const std::uint32_t version) { AGE_ASSERT(scene != nullptr); std::size_t entityNumber; ar(componentsIdReferenceTable); ar(entityNumber); entities.resize(entityNumber); for (std::size_t i = 0; i < entities.size(); ++i) { entities[i].entity = scene->createEntity(); entities[i].typesMap = &componentsIdReferenceTable; ar(entities[i]); } for (auto &e : entities) { for (auto &c : e.children) { e.entity->getLink().attachChild(entities[c].entity.getLinkPtr()); } } }
void BinaryEntity::load(cereal::PortableBinaryInputArchive &ar, const std::uint32_t version) { ENTITY_FLAGS flags; AGE_ASSERT(typesMap != nullptr); ar(entity->getLink() , children , flags , componentTypes , archetypesDependency); auto archetypeManager = entity->getScene()->getInstance<AGE::IArchetypeManager>(); // we load archetypes dependency if (!archetypesDependency.empty()) { for (auto &dep : archetypesDependency) { archetypeManager->loadOne(dep); } } entity->getLink().setPosition(entity->getLink().getPosition()); entity->getLink().setOrientation(entity->getLink().getOrientation()); entity->getLink().setScale(entity->getLink().getScale()); //entity.setFlags(f); for (auto &e : componentTypes) { auto hashType = (*typesMap)[e]; auto newComponent = ComponentRegistrationManager::getInstance().loadBinary(hashType, entity, ar); } if (entity->haveComponent<ArchetypeComponent>()) { auto archetypeName = entity->getComponent<ArchetypeComponent>()->archetypeName; archetypeManager->spawn(entity, archetypeName); } }
DepthOfField::DepthOfField(glm::uvec2 const &screenSize, std::shared_ptr<PaintingManager> painterManager, std::shared_ptr<Texture2D> depth, std::shared_ptr<Texture2D> blurred1, std::shared_ptr<Texture2D> blurred2, std::shared_ptr<Texture2D> clean, std::shared_ptr<Texture2D> dst) : FrameBufferRender(screenSize.x, screenSize.y, painterManager) { push_storage_output(GL_COLOR_ATTACHMENT0, dst); _depth = depth; _clean = clean; _blurred1 = blurred1; _blurred2 = blurred2; _programs.resize(PROGRAM_NBR); auto confManager = GetEngine()->getInstance<ConfigurationManager>(); auto shaderPath = confManager->getConfiguration<std::string>("ShadersPath"); // you have to set shader directory in configuration path AGE_ASSERT(shaderPath != nullptr); auto vertexShaderPath = shaderPath->getValue() + PROGRAM_DOF_VERTEX; auto fragmentShaderPath = shaderPath->getValue() + PROGRAM_DOF_FRAG; _programs[PROGRAM_DEPTH_OF_FIELD] = std::make_shared<Program>(Program(std::string("depth_of_field"), { std::make_shared<UnitProg>(vertexShaderPath, GL_VERTEX_SHADER), std::make_shared<UnitProg>(fragmentShaderPath, GL_FRAGMENT_SHADER) })); Key<Painter> quadPainterKey; GetRenderThread()->getQuadGeometry(_quadVertices, quadPainterKey); _quadPainter = _painterManager->get_painter(quadPainterKey); }
void BFCBlockManager::deleteItem(BlockID &blockID, ItemID &itemId) { AGE_ASSERT(blockID < _blocks.size()); _blocks[blockID]->deleteItem(itemId); _blocksNotFull.insert(blockID); }
void ArchetypeEditorManager::addOne(const std::string &name, Entity &entity) { if (_archetypesCollection.find(name) != std::end(_archetypesCollection)) { return; } auto scene = entity->getScene(); auto representation = std::make_shared<ArchetypeEditorRepresentation>(); representation->name = name; representation->loaded = true; //we copy the original entity into the archetype entity //for that we set the ArchetypeScene as the current scene //so that messages will be not passed to the renderScene of the WE's scene //but to the ArchetypeScene. bool success = getScene()->copyEntity(entity, representation->root, true, false); AGE_ASSERT(success); representation->root->getComponent<EntityRepresentation>()->editorOnly = true; auto componentsCopy = entity->getComponentList(); auto entityRepresentationComponent = entity->getComponent<EntityRepresentation>(); AGE_ASSERT(entityRepresentationComponent != nullptr); //we remove original entity's components //replacing them by archetypes ones for (auto &e : componentsCopy) { if (e != nullptr && e != entityRepresentationComponent) { entity->copyComponent(representation->root->getComponent(e->getType())); } } std::vector<Entity*> tmpEntitiesList; std::vector<const char*> tmpEntitiesNameList; listEntityTree(entity, tmpEntitiesNameList, tmpEntitiesList); for (auto &entity : tmpEntitiesList) { auto &e = *entity; auto er = e->getComponent<EntityRepresentation>(); e->addComponent<ArchetypeComponent>(name); e->getComponent<ArchetypeComponent>()->parentIsAnArchetype = false; if (er != entityRepresentationComponent) { e->getComponent<ArchetypeComponent>()->parentIsAnArchetype = true; } } tmpEntitiesList.clear(); tmpEntitiesNameList.clear(); listEntityTree(representation->root, tmpEntitiesNameList, tmpEntitiesList); for (auto &entity : tmpEntitiesList) { auto &e = *entity; auto er = e->getComponent<EntityRepresentation>(); er->_isArchetype = true; } entityRepresentationComponent->_archetypeLinked = representation; representation->entities.insert(entity); _archetypesCollection.insert(std::make_pair(name, representation)); _regenerateImGuiNamesList(); }