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();
}
