void Projector::appendRenderables( RenderQueue& queue, const Transform* transform )
{
if( !geometry ) return;
const Transform* geotransform = geometry->getEntity()->getTransform().get();
const Matrix4x3& absoluteTransform = geotransform->getAbsoluteTransform();
const RenderablesVector& renderables = geometry->getRenderables();
for( size_t i = 0; i < renderables.size(); i++ )
{
RenderBatch* renderable = renderables[i].get();
if( !renderable ) continue;
renderable->onPreRender.Bind(this, &Projector::onPreRender);
RenderState state;
state.renderable = renderable;
state.material = material.Resolve();
state.modelMatrix = absoluteTransform;
state.priority = renderable->getRenderPriority() + 1;
queue.pushBack(state);
}
}
void MipMapReplacer::EnumerateTexturesRecursive(Entity * entity, Set<Texture *> & textures)
{
if(!entity)
return;
int32 childrenCount = entity->GetChildrenCount();
for(int32 i = 0; i < childrenCount; i++)
EnumerateTexturesRecursive(entity->GetChild(i), textures);
RenderObject * ro = GetRenderObject(entity);
if(ro)
{
int32 rbCount = ro->GetRenderBatchCount();
for(int32 i = 0; i < rbCount; i++)
{
RenderBatch * rb = ro->GetRenderBatch(i);
if(rb)
{
DVASSERT(0 && "Vitaliy Borodovsky: Temporarly disabled. Need to rewrite for new materials");
NMaterial * material = rb->GetMaterial();
if(material)
{
Texture * texture = material->GetTexture(NMaterial::TEXTURE_ALBEDO);
if(texture)
textures.insert(texture);
}
}
}
}
}
int32 NodesPropertyControl::GetTrianglesForLodLayer(LodComponent::LodData *lodData)
{
int32 trianglesCount = 0;
for(int32 n = 0; n < (int32)lodData->nodes.size(); ++n)
{
Vector<Entity *> meshes;
lodData->nodes[n]->GetChildNodes(meshes);
meshes.push_back(lodData->nodes[n]);
for(int32 m = 0; m < (int32)meshes.size(); ++m)
{
RenderObject *ro = GetRenerObject(meshes[m]);
if(!ro || ro->GetType() != RenderObject::TYPE_MESH) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 r = 0; r < count; ++r)
{
RenderBatch *batch = ro->GetRenderBatch(r);
PolygonGroup *pg = batch->GetPolygonGroup();
if(pg)
{
trianglesCount += pg->GetIndexCount() / 3;
}
}
}
}
return trianglesCount;
}
void RenderObject::Load(KeyedArchive * archive, SceneFileV2 *sceneFile)
{
if(NULL != archive)
{
if(archive->IsKeyExists("ro.type")) type = archive->GetUInt32("ro.type");
if(archive->IsKeyExists("ro.flags")) flags = archive->GetUInt32("ro.flags");
if(archive->IsKeyExists("ro.debugflags")) debugFlags = archive->GetUInt32("ro.debugflags");
if(archive->IsKeyExists("ro.batchCount"))
{
KeyedArchive *batchesArch = archive->GetArchive("ro.batches");
for(uint32 i = 0; i < archive->GetUInt32("ro.batchCount"); ++i)
{
KeyedArchive *batchArch = batchesArch->GetArchive(KeyedArchive::GenKeyFromIndex(i));
if(NULL != batchArch)
{
RenderBatch *batch = (RenderBatch *) ObjectFactory::Instance()->New(batchArch->GetString("rb.classname"));
if(NULL != batch)
{
batch->Load(batchArch, sceneFile);
AddRenderBatch(batch);
batch->Release();
}
}
}
}
}
AnimatedObject::Load(archive);
}
RenderObject* SkyboxRenderObject::Clone(RenderObject *newObject)
{
if(!newObject)
{
DVASSERT_MSG(IsPointerToExactClass<SkyboxRenderObject>(this), "Can clone only SkyboxRenderObject");
newObject = new SkyboxRenderObject();
}
SkyboxRenderObject* skyboxRenderObject = static_cast<SkyboxRenderObject*>(newObject);
skyboxRenderObject->type = type;
skyboxRenderObject->flags = flags;
skyboxRenderObject->RemoveFlag(RenderObject::TREE_NODE_NEED_UPDATE);
skyboxRenderObject->debugFlags = debugFlags;
skyboxRenderObject->ownerDebugInfo = ownerDebugInfo;
skyboxRenderObject->bbox = bbox;
skyboxRenderObject->texturePath = texturePath;
skyboxRenderObject->offsetZ = offsetZ;
skyboxRenderObject->rotationZ = rotationZ;
skyboxRenderObject->nonClippingDistance = nonClippingDistance;
uint32 size = GetRenderBatchCount();
for(uint32 i = 0; i < size; ++i)
{
RenderBatch *batch = GetRenderBatch(i)->Clone();
skyboxRenderObject->AddRenderBatch(batch);
batch->Release();
}
skyboxRenderObject->BuildSkybox();
skyboxRenderObject->UpdateMaterial();
return newObject;
}
void MipMapReplacer::EnumerateTexturesRecursive(Entity * entity, Set<Texture *> & textures)
{
if(!entity)
return;
int32 childrenCount = entity->GetChildrenCount();
for(int32 i = 0; i < childrenCount; i++)
EnumerateTexturesRecursive(entity->GetChild(i), textures);
RenderObject * ro = GetRenderObject(entity);
if(ro)
{
int32 rbCount = ro->GetRenderBatchCount();
for(int32 i = 0; i < rbCount; i++)
{
RenderBatch * rb = ro->GetRenderBatch(i);
if(rb)
{
Material * material = rb->GetMaterial();
if(material)
{
Texture * texture = material->GetTexture(Material::TEXTURE_DIFFUSE);
if(texture)
textures.insert(texture);
}
}
}
}
}
RenderObject * RenderObject::Clone(RenderObject *newObject)
{
if(!newObject)
{
DVASSERT_MSG(IsPointerToExactClass<RenderObject>(this), "Can clone only RenderObject");
newObject = new RenderObject();
}
newObject->type = type;
newObject->flags = flags;
newObject->debugFlags = debugFlags;
//ro->bbox = bbox;
//ro->worldBBox = worldBBox;
uint32 size = GetRenderBatchCount();
for(uint32 i = 0; i < size; ++i)
{
RenderBatch *batch = GetRenderBatch(i)->Clone();
newObject->AddRenderBatch(batch);
batch->Release();
}
newObject->ownerDebugInfo = ownerDebugInfo;
return newObject;
}
void RenderObject::Save(KeyedArchive * archive, SceneFileV2* sceneFile)
{
AnimatedObject::Save(archive);
if(NULL != archive)
{
archive->SetUInt32("ro.type", type);
archive->SetUInt32("ro.flags", flags);
archive->SetUInt32("ro.debugflags", debugFlags);
archive->SetUInt32("ro.batchCount", GetRenderBatchCount());
KeyedArchive *batchesArch = new KeyedArchive();
for(uint32 i = 0; i < GetRenderBatchCount(); ++i)
{
RenderBatch *batch = GetRenderBatch(i);
if(NULL != batch)
{
KeyedArchive *batchArch = new KeyedArchive();
batch->Save(batchArch, sceneFile);
if(batchArch->Count() > 0)
{
batchArch->SetString("rb.classname", batch->GetClassName());
}
batchesArch->SetArchive(KeyedArchive::GenKeyFromIndex(i), batchArch);
batchArch->Release();
}
}
archive->SetArchive("ro.batches", batchesArch);
batchesArch->Release();
}
}
void MainForwardRenderPass::Draw(RenderSystem * renderSystem, uint32 clearBuffers)
{
Camera *mainCamera = renderSystem->GetMainCamera();
Camera *drawCamera = renderSystem->GetDrawCamera();
DVASSERT(mainCamera);
DVASSERT(drawCamera);
drawCamera->SetupDynamicParameters();
if (mainCamera!=drawCamera)
mainCamera->PrepareDynamicParameters();
if (needWaterPrepass)
{
/*water presence is cached from previous frame in optimization purpose*/
/*if on previous frame there was water - reflection and refraction textures are rendered first (it helps to avoid excessive renderPassBatchArray->PrepareVisibilityArray)*/
/* if there was no water on previous frame, and it appears on this frame - reflection and refractions textures are still to be rendered*/
PrepareReflectionRefractionTextures(renderSystem);
}
//important: FoliageSystem also using main camera for cliping vegetation cells
PrepareVisibilityArrays(mainCamera, renderSystem);
RenderLayerBatchArray *waterLayer = renderPassBatchArray->Get(RenderLayerManager::Instance()->GetLayerIDByName(LAYER_WATER));
uint32 waterBatchesCount = waterLayer->GetRenderBatchCount();
if (waterBatchesCount)
{
waterBox.Empty();
for (uint32 i=0; i<waterBatchesCount; ++i)
{
RenderBatch *batch = waterLayer->Get(i);
waterBox.AddAABBox(batch->GetRenderObject()->GetWorldBoundingBox());
}
}
if (!needWaterPrepass&&waterBatchesCount)
{
PrepareReflectionRefractionTextures(renderSystem);
/*as PrepareReflectionRefractionTextures builds render batches according to reflection/refraction camera - render batches in main pass list are not valid anymore*/
/*to avoid this happening every frame water visibility is cached from previous frame (needWaterPrepass)*/
/*however if there was no water on previous frame and there is water on this frame visibilityArray should be re-prepared*/
renderPassBatchArray->Clear();
renderPassBatchArray->PrepareVisibilityArray(&visibilityArray, mainCamera);
}
needWaterPrepass = (waterBatchesCount!=0); //for next frame;
ClearBuffers(clearBuffers);
DrawLayers(mainCamera);
}
void BulletObject::CreateFromEntity()
{
bool wasPolygonGroup = false;
RenderObject * renderObject = ((RenderComponent*)entity->GetComponent(Component::RENDER_COMPONENT))->GetRenderObject();
uint32 batchesCount = renderObject->GetRenderBatchCount();
for(uint32 batchIndex = 0; batchIndex < batchesCount; ++batchIndex)
{
RenderBatch * batch = renderObject->GetRenderBatch(batchIndex);
PolygonGroup * pg = batch->GetPolygonGroup();
if(pg)
{
if(!wasPolygonGroup)
{
collisionObject = new btCollisionObject();
trimesh = new btTriangleMesh();
createdWith = entity->GetWorldTransform();
wasPolygonGroup = true;
}
for(int32 i = 0; i < pg->indexCount / 3; i++)
{
uint16 index0 = pg->indexArray[i*3];
uint16 index1 = pg->indexArray[i*3+1];
uint16 index2 = pg->indexArray[i*3+2];
Vector3 v;
pg->GetCoord(index0, v);
v = v * createdWith;
btVector3 vertex0(v.x, v.y, v.z);
pg->GetCoord(index1, v);
v = v * createdWith;
btVector3 vertex1(v.x, v.y, v.z);
pg->GetCoord(index2, v);
v = v * createdWith;
btVector3 vertex2(v.x, v.y, v.z);
trimesh->addTriangle(vertex0,vertex1,vertex2, false);
}
}
}
if(wasPolygonGroup)
{
shape = new btBvhTriangleMeshShape(trimesh, true, true);
collisionObject->setCollisionShape(shape);
collWorld->addCollisionObject(collisionObject);
}
}
RenderBatch* Camera::renderBatch(int queue)
{
for (int i = 0; i < m_renderBatches->count(); ++i)
{
RenderBatch* batch = (RenderBatch*)m_renderBatches->get(i);
if (batch->renderQueue() == queue)
{
return batch;
}
}
RenderBatch* batch = RenderBatch::create(this, queue);
batch->autorelease();
m_renderBatches->add(batch);
return batch;
}
RenderBatchPtr Model::createDebugRenderable() const
{
MaterialHandle handleMaterial = MaterialCreate(AllocatorGetHeap(), "SkeletonDebug");
Material* material = handleMaterial.Resolve();
material->setDepthTest(false);
GeometryBuffer* gb = AllocateHeap(GeometryBuffer);
RenderBatch* renderable = AllocateHeap(Renderable);
renderable->setPrimitiveType(PrimitiveType::Lines);
renderable->setGeometryBuffer(gb);
renderable->setMaterial(handleMaterial);
return renderable;
}
Projector::~Projector()
{
if( !geometry ) return;
const RenderablesVector& renderables = geometry->getRenderables();
for( size_t i = 0; i < renderables.size(); i++ )
{
RenderBatch* renderable = renderables[i].get();
renderable->onPreRender.clear();
const UniformBufferPtr& ub = renderable->getUniformBuffer();
ub->removeUniform("vp_TextureProjection");
ub->removeUniform("vp_TextureView");
}
}
void Camera::present()
{
// Viewport
Rectf viewportRect;
if (m_renderTexture)
{
glViewport(0, 0, m_renderTexture->width(), m_renderTexture->height());
m_renderTexture->begin();
viewportRect = Rectf(0, 0, m_renderTexture->width(), m_renderTexture->height());
}
else
{
glViewport((GLint)m_viewportRect.x(), (GLint)m_viewportRect.y(), (GLsizei)m_viewportRect.width(), (GLsizei)m_viewportRect.height());
viewportRect = m_viewportRect;
}
// Prepare matrices
if (m_isProjectionDirty)
{
if (m_projectType == Orthographic)
{
buildOrthographicProjectionMatrix(m_projection, viewportRect, m_orthoSize, m_zNear, m_zFar, m_renderTexture != NULL);
}
m_isProjectionDirty = false;
}
m_worldviewprojection = m_projection * m_view;
// Clear
if (m_clearType != NONE)
{
glClearColor(m_backgroundColor.red, m_backgroundColor.green, m_backgroundColor.blue, m_backgroundColor.alpha);
glClear(m_clearType);
}
for (int i = 0; i < m_renderBatches->count(); ++i)
{
RenderBatch* batch = (RenderBatch*)m_renderBatches->get(i);
batch->draw();
batch->clear();
}
if (m_renderTexture)
{
m_renderTexture->end();
}
}
void TextureHelper::EnumerateTextures(DAVA::Entity *forNode, Map<String, Texture *> &textures)
{
if(!forNode) return;
Vector<Entity *> nodes;
forNode->GetChildNodes(nodes);
nodes.push_back(forNode);
for(int32 n = 0; n < (int32)nodes.size(); ++n)
{
RenderComponent *rc = static_cast<RenderComponent *>(nodes[n]->GetComponent(Component::RENDER_COMPONENT));
if(!rc) continue;
RenderObject *ro = rc->GetRenderObject();
if(!ro) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
NMaterial *material = renderBatch->GetMaterial();
if(material)
{
for(int32 t = 0; t < material->GetTextureCount(); ++t)
{
Texture* tx = material->GetTexture(t);
CollectTexture(textures, tx->GetPathname(), tx);
}
}
/*InstanceMaterialState *instanceMaterial = renderBatch->GetMaterialInstance();
if(instanceMaterial)
{
CollectTexture(textures, instanceMaterial->GetLightmapName(), instanceMaterial->GetLightmap());
}*/
}
Landscape *land = dynamic_cast<Landscape *>(ro);
if(land)
{
CollectLandscapeTextures(textures, land);
}
}
}
void SceneHelper::EnumerateDescriptors(DAVA::Entity *forNode, DAVA::Set<DAVA::FilePath> &descriptors)
{
if(!forNode) return;
Vector<Entity *> nodes;
forNode->GetChildNodes(nodes);
nodes.push_back(forNode);
for(int32 n = 0; n < (int32)nodes.size(); ++n)
{
RenderComponent *rc = static_cast<RenderComponent *>(nodes[n]->GetComponent(Component::RENDER_COMPONENT));
if(!rc) continue;
RenderObject *ro = rc->GetRenderObject();
if(!ro) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
Material *material = renderBatch->GetMaterial();
if(material)
{
for(int32 t = 0; t < Material::TEXTURE_COUNT; ++t)
{
CollectDescriptors(descriptors, material->GetTextureName((DAVA::Material::eTextureLevel)t));
}
}
InstanceMaterialState *instanceMaterial = renderBatch->GetMaterialInstance();
if(instanceMaterial)
{
CollectDescriptors(descriptors, instanceMaterial->GetLightmapName());
}
}
Landscape *land = dynamic_cast<Landscape *>(ro);
if(land)
{
CollectLandscapeDescriptors(descriptors, land);
}
}
}
void SceneHelper::EnumerateTextures(Entity *forNode, Map<String, Texture *> &textures)
{
if(!forNode) return;
Vector<Entity *> nodes;
forNode->GetChildNodes(nodes);
nodes.push_back(forNode);
for(int32 n = 0; n < (int32)nodes.size(); ++n)
{
RenderObject *ro = GetRenderObject(nodes[n]);
if(!ro) continue;
uint32 count = ro->GetRenderBatchCount();
for(uint32 b = 0; b < count; ++b)
{
RenderBatch *renderBatch = ro->GetRenderBatch(b);
Material *material = renderBatch->GetMaterial();
if(material)
{
for(int32 t = 0; t < Material::TEXTURE_COUNT; ++t)
{
CollectTexture(textures, material->GetTextureName((DAVA::Material::eTextureLevel)t).GetAbsolutePathname(), material->GetTexture((DAVA::Material::eTextureLevel)t));
}
}
InstanceMaterialState *instanceMaterial = renderBatch->GetMaterialInstance();
if(instanceMaterial)
{
CollectTexture(textures, instanceMaterial->GetLightmapName().GetAbsolutePathname(), instanceMaterial->GetLightmap());
}
}
Landscape *land = dynamic_cast<Landscape *>(ro);
if(land)
{
CollectLandscapeTextures(textures, land);
}
}
}
bool DAEConvertWithSettingsAction::CopyRenderObjects( DAVA::RenderObject *srcRo, DAVA::RenderObject *dstRo )
{
uint32 srcBatchCount = srcRo->GetRenderBatchCount();
uint32 dstBatchCount = dstRo->GetRenderBatchCount();
if(srcBatchCount != dstBatchCount)
{
return false;
}
for(uint32 i = 0; i < srcBatchCount; ++i)
{
RenderBatch *srcBatch = srcRo->GetRenderBatch(i);
RenderBatch *dstBatch = dstRo->GetRenderBatch(i);
dstBatch->SetPolygonGroup(srcBatch->GetPolygonGroup());
}
return true;
}
void Mesh::AddPolygonGroup(PolygonGroup * polygonGroup, Material * material)
{
RenderBatch * batch = new RenderBatch();
batch->SetPolygonGroup(polygonGroup);
batch->SetMaterial(material);
batch->SetRenderDataObject(polygonGroup->renderDataObject);
batch->SetStartIndex(0);
batch->SetIndexCount(polygonGroup->GetIndexCount());
AddRenderBatch(batch);
batch->Release();
//polygonGroups.push_back(polygonGroup);
}
void SkyboxSystem::Reload()
{
if(skyboxEntity)
{
RenderComponent* renderComponent = static_cast<RenderComponent*>(skyboxEntity->GetComponent(Component::RENDER_COMPONENT));
SkyboxRenderObject* renderObj = cast_if_equal<SkyboxRenderObject*>(renderComponent->GetRenderObject());
if(renderObj &&
renderObj->GetRenderBatchCount() > 0)
{
RenderBatch* renderBatch = renderObj->GetRenderBatch(0);
Material* material = renderBatch->GetMaterial();
if(material)
{
Texture* texture = material->GetTexture(Material::TEXTURE_DIFFUSE);
if(texture)
{
texture->Reload();
}
}
}
}
}
void SkyboxRenderObject::CreateRenderData()
{
if(renderBatchArray.size() == 0)
{
RenderDataObject* renderDataObj = new RenderDataObject();
Material* skyboxMaterial = new Material();
skyboxMaterial->SetType(Material::MATERIAL_SKYBOX);
skyboxMaterial->SetAlphablend(false);
skyboxMaterial->SetName("SkyBox_material");
skyboxMaterial->GetRenderState()->SetDepthFunc(CMP_LEQUAL);
skyboxMaterial->GetRenderState()->state |= RenderState::STATE_DEPTH_TEST;
skyboxMaterial->GetRenderState()->state &= ~RenderState::STATE_DEPTH_WRITE;
RenderBatch* skyboxRenderBatch = new RenderBatch();
skyboxRenderBatch->SetRenderDataObject(renderDataObj);
skyboxRenderBatch->SetMaterial(skyboxMaterial);
SafeRelease(renderDataObj);
SafeRelease(skyboxMaterial);
RenderObject::AddRenderBatch(skyboxRenderBatch);
SafeRelease(skyboxRenderBatch);
}
}
void RenderLayer::Update(Camera * camera)
{
// Need sort
if ((flags & SORT_THIS_FRAME) == SORT_THIS_FRAME)
{
uint32 renderBatchCount = (uint32)renderBatchArray.size();
sortArray.resize(renderBatchCount);
if (flags & SORT_BY_MATERIAL)
{
for (uint32 k = 0; k < renderBatchCount; ++k)
{
RenderBatchSortItem & item = sortArray[k];
RenderBatch * batch = renderBatchArray[k];;
item.renderBatch = batch;
item.sortingKey = ((pointer_size)renderBatchArray[k]->GetMaterial() & 0x0fffffff) | (batch->GetSortingKey() << 28);
}
std::stable_sort(sortArray.begin(), sortArray.end(), MaterialCompareFunction);
for (uint32 k = 0; k < renderBatchCount; ++k)
{
RenderBatchSortItem & item = sortArray[k];
renderBatchArray[k] = item.renderBatch;
item.renderBatch->SetRemoveIndex(this, k);
}
flags &= ~SORT_REQUIRED;
}
if (flags & SORT_BY_DISTANCE)
{
Vector3 cameraPosition = camera->GetPosition();
for (uint32 k = 0; k < renderBatchCount; ++k)
{
RenderBatchSortItem & item = sortArray[k];
RenderBatch * batch = renderBatchArray[k];;
item.renderBatch = batch;
item.sortingKey = 0;
if (batch)
{
RenderObject * renderObject = batch->GetRenderObject();
Vector3 position = renderObject->GetBoundingBox().GetCenter();
float32 distance = (position - cameraPosition).Length();
item.sortingKey = (((uint32)distance) & 0x0fffffff) | (batch->GetSortingKey() << 24);
}
}
std::stable_sort(sortArray.begin(), sortArray.end(), MaterialCompareFunction);
for (uint32 k = 0; k < renderBatchCount; ++k)
{
RenderBatchSortItem & item = sortArray[k];
renderBatchArray[k] = item.renderBatch;
item.renderBatch->SetRemoveIndex(this, k);
}
flags |= SORT_REQUIRED;
}
}
}
void RenderDevice::render( const RenderState& state, const LightQueue& lights )
{
BufferManager* buffers = activeContext->bufferManager;
ProgramManager* programs = activeContext->programManager;
RenderBatch* renderable = state.renderable;
bindBuffers(renderable);
const GeometryBuffer* gb = renderable->getGeometryBuffer().get();
if( gb->data.Empty() ) return;
BufferEntry* bufs = buffers->getBuffer(gb);
// Setup the vertex buffer format.
VertexBuffer* vb = bufs->vb.get();
renderBackend->setupVertexBuffer(vb);
Material* material = state.material;
ShaderMaterial* shader = material->getShader().Resolve();
ShaderProgram* shaderProgram = programs->getProgram(shader);
if( !shaderProgram ) return;
if( !shaderProgram->isLinked() && !shaderProgram->link() )
return;
shaderProgram->bind();
renderBackend->setupRenderState(state, true);
bindTextureUnits(state, true);
if( !renderable->onPreRender.empty() )
{
// Call the user pre render hook.
renderable->onPreRender(activeView, state);
}
RenderLayer stage = renderable->getRenderLayer();
if( stage != RenderLayer::Overlays )
{
if( !setupRenderStateMatrix(state) )
return;
//if( !setupRenderStateLight(state, lights) )
// return;
}
else if( stage == RenderLayer::Overlays )
{
if( !setupRenderStateOverlay(state) )
return;
}
UniformBuffer* ub = renderable->getUniformBuffer().get();
shaderProgram->setUniforms(ub);
renderBackend->renderBatch(renderable);
if( !renderable->onPostRender.empty() )
{
// Call the user post render hook.
renderable->onPostRender(activeView, state);
}
renderBackend->unsetupRenderState(state);
unbindTextureUnits(state.material);
shaderProgram->unbind();
renderBackend->unbindVertexBuffer(vb);
unbindBuffers(renderable);
}
void GUIButton::AddToBatch(RenderBatch& batch, GUI* caller) {
batch.Add(mButtonBottom);
batch.Add(mButtonTop);
batch.Add(mButtonText);
}
bool SwitchToRenerObjectConverter::MergeSwitch(Entity * entity)
{
Vector<Entity*> entitiesToRemove;
SwitchComponent * sw = GetSwitchComponent(entity);
if(sw)
{
RenderComponent * rc = GetRenderComponent(entity);
RenderObject * ro = 0;
if(!rc)
{
ro = new Mesh();
rc = new RenderComponent(ro);
ro->Release();
ro->SetAABBox(AABBox3(Vector3(0, 0, 0), Vector3(0, 0, 0)));
entity->AddComponent(rc);
}
else
{
ro = rc->GetRenderObject();
}
DVASSERT(ro);
int32 size = entity->GetChildrenCount();
for(int32 i = 0; i < size; ++i)
{
Entity * sourceEntity = entity->GetChild(i);
RenderObject * sourceRenderObject = GetRenderObject(sourceEntity);
//workaround for custom properties for crashed model
if(1 == i) // crash model
{
KeyedArchive *childProps = GetCustomPropertiesArchieve(sourceEntity);
if(childProps && childProps->IsKeyExists("CollisionType"))
{
KeyedArchive *entityProps = GetOrCreateCustomProperties(entity)->GetArchive();
entityProps->SetInt32("CollisionTypeCrashed", childProps->GetInt32("CollisionType", 0));
}
}
//end of custom properties
Vector<std::pair<Entity*, RenderObject*> > renderPairs;
if(sourceRenderObject)
{
renderPairs.push_back(std::make_pair(sourceEntity, sourceRenderObject));
}
else
{
FindRenderObjectsRecursive(sourceEntity, renderPairs);
DVASSERT(renderPairs.size() == 1);
sourceRenderObject = renderPairs[0].second;
}
if(sourceRenderObject)
{
TransformComponent * sourceTransform = GetTransformComponent(sourceEntity);
if (sourceTransform->GetLocalTransform() != Matrix4::IDENTITY)
{
PolygonGroup * pg = sourceRenderObject->GetRenderBatchCount() > 0 ? sourceRenderObject->GetRenderBatch(0)->GetPolygonGroup() : 0;
if(pg && bakedPolygonGroups.end() == bakedPolygonGroups.find(pg))
{
sourceRenderObject->BakeGeometry(sourceTransform->GetLocalTransform());
bakedPolygonGroups.insert(pg);
}
}
uint32 sourceSize = sourceRenderObject->GetRenderBatchCount();
while(sourceSize)
{
int32 lodIndex, switchIndex;
RenderBatch * sourceRenderBatch = sourceRenderObject->GetRenderBatch(0, lodIndex, switchIndex);
sourceRenderBatch->Retain();
sourceRenderObject->RemoveRenderBatch(sourceRenderBatch);
ro->AddRenderBatch(sourceRenderBatch, lodIndex, i);
sourceRenderBatch->Release();
sourceSize--;
}
}
renderPairs[0].first->RemoveComponent(Component::RENDER_COMPONENT);
LodComponent * lc = GetLodComponent(sourceEntity);
if((0 != lc) && (0 == GetLodComponent(entity)))
{
LodComponent * newLod = (LodComponent*)lc->Clone(entity);
entity->AddComponent(newLod);
}
renderPairs[0].first->RemoveComponent(Component::LOD_COMPONENT);
if(sourceEntity->GetChildrenCount() == 0)
{
entitiesToRemove.push_back(sourceEntity);
}
}
}
uint32 entitiesToRemoveCount = entitiesToRemove.size();
for(uint32 i = 0; i < entitiesToRemoveCount; ++i)
{
entitiesToRemove[i]->GetParent()->RemoveNode(entitiesToRemove[i]);
}
return false;
}
void RenderLayer::Draw(const FastName & ownerRenderPass, Camera * camera, RenderLayerBatchArray * renderLayerBatchArray)
{
TIME_PROFILE("RenderLayer::Draw");
renderLayerBatchArray->Sort(camera);
#if CAN_INSTANCE_CHECK
RenderBatch * prevBatch = 0;
uint32 canBeInstanced = 0;
Vector<int32> chain;
#endif
uint32 size = (uint32)renderLayerBatchArray->GetRenderBatchCount();
RenderOptions* options = RenderManager::Instance()->GetOptions();
bool layerOcclustionStatsEnabled = options->IsOptionEnabled(RenderOptions::LAYER_OCCLUSION_STATS);
if(layerOcclustionStatsEnabled)
{
if(NULL == occlusionQuery)
{
occlusionQuery = new OcclusionQuery();
occlusionQuery->Init();
}
if(false == queryPending)
{
occlusionQuery->BeginQuery();
}
}
for (uint32 k = 0; k < size; ++k)
{
RenderBatch * batch = renderLayerBatchArray->Get(k);
#if CAN_INSTANCE_CHECK
if (prevBatch && batch->GetPolygonGroup() == prevBatch->GetPolygonGroup() && batch->GetMaterial()->GetParent() == prevBatch->GetMaterial()->GetParent())
{
canBeInstanced++;
}else
{
if (canBeInstanced > 0)
chain.push_back(canBeInstanced + 1);
canBeInstanced = 0;
}
#endif
batch->Draw(ownerRenderPass, camera);
#if CAN_INSTANCE_CHECK
prevBatch = batch;
#endif
}
if(layerOcclustionStatsEnabled)
{
if(false == queryPending)
{
occlusionQuery->EndQuery();
queryPending = true;
}
if((true == queryPending) &&
occlusionQuery->IsResultAvailable())
{
occlusionQuery->GetQuery(&lastFragmentsRenderedValue);
queryPending = false;
}
}
#if CAN_INSTANCE_CHECK
int32 realDrawEconomy = 0;
for (uint32 k = 0; k < chain.size(); ++k)
{
realDrawEconomy += (chain[k] - 1);
}
Logger::Debug("Pass: %s Layer: %s Size: %d Can be instanced: %d Econ: %d", ownerRenderPass.c_str(), name.c_str(), size, chain.size(), realDrawEconomy);
for (uint32 k = 0; k < chain.size(); ++k)
{
Logger::Debug("%d - %d", k, chain[k]);
}
#endif
}
void Compass::render(RenderBatch& renderBatch) {
renderBatch.add(this);
}
