void RenderManager::render(const std::vector<RenderableNode *> &renderableNodes) { // TODO: render children RenderableNode *item = NULL; int size = renderableNodes.size(); for (int i = 0; i < size; i++) { item = renderableNodes[i]; this->matrixManager->push(item->getTransform()->getMatrix()); this->matrixManager->update(); for (unsigned int m = 0; m < item->meshes.size(); m++) { Mesh *mesh = item->meshes[m]; mesh->applyMaterial(item->receiveLight); this->drawMesh(mesh); } this->matrixManager->pop(); } }
// push Renderable nodes //virtual bool ControlPointGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context) { Mesh* mesh = ShapeLibGetMesh(RenderShape::QuadLineStrip); m_localBounds = mesh->bounds; const float pointSize = 8; // control point size in pixels float upp = context->Cam().ComputeUnitPerPixel(float3(&m_world.M41), context->ViewPort().y); float scale = pointSize * upp; Matrix scaleM = Matrix::CreateScale(scale); float3 objectPos = float3(m_world.M41,m_world.M42,m_world.M43); Matrix b = Matrix::CreateBillboard(objectPos,context->Cam().CamPos(),context->Cam().CamUp(),context->Cam().CamLook()); Matrix billboard = scaleM * b; // calculate bounds for screen facing quad float3 transformed, min, max; transformed = mesh->pos[0]; transformed.Transform(billboard); min = max = transformed; for (auto it = mesh->pos.begin(); it != mesh->pos.end(); ++it) { transformed = (*it); transformed.Transform(billboard); min = minimize(min, transformed); max = maximize(max, transformed); } m_bounds = AABB(min,max); // give it same color as curve int color = 0xFFFF0000; CurveGob* curve = (CurveGob*)m_parent; if(curve != NULL) { color = curve->GetColor(); } // set renderable RenderableNode r; r.mesh = mesh; ConvertColor(color, &r.diffuse); r.objectId = GetInstanceId(); r.bounds = m_bounds; r.WorldXform = billboard; r.SetFlag(RenderableNode::kTestAgainstBBoxOnly, true); r.SetFlag(RenderableNode::kShadowCaster, false); r.SetFlag(RenderableNode::kShadowReceiver, false); collector->Add(r, RenderFlags::None, Shaders::BasicShader); return true; }
void generateRenderableNodes() { DEBUGLOG->log("Generating renderable nodes from filled cells"); for ( unsigned int i = 0; i < m_filledGridCells.size(); i++) { RenderableNode* filledCell = new RenderableNode( p_parentNode ); filledCell->scale( glm::vec3(p_axisAlignedVoxelGrid->getCellSize() ) ); // filledCell->translate( p_axisAlignedVoxelGrid->getGridCellCenter( m_filledGridCells[i].second) ); filledCell->translate( m_filledGridCells[i].second ); filledCell->setObject( p_resourceManager->getCube( ) ); m_renderableNodes.push_back(filledCell); } }
//--------------------------------------------------------------------------- void ShadowMapGen::DrawRenderable(const RenderableNode& r) { if (!r.GetFlag( RenderableNode::kShadowCaster ) ) return; ID3D11DeviceContext* dc = m_rc->Context(); ConstantBufferShadowMapGenPerDraw constBuffer; Matrix::Transpose(r.WorldXform, constBuffer.world ); UpdateConstantBuffer(dc,m_pConstantBufferPerDraw,&constBuffer,sizeof(constBuffer)); uint32_t stride = r.mesh->vertexBuffer->GetStride(); uint32_t offset = 0; uint32_t startIndex = 0; uint32_t startVertex = 0; uint32_t indexCount = r.mesh->indexBuffer->GetCount(); ID3D11Buffer* d3dvb = r.mesh->vertexBuffer->GetBuffer(); ID3D11Buffer* d3dib = r.mesh->indexBuffer->GetBuffer(); dc->IASetPrimitiveTopology( (D3D11_PRIMITIVE_TOPOLOGY)r.mesh->primitiveType ); dc->IASetVertexBuffers( 0, 1, &d3dvb, &stride, &offset ); dc->IASetIndexBuffer(d3dib, DXGI_FORMAT_R32_UINT, 0); dc->DrawIndexed(indexCount, startIndex, startVertex); }
void SkyDome::Render( RenderContext* context) { if(IsVisible() == false) return; RenderableNode r; r.mesh = ShapeLibGetMesh(RenderShape::Sphere); r.objectId = GetInstanceId(); r.textures[TextureType::Cubemap] = m_texture ? m_texture : TextureLib::Inst()->GetDefault(TextureType::Cubemap); r.SetFlag( RenderableNode::kShadowCaster, false ); r.SetFlag( RenderableNode::kShadowReceiver, false ); SkyDomeShader* pShader =(SkyDomeShader*) ShaderLib::Inst()->GetShader(Shaders::SkyDomeShader); pShader->Begin( context); pShader->SetRenderFlag( RenderFlags::None ); // call this *after* Begin() pShader->Draw(r); pShader->End(); }
void Locator::BuildRenderables() { m_renderables.clear(); Model* model = NULL; assert(m_resource); model = (Model*)m_resource->GetTarget(); assert(model && model->IsReady()); const NodeDict& nodes = model->Nodes(); for(auto nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt) { Node* node = nodeIt->second; assert(m_modelTransforms.size() >= node->index); const Matrix& world = m_modelTransforms[node->index]; // transform array holds world matricies already, not local for(auto geoIt = node->geometries.begin(); geoIt != node->geometries.end(); ++geoIt) { Geometry* geo = (*geoIt); Material * mat = geo->material; RenderableNode renderNode; renderNode.mesh = geo->mesh; renderNode.WorldXform = world; renderNode.bounds = geo->mesh->bounds; renderNode.bounds.Transform(renderNode.WorldXform); renderNode.objectId = GetInstanceId(); renderNode.diffuse = mat->diffuse; renderNode.specular = mat->specular.xyz(); renderNode.specPower = mat->power; renderNode.SetFlag( RenderableNode::kShadowCaster, GetCastsShadows() ); renderNode.SetFlag( RenderableNode::kShadowReceiver, GetReceivesShadows() ); LightingState::Inst()->UpdateLightEnvironment(renderNode); for(unsigned int i = TextureType::MIN; i < TextureType::MAX; ++i) { renderNode.textures[i] = geo->material->textures[i]; } m_renderables.push_back(renderNode); } } }
//--------------------------------------------------------------------------- void RenderableNodeSorter::Add(RenderableNode& r, RenderFlagsEnum rf, ShadersEnum shaderId) { assert(shaderId != Shaders::NONE); RenderContext* context = RenderContext::Inst(); bool selected = ( context->selection.find( r.objectId ) != context->selection.end() ); PrimitiveTypeEnum primtype = r.mesh->primitiveType; GlobalRenderFlagsEnum gflags = this->GetFlags(); bool triPrim = primtype == PrimitiveType::TriangleList || primtype == PrimitiveType::TriangleStrip; uint32_t mask =(uint32_t) ~(RenderFlags::Textured | RenderFlags::Lit); uint32_t flags = rf & (mask | gflags); flags |= (gflags & GlobalRenderFlags::RenderBackFace); bool wireflagset = (gflags & GlobalRenderFlags::WireFrame) != 0; if(triPrim) { if(gflags & GlobalRenderFlags::Solid) { Bucket& bucket = GetOrMakeBucket(flags, shaderId); bucket.renderables.push_back( r ); if(r.GetFlag(RenderableNode::kShadowCaster)) m_bounds.Extend(r.bounds); } if(selected || wireflagset) { RenderableNode node = r; node.diffuse = selected ? context->State()->GetSelectionColor() : context->State()->GetWireframeColor(); flags &= ~RenderFlags::AlphaBlend; Bucket& bucket = GetOrMakeBucket(flags, Shaders::WireFrameShader ); bucket.renderables.push_back( node ); } } else { flags &= ~RenderFlags::AlphaBlend; Bucket& bucket = GetOrMakeBucket(flags, shaderId); if(selected) { RenderableNode node = r; node.diffuse = context->State()->GetSelectionColor(); bucket.renderables.push_back( node); } else { bucket.renderables.push_back( r ); } } }
//----------------------------------------------------------------------------------------------------------------------------------- // push Renderable nodes //virtual void CurveGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context) { if (!IsVisible(context->Cam().GetFrustum()) || m_points.size() < 2) return; super::GetRenderables(collector, context); RenderableNode r; r.mesh = &m_mesh; ConvertColor(m_color, &r.diffuse); r.objectId = GetInstanceId(); r.SetFlag( RenderableNode::kShadowCaster, false ); r.SetFlag( RenderableNode::kShadowReceiver, false ); r.bounds = m_bounds; r.WorldXform = m_world; collector->Add( r, RenderFlags::None, Shaders::BasicShader ); // draw control points. for( auto it = m_points.begin(); it != m_points.end(); ++it) { (*it)->GetRenderables(collector,context); } }
//--------------------------------------------------------------------------- void ShadowMapGen::DrawRenderable(const RenderableNode& r) { if (!r.GetFlag( RenderableNode::kShadowCaster ) ) return; ID3D11DeviceContext* dc = m_rc->Context(); Matrix::Transpose(r.WorldXform, m_cbPerDraw.Data); m_cbPerDraw.Update(dc); uint32_t stride = r.mesh->vertexBuffer->GetStride(); uint32_t offset = 0; uint32_t startIndex = 0; uint32_t startVertex = 0; uint32_t indexCount = r.mesh->indexBuffer->GetCount(); ID3D11Buffer* d3dvb = r.mesh->vertexBuffer->GetBuffer(); ID3D11Buffer* d3dib = r.mesh->indexBuffer->GetBuffer(); dc->IASetPrimitiveTopology( (D3D11_PRIMITIVE_TOPOLOGY)r.mesh->primitiveType ); dc->IASetVertexBuffers( 0, 1, &d3dvb, &stride, &offset ); dc->IASetIndexBuffer(d3dib, (DXGI_FORMAT) r.mesh->indexBuffer->GetFormat(), 0); dc->DrawIndexed(indexCount, startIndex, startVertex); }
void DispatchVoxelizeComputeShader::call() { // use compute program p_computeShader->useProgram(); // unbind output texture p_voxelGrid->texture->unbindFromActiveUnit(); // upload output texture glBindImageTexture(0, p_voxelGrid->handle, 0, GL_FALSE, 0, GL_READ_WRITE, // allow both GL_R32UI); // 1 channel 32 bit unsigned int to make sure OR-ing works // upload bit mask glBindImageTexture(1, p_bitMask->getTextureHandle(), 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI ); double totalExecutionTime = 0.0; // dispatch this shader once per object for ( unsigned int i = 0; i < m_objects.size(); i++) { Object* object = m_objects[i].first; RenderableNode* objectNode = m_objects[i].second; int numVertices = 0; int numIndices = 0; int numFaces = 0; if ( object->getModel() ) { // bind positions VBO to shader storage buffer glBindBufferBase( GL_SHADER_STORAGE_BUFFER, // target 0, // target binding index object->getModel()->getPositionBufferHandle() ); // buffer numVertices = object->getModel()->getNumVertices(); // bind index buffer glBindBufferBase( GL_SHADER_STORAGE_BUFFER, // target 1, // target binding index object->getModel()->getIndexBufferHandle() ); // buffer numIndices = object->getModel()->getNumIndices(); numFaces = object->getModel()->getNumFaces(); } else { continue; } glm::mat4 modelMatrix = glm::mat4(1.0f); if (objectNode) { modelMatrix = objectNode->getAccumulatedModelMatrix(); } // upload uniform model matrix p_computeShader->uploadUniform( modelMatrix, "uniformModel"); // upload voxel grid info p_computeShader->uploadUniform( p_voxelGrid->worldToVoxel, "uniformWorldToVoxel"); // upload geometric info p_computeShader->uploadUniform( numVertices, "uniformNumVertices"); p_computeShader->uploadUniform( numIndices, "uniformNumIndices"); p_computeShader->uploadUniform( numFaces, "uniformNumFaces"); // set local group amount suitable for object size: m_num_groups_x = numFaces / p_computeShader->getLocalGroupSizeX() + ( ( numFaces % p_computeShader->getLocalGroupSizeX() == 0 ) ? 0 : 1 ); m_num_groups_y = 1; m_num_groups_z = 1; // dispatch as usual DispatchComputeShaderListener::call(); glMemoryBarrier( GL_ALL_BARRIER_BITS ); if ( m_queryTime ) { totalExecutionTime += m_executionTime; } } if ( m_queryTime ) { m_executionTime = totalExecutionTime; } // unbind image textures glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI); glBindImageTexture(1, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI); }
void postInitialize() { DEBUGLOG->log("Loading some objects"); DEBUGLOG->indent(); DEBUGLOG->log("Loading test room dae file"); DEBUGLOG->indent(); std::vector< Object* > testRoom= m_resourceManager.loadObjectsFromFile( RESOURCES_PATH "/testRoom.dae" ); DEBUGLOG->outdent(); DEBUGLOG->log("Loading overlapping geometry file"); DEBUGLOG->indent(); std::vector< Object* > overlappingGeometry = m_resourceManager.loadObjectsFromFile( RESOURCES_PATH "/overlappingGeometry.dae" ); DEBUGLOG->outdent(); DEBUGLOG->log("Loading some objects complete"); DEBUGLOG->outdent(); DEBUGLOG->log("Adding objects to a scene instance"); DEBUGLOG->indent(); Scene* scene = new Scene(); scene->addObjects( testRoom ); scene->addObjects( overlappingGeometry ); DEBUGLOG->log("Creating scene graph nodes"); DEBUGLOG->indent(); // DEBUGLOG->log("Creating node tree for rotating node"); // Node* positionNode = new Node(scene->getSceneGraph()->getRootNode()); // positionNode->translate( glm::vec3(0.0f, 0.0f, 0.0f) ); // RotatingNode* yAxisRotationNode = new RotatingNode(positionNode); // yAxisRotationNode->setAngle(0.005f); // yAxisRotationNode->setRotationAxis( glm::vec3( 0.0f, 1.0f, 0.0f ) ); // // RotatingNode* rotatingNode = new RotatingNode(yAxisRotationNode); // rotatingNode->setRotationAxis(glm::vec3 ( 1.0f, 1.0f, 0.1f)); // rotatingNode->setAngle(0.01f); // DEBUGLOG->log("Adding updatable rotation nodes to scene"); // scene->addUpdatable(yAxisRotationNode); // scene->addUpdatable(rotatingNode); // DEBUGLOG->log("Creating renderable node for overlapping geometry attached to rotating node"); // RenderableNode* overlappingGeometryNode = new RenderableNode(rotatingNode); Node* sceneNode = new Node(scene->getSceneGraph()->getRootNode() ); RenderableNode* overlappingGeometryNode = new RenderableNode( sceneNode ); overlappingGeometryNode->setObject(overlappingGeometry[0]); DEBUGLOG->log("Creating renderable node for test room"); RenderableNode* testRoomNode = new RenderableNode( sceneNode ); testRoomNode->scale( glm::vec3(0.56f, 0.56f, 0.56f) ); testRoomNode->setObject(testRoom[0]); DEBUGLOG->log("Creating camera parent node"); Node* cameraParentNode = new Node( scene->getSceneGraph()->getRootNode() ); DEBUGLOG->outdent(); DEBUGLOG->outdent(); DEBUGLOG->log("Setting scene instance as active scene "); m_sceneManager.setActiveScene(scene); DEBUGLOG->log("Configuring Rendering"); DEBUGLOG->indent(); DEBUGLOG->log("Creating phong renderpass"); DEBUGLOG->indent(); Shader* phongOrtho = new Shader(SHADERS_PATH "/myShader/phong.vert", SHADERS_PATH "/myShader/phong_backfaceCulling_ortho.frag"); FramebufferObject* fbo = new FramebufferObject(512,512); fbo->addColorAttachments(1); CameraRenderPass* phongOrthoRenderPass = new CameraRenderPass(phongOrtho, fbo); phongOrthoRenderPass->setViewport(0,0,512,512); phongOrthoRenderPass->setClearColor( 0.1f, 0.1f, 0.1f, 1.0f ); phongOrthoRenderPass->addEnable(GL_DEPTH_TEST); phongOrthoRenderPass->addClearBit(GL_DEPTH_BUFFER_BIT); phongOrthoRenderPass->addClearBit(GL_COLOR_BUFFER_BIT); CameraNode* orthographicCamera = new CameraNode(cameraParentNode); orthographicCamera->setProjectionMatrix(glm::ortho(-5.0f, 5.0f, -5.0f, 5.0f, 0.0f, 20.0f)); orthographicCamera->setPosition(0.0f,0.0f,5.0f); phongOrthoRenderPass->setCamera(orthographicCamera); DEBUGLOG->outdent(); DEBUGLOG->log("Creating perspective phong renderpass"); DEBUGLOG->indent(); Shader* phongPersp= new Shader(SHADERS_PATH "/myShader/phong.vert", SHADERS_PATH "/myShader/phong_backfaceCulling_persp.frag"); FramebufferObject* fbo2 = new FramebufferObject(512,512); fbo2->addColorAttachments(1); CameraRenderPass* phongPerspectiveRenderPass = new CameraRenderPass(phongPersp, fbo2); phongPerspectiveRenderPass->setViewport(0,0,512,512); phongPerspectiveRenderPass->setClearColor( 0.1f, 0.1f, 0.1f, 1.0f ); phongPerspectiveRenderPass->addEnable(GL_DEPTH_TEST); phongPerspectiveRenderPass->addClearBit(GL_DEPTH_BUFFER_BIT); phongPerspectiveRenderPass->addClearBit(GL_COLOR_BUFFER_BIT); CameraNode* perspectiveCamera = new CameraNode(cameraParentNode); perspectiveCamera->setProjectionMatrix(glm::perspective(60.0f, 1.0f, 0.1f, 100.0f)); perspectiveCamera->setPosition(0.0f,0.0f,5.0f); phongPerspectiveRenderPass->setCamera(perspectiveCamera); DEBUGLOG->outdent(); DEBUGLOG->log("Creating grid overlay renderpasses"); DEBUGLOG->indent(); Shader* gridPersp= new Shader(SHADERS_PATH "/grid/simpleVertex.vert", SHADERS_PATH "/grid/simpleColor.frag"); GridRenderPass* gridPerspectiveRenderPass = new GridRenderPass(gridPersp, fbo2); // just render on top of that other render pass gridPerspectiveRenderPass->setViewport(0,0,512,512); gridPerspectiveRenderPass->addEnable(GL_DEPTH_TEST); gridPerspectiveRenderPass->addEnable(GL_BLEND); gridPerspectiveRenderPass->setCamera(perspectiveCamera); GridRenderPass* gridOrthoRenderPass = new GridRenderPass(gridPersp, fbo); // just render on top of that other render pass gridOrthoRenderPass->setViewport(0,0,512,512); gridOrthoRenderPass->addEnable(GL_DEPTH_TEST); gridOrthoRenderPass->addEnable(GL_BLEND); gridOrthoRenderPass->setCamera(orthographicCamera); DEBUGLOG->outdent(); DEBUGLOG->log("Adding objects to perspective phong render pass"); phongPerspectiveRenderPass->addRenderable(overlappingGeometryNode); phongPerspectiveRenderPass->addRenderable(testRoomNode); DEBUGLOG->log("Adding objects to ortho phong render pass"); phongOrthoRenderPass->addRenderable(overlappingGeometryNode); phongOrthoRenderPass->addRenderable(testRoomNode); DEBUGLOG->log("Adding renderpasses to application"); m_renderManager.addRenderPass(phongPerspectiveRenderPass); m_renderManager.addRenderPass(phongOrthoRenderPass); m_renderManager.addRenderPass(gridPerspectiveRenderPass); m_renderManager.addRenderPass(gridOrthoRenderPass); DEBUGLOG->log("Creating screen filling triangle render passes"); DEBUGLOG->indent(); Shader* showTexture = new Shader(SHADERS_PATH "/screenspace/screenFill.vert" ,SHADERS_PATH "/screenspace/simpleTexture.frag"); DEBUGLOG->indent(); DEBUGLOG->log("Creating screen filling triangle rendering on screen for ortho phong render pass"); TriangleRenderPass* showRenderPass = new TriangleRenderPass(showTexture, 0, m_resourceManager.getScreenFillingTriangle()); showRenderPass->setViewport(0,0,512,512); showRenderPass->addClearBit(GL_COLOR_BUFFER_BIT); Texture* renderPassTexture = new Texture(); renderPassTexture->setTextureHandle(phongOrthoRenderPass->getFramebufferObject()->getColorAttachmentTextureHandle(GL_COLOR_ATTACHMENT0)); showRenderPass->addUniformTexture(renderPassTexture, "uniformTexture"); m_renderManager.addRenderPass(showRenderPass); DEBUGLOG->outdent(); DEBUGLOG->indent(); DEBUGLOG->log("Creating screen filling triangle rendering for perspective phong render pass"); TriangleRenderPass* showRenderPassPerspective = new TriangleRenderPass(showTexture, 0, m_resourceManager.getScreenFillingTriangle()); showRenderPassPerspective->setViewport(512,0,512,512); Texture* renderPassPerspectiveTexture = new Texture(); renderPassPerspectiveTexture->setTextureHandle(phongPerspectiveRenderPass->getFramebufferObject()->getColorAttachmentTextureHandle(GL_COLOR_ATTACHMENT0)); showRenderPassPerspective->addUniformTexture(renderPassPerspectiveTexture, "uniformTexture"); m_renderManager.addRenderPass(showRenderPassPerspective); DEBUGLOG->outdent(); DEBUGLOG->outdent(); DEBUGLOG->outdent(); /************************************************************************************** * VOXELGRID SETUP **************************************************************************************/ DEBUGLOG->log("Configuring voxel grid"); DEBUGLOG->indent(); DEBUGLOG->log("Creating voxel grid object"); DEBUGLOG->indent(); Grid::AxisAlignedVoxelGrid* axisAlignedVoxelGrid = new Grid::AxisAlignedVoxelGrid(-5.0f, -5.0f, -5.0f, 20, 20, 20, 0.5f); DEBUGLOG->log("Grid width : ", axisAlignedVoxelGrid->getWidth()); DEBUGLOG->log("Grid height : ", axisAlignedVoxelGrid->getHeight()); DEBUGLOG->log("Grid depth : ", axisAlignedVoxelGrid->getDepth()); DEBUGLOG->log("Grid cell size: ", axisAlignedVoxelGrid->getCellSize()); DEBUGLOG->outdent(); DEBUGLOG->log("Creating parent node for voxel grid related geometry"); Node* voxelGridNode = new Node( scene->getSceneGraph()->getRootNode() ); DEBUGLOG->outdent(); /************************************************************************************** * VOXELIZATION **************************************************************************************/ DEBUGLOG->log("Voxelizing scene"); DEBUGLOG->indent(); DEBUGLOG->log("Creating voxelizer object"); DEBUGLOG->indent(); // objects to be voxelized std::vector<Object* > objects = scene->getObjects(); std::vector<RenderPass* > gridCellRenderPasses; gridCellRenderPasses.push_back( gridOrthoRenderPass ); gridCellRenderPasses.push_back( gridPerspectiveRenderPass ); // create voxelizer CPUVoxelizer* voxelizer = new CPUVoxelizer(axisAlignedVoxelGrid, scene, &m_resourceManager, objects, voxelGridNode, gridCellRenderPasses); // configure display of cells m_resourceManager.getCube()->getMaterial()->setAttribute("uniformRed", 0.5f); m_resourceManager.getCube()->getMaterial()->setAttribute("uniformGreen", 0.1f); m_resourceManager.getCube()->getMaterial()->setAttribute("uniformBlue", 0.1f); m_resourceManager.getCube()->getMaterial()->setAttribute("uniformAlpha", 0.6f); // call voxelizer once DEBUGLOG->log("Executing voxelization"); DEBUGLOG->indent(); voxelizer->call(); DEBUGLOG->outdent(); DEBUGLOG->outdent(); DEBUGLOG->outdent(); DEBUGLOG->log("Creating voxel grid model"); Model* gridModel = m_resourceManager.generateVoxelGridModel(axisAlignedVoxelGrid->getWidth(), axisAlignedVoxelGrid->getHeight(), axisAlignedVoxelGrid->getDepth(), axisAlignedVoxelGrid->getCellSize()); axisAlignedVoxelGrid->setModel(gridModel); axisAlignedVoxelGrid->getMaterial()->setAttribute("uniformRed", 0.7f); axisAlignedVoxelGrid->getMaterial()->setAttribute("uniformGreen", 0.7f); axisAlignedVoxelGrid->getMaterial()->setAttribute("uniformBlue", 0.7f); axisAlignedVoxelGrid->getMaterial()->setAttribute("uniformAlpha", 0.1f); DEBUGLOG->log("Creating renderable node voxel grid object"); RenderableNode* axisAlignedVoxelGridNode = new RenderableNode( voxelGridNode ); axisAlignedVoxelGridNode->setObject(axisAlignedVoxelGrid); axisAlignedVoxelGridNode->translate( glm::vec3(axisAlignedVoxelGrid->getX(), axisAlignedVoxelGrid->getY(), axisAlignedVoxelGrid->getZ() ) ); // DEBUGLOG->log("Adding voxel grid object to render passes"); // gridPerspectiveRenderPass->addRenderable(axisAlignedVoxelGridNode); // gridOrthoRenderPass->addRenderable(axisAlignedVoxelGridNode); DEBUGLOG->outdent(); DEBUGLOG->log("Configuring Input"); DEBUGLOG->indent(); DEBUGLOG->log("Configuring camera movement"); Camera* movableCam = phongOrthoRenderPass->getCamera(); Camera* movableCamClone = phongPerspectiveRenderPass->getCamera(); SimpleScene::configureSimpleCameraMovement( movableCam , this, 2.5); SimpleScene::configureSimpleCameraMovement( movableCamClone, this , 2.5); // voxelize on key press : V m_inputManager.attachListenerOnKeyPress( voxelizer, GLFW_KEY_V, GLFW_PRESS); // restore on key press : R m_inputManager.attachListenerOnKeyPress( new SimpleScene::SceneGraphState( scene->getSceneGraph() ), GLFW_KEY_R, GLFW_PRESS); DEBUGLOG->log("Configuring Turntable for scene node"); Turntable* turntable = SimpleScene::configureTurnTable(sceneNode, this, 0.05f, GLFW_MOUSE_BUTTON_LEFT); Turntable* turntableCamera = SimpleScene::configureTurnTable(cameraParentNode, this, 0.05f, GLFW_MOUSE_BUTTON_RIGHT); DEBUGLOG->outdent(); }