Node* CameraNode::Clone() const
{
CameraNode* node = new CameraNode;
node->SetCamera(m_camera);
CloneInternals(node);
return node;
}
int SceneManager::checkNodeVisibility( SceneNode &node, CameraNode &cam, bool checkOcclusion, bool calcLod )
{
// Note: This function is a bit hacky with all the hard-coded node types
if( node._dirty ) updateNodes();
// Check occlusion
if( checkOcclusion && cam._occSet >= 0 )
{
if( node.getType() == SceneNodeTypes::Mesh && cam._occSet < (int)((MeshNode *)&node)->_occQueries.size() )
{
if( gRDI->getQueryResult( ((MeshNode *)&node)->_occQueries[cam._occSet] ) < 1 )
return -1;
}
else if( node.getType() == SceneNodeTypes::Emitter && cam._occSet < (int)((EmitterNode *)&node)->_occQueries.size() )
{
if( gRDI->getQueryResult( ((EmitterNode *)&node)->_occQueries[cam._occSet] ) < 1 )
return -1;
}
else if( node.getType() == SceneNodeTypes::Light && cam._occSet < (int)((LightNode *)&node)->_occQueries.size() )
{
if( gRDI->getQueryResult( ((LightNode *)&node)->_occQueries[cam._occSet] ) < 1 )
return -1;
}
}
// Frustum culling
if( cam.getFrustum().cullBox( node.getBBox() ) )
return -1;
else if( calcLod )
return node.calcLodLevel( cam.getAbsPos() );
else
return 0;
}
void StockShapeSelector::MousePressEvent(QMouseEvent* event) {
// Convert the mouse coordinates into a world-space ray.
Viewport* viewport = renderer_->GetViewport();
CameraNode* camera = viewport->GetCamera();
const QVector3D dir = camera->Unproject(event->x(), event->y()).normalized();
const QVector3D start = camera->Translation();
// Cast the ray into the scene to select an object. This query is performed
// using axis-aligned bounding boxes, which are fast and generally
// sufficient. The bounding boxes are automatically computed from the scene
// graph geometry, so we get the tests "for free".
//
// If we wanted more precise ray casting, then we could cull the results of
// the query with a more exact method (e.g., based on a custom collision
// volume).
const int64_t selection_mask = 0x1;
SelectionQuery query(renderer_->GetScene());
std::vector<QueryResult> qresult = query.CastRay(selection_mask, start, dir);
if (qresult.empty()) {
return;
}
// Found an object. Pass it on to StockShapeRenderer
QueryResult& first_result = qresult.front();
renderer_->NodeSelected(first_result.node);
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "camnode", ros::init_options::AnonymousName);
ros::NodeHandle node;
ros::NodeHandle node_priv("~");
DynamicReconfigureCameraConfig config_srv;
DynamicReconfigureCameraConfig::CallbackType cb;
CameraNode* cn = new CameraNode(node_priv, argc,argv);
cb = boost::bind(&CameraNode::config_callback, cn, _1, _2);
config_srv.setCallback(cb);
return cn->run();
}
State::stateResult_t SurfelRenderer::doEnableState(FrameContext & context, Node * node, const RenderParam & rp) {
State::stateResult_t result = NodeRendererState::doEnableState(context,node,rp);
if( result == State::STATE_OK ){
CameraNode* camera = dynamic_cast<CameraNode*>( context.getCamera() );
if(camera){ // else: an orthographic camera is used; just re-use the previous values.
cameraOrigin = camera->getWorldOrigin();
projectionScale = camera->getWidth() / (std::tan((camera->getRightAngle()-camera->getLeftAngle()).rad()*0.5f)*2.0f);
}
}
return result;
}
Viewer::Viewer(QWidget* parent) :
QMainWindow(parent),
resources_(ResourceManager::Create()),
default_scene_(resources_->MakeScene("default_scene")),
viewport_(new Viewport(resources_, default_scene_, this)) {
// Add a couple lights
LightNode* light0 = default_scene_->MakeLight(default_scene_->Root());
light0->SetDirection(QVector3D(1, 1, -1));
light0->SetLightType(LightType::kDirectional);
light0->SetAmbient(0.05);
// Add a camera to the scene
CameraNode* camera = default_scene_->MakeCamera(default_scene_->Root());
// Set the camera perspective projection parameters, and point it somewhere.
const QVector3D eye(5, 5, -10);
const QVector3D look_at(0, 0, 0);
const QVector3D up(0, 0, -1);
camera->LookAt(eye, look_at, up);
camera->SetProjectionParams(CameraNode::kPerspective, 50, 0.1, 5000);
// Assign the camera to the viewport
viewport_->SetCamera(camera);
// Add a renderer widget stack
renderer_widget_stack_ = new RendererWidgetStack(this);
// Whenever a renderer is added to the viewport, add its widget to
// the renderer widget stack and a menu entry.
connect(viewport_, &Viewport::RendererAdded,
this, &Viewer::OnRendererAdded);
// Similarly, whenever an input handler is added to the viewport, add
// a menu entry.
connect(viewport_, &Viewport::InputHandlerAdded,
this, &Viewer::OnInputHandlerAdded);
connect(viewport_, &Viewport::InputHandlerActivated,
this, &Viewer::OnInputHandlerActivated);
setCentralWidget(viewport_);
addDockWidget(Qt::LeftDockWidgetArea, renderer_widget_stack_);
// Add the input controls dock widget
input_handler_widget_ = new InputHandlerWidgetStack(viewport_, this);
addDockWidget(Qt::LeftDockWidgetArea, input_handler_widget_);
CreateMenus();
resize(800, 600);
}
TextureProjectorNode::TextureProjectorNode( Texture* texture, SceneManagerptr sceneManagerPtr, Nodeptr parent )
:Node(parent , sceneManagerPtr)
{
this->texture = texture;
projectionPolicy = PROJECTION_POLICY_PROJECTOR;
projectorPosition.x = 15.0f; projectorPosition.y = 16.0f; projectorPosition.z = -12.0f;
projectorTarget.x = 0.0f; projectorTarget.y = 0.0f; projectorTarget.z = 0.0f;
projectorUp.x = 0.0f; projectorUp.y =1.0f; projectorUp.z = 0.0f;
textureProjector = new TextureProjector(sceneManager->getActiveCamera() , projectorPosition, projectorTarget, projectorUp);
projectorUpdator = new ProjectorUpdater(textureProjector);
addAnimator(projectorUpdator);
projectorTexUnitState = new TextureUnitState(texture);
projectorTexUnitState->getTextureAttributes()->texture_mode = ETEXM_MODULATE;
projectorTexUnitState->getTexCoordGeneration()->bEnable = true;
projectorTexUnitState->getTexCoordGeneration()->texGenMode = ETGM_EYE_LINEAR;
projectorTexUnitState->getTexCoordGeneration()->texComponentFormat = ETCF_4;
projectorUpdator->projectorTextureAttributes = projectorTexUnitState->getTextureAttributes();
Vector3 dir, right, upVector;
dir.sub( projectorTarget, projectorPosition);
dir.normalize();
CameraNode* camera = sceneManager->getActiveCamera();
float fov = camera->getFOV();
dir.scale( camera->getNearPlane() );
Matrix4f& view = textureProjector->getViewMatrix();
right.x = view.m00; right.y = view.m01;right.z = view.m02;
upVector.x = view.m10; upVector.x = view.m11; upVector.x = view.m12;
float height = 2.0f*camera->getNearPlane()*tan(fov/2.0f);
float width = height* camera->getAspectRatio();
width = height = 1.0f;
n1.x = projectorPosition.x + dir.x + 0.5f*width*right.x + 0.5f*height*upVector.x;
n1.y = projectorPosition.y + dir.y + 0.5f*width*right.y + 0.5f*height*upVector.y;
n1.z = projectorPosition.z + dir.z + 0.5f*width*right.z + 0.5f*height*upVector.z;
n2.x = projectorPosition.x + dir.x + 0.5f*width*right.x - 0.5f*height*upVector.x;
n2.y = projectorPosition.y + dir.y + 0.5f*width*right.y - 0.5f*height*upVector.y;
n2.z = projectorPosition.z + dir.z + 0.5f*width*right.z - 0.5f*height*upVector.z;
n3.x = projectorPosition.x + dir.x - 0.5f*width*right.x + 0.5f*height*upVector.x;
n3.y = projectorPosition.y + dir.y - 0.5f*width*right.y + 0.5f*height*upVector.y;
n3.z = projectorPosition.z + dir.z - 0.5f*width*right.z + 0.5f*height*upVector.z;
n4.x = projectorPosition.x + dir.x - 0.5f*width*right.x - 0.5f*height*upVector.x;
n4.y = projectorPosition.y + dir.y - 0.5f*width*right.y - 0.5f*height*upVector.y;
n4.z = projectorPosition.z + dir.z - 0.5f*width*right.z - 0.5f*height*upVector.z;
}
void ModelNode::geometryPass(SceneManager* manager) {
if (mesh != NULL) {
CameraNode* camera = manager->getCameraNode();
ShaderProgram* shaderProgram = manager->getGeometryProgram();
glm::mat4 mv = camera->getView() * getTransform().getTransformation();
//glm::mat3 normalMatrix = glm::inverseTranspose(glm::mat3(getTransform().getTransformation()));
glm::mat4 mvp = camera->getProjection() * mv;
shaderProgram->setUniformMatrix4fv("mvp", 1, false, glm::value_ptr(mvp));
//shaderProgram->setUniformMatrix3fv("normalMatrix", 1, false, glm::value_ptr(normalMatrix));
mesh->draw(shaderProgram);
}
}
//----------------------------------------------------------------------------
void UI::OnEvent(Event *ent)
{
if (GraphicsES::IsEqual(ent, GraphicsES::AddObject))
{
AddObjectData data = ent->GetData<AddObjectData>();
CameraNode *camNode = DynamicCast<CameraNode>(data.Obj);
if (camNode)
{
UI *ui = camNode->GetFirstParentDerivedFromType<UI>();
if (ui)
{
ui->AddCamera(camNode->GetCamera());
}
}
}
}
bool CameraNode::sEqual(const RepoNode &other) const
{
if (other.getTypeAsEnum() != NodeType::CAMERA || other.getParentIDs().size() != getParentIDs().size())
{
return false;
}
const CameraNode otherCam = CameraNode(other);
std::vector<float> mat = getCameraMatrix();
std::vector<float> otherMat = otherCam.getCameraMatrix();
return !memcmp(mat.data(), otherMat.data(), mat.size() *sizeof(*mat.data()));
}
//----------------------------------------------------------------------------
void EU_CanvasStage::_UpdateCameraCanvas()
{
int numObjscts = PX2_SELECTM_E->GetNumObjects();
if (1 == numObjscts)
{
Object *firstSelObj = PX2_SELECTM_E->GetFirstObject();
CameraNode *camNode = DynamicCast<CameraNode>(firstSelObj);
if (camNode)
{
if (mCameraCanvasView)
{
Scene *scene = PX2_PROJ.GetScene();
mCameraCanvasView->SetOverCamera(camNode->GetCamera());
mCameraCanvasView->SetRenderNode(scene);
mCameraCanvasView->Show(true);
}
}
else
{
if (mCameraCanvasView)
{
mCameraCanvasView->SetOverCamera(0);
mCameraCanvasView->SetRenderNode(0);
mCameraCanvasView->Show(false);
}
}
}
else
{
if (mCameraCanvasView)
{
mCameraCanvasView->SetOverCamera(0);
mCameraCanvasView->SetRenderNode(0);
mCameraCanvasView->Show(false);
}
}
}
void GroupNode::CopyAsChildren(Scene* scene, GroupNode* root) {
const std::vector<SceneNode*>& tocopy_children = root->Children();
std::deque<SceneNode*>
to_process(tocopy_children.begin(), tocopy_children.end());
SetTranslation(root->Translation());
SetRotation(root->Rotation());
SetScale(root->Scale());
SetVisible(root->Visible());
while (!to_process.empty()) {
SceneNode* to_copy = to_process.front();
to_process.pop_front();
SceneNode* node_copy = nullptr;
switch (to_copy->NodeType()) {
case SceneNodeType::kGroupNode:
{
GroupNode* child = scene->MakeGroup(this, Scene::kAutoName);
GroupNode* group_to_copy =
dynamic_cast<GroupNode*>(to_copy);
child->CopyAsChildren(scene, group_to_copy);
node_copy = child;
}
break;
case SceneNodeType::kCameraNode:
{
CameraNode* child = scene->MakeCamera(this, Scene::kAutoName);
const CameraNode* camera_to_copy =
dynamic_cast<const CameraNode*>(to_copy);
child->CopyFrom(*camera_to_copy);
node_copy = child;
}
break;
case SceneNodeType::kLightNode:
{
LightNode* child = scene->MakeLight(this, Scene::kAutoName);
const LightNode* light_to_copy =
dynamic_cast<const LightNode*>(to_copy);
// *child = *light_to_copy;
(void)light_to_copy;
node_copy = child;
}
break;
case SceneNodeType::kDrawNode:
{
DrawNode* node_to_copy =
dynamic_cast<DrawNode*>(to_copy);
DrawNode* child = scene->MakeDrawNode(this, Scene::kAutoName);
for (const Drawable::Ptr& item : node_to_copy->Drawables()) {
child->Add(item);
}
node_copy = child;
}
break;
}
node_copy->SetTranslation(to_copy->Translation());
node_copy->SetRotation(to_copy->Rotation());
node_copy->SetScale(to_copy->Scale());
node_copy->SetVisible(to_copy->Visible());
}
}
int test_large_scene(Util::UI::Window * window, Util::UI::EventContext & eventContext) {
// texture registry
std::map<std::string, Util::Reference<Rendering::Texture> > textures;
std::cout << "Create FrameContext...\n";
FrameContext fc;
unsigned int renderingFlags = /*BOUNDING_BOXES|SHOW_META_OBJECTS|*/FRUSTUM_CULLING/*|SHOW_COORD_SYSTEM*/;//|SHOW_COORD_SYSTEM;
std::cout << "Create scene graph...\n";
Util::Reference<GroupNode> root = new MinSG::ListNode();
/// Skybox
SkyboxState * sb = SkyboxState::createSkybox("Data/texture/?.bmp");
root->addState(sb);
/// Some shperes...
{
std::default_random_engine engine;
std::uniform_real_distribution<float> coordinateDist(0.0f, 200.0f);
std::vector<Util::Reference<Rendering::Mesh> > spheres;
Util::Reference<Rendering::Mesh> icosahedron = Rendering::MeshUtils::PlatonicSolids::createIcosahedron();
for(int i=0;i<6;++i)
spheres.push_back(Rendering::MeshUtils::PlatonicSolids::createEdgeSubdivisionSphere(icosahedron.get(), i)); // 6... 81920 triangles each
for (int i = 0; i < 1000; i++) {
// create a real clone inclusive internal data!
MinSG::GeometryNode * gn = new GeometryNode(spheres[std::uniform_int_distribution<std::size_t>(0, spheres.size() - 1)(engine)]->clone());
gn->moveRel(Geometry::Vec3(coordinateDist(engine), coordinateDist(engine), coordinateDist(engine)));
root->addChild(gn);
gn->scale(0.1 + std::uniform_real_distribution<float>(0.0f, 1000.0f)(engine) / 400.0);
}
}
/// Camera
Node * schwein = loadModel(Util::FileName("Data/model/Schwein.low.t.ply"), MESH_AUTO_CENTER | MESH_AUTO_SCALE);
ListNode * camera = new ListNode();
CameraNode * camNode = new CameraNode();
camNode->setViewport(Geometry::Rect_i(0, 0, 1024, 768));
camNode->setNearFar(0.1, 2000);
camNode->applyVerticalAngle(80);
camNode->moveRel(Geometry::Vec3(0, 4, 10));
camera->addChild(camNode);
camera->addChild(schwein);
schwein->moveRel(Geometry::Vec3(0, 0, 0));
schwein->rotateLocal_deg(180, Geometry::Vec3(0, 1, 0));
LightNode * myHeadLight = LightNode::createPointLight();
myHeadLight->scale(1);
myHeadLight->moveRel(Geometry::Vec3(0, 0, 0));
camera->addChild(myHeadLight);
LightingState * lightState = new LightingState;
lightState->setLight(myHeadLight);
root->addState(lightState);
root->addChild(camera);
/// Eventhandler
MoveNodeHandler * eh = new MoveNodeHandler();
MoveNodeHandler::initClaudius(eh, camera);
// ---------------------------------------------------------------------------------------------
Rendering::RenderingContext::clearScreen(Util::Color4f(0.5f, 0.5f, 0.5f, 0.5f));
// ----
GET_GL_ERROR();
uint32_t fpsFrameCounter = 0;
Util::Timer fpsTimer;
std::cout << "\nEntering main loop...\n";
// program main loop
bool done = false;
while (!done) {
++fpsFrameCounter;
double seconds = fpsTimer.getSeconds();
if (seconds > 1.0) {
double fps = static_cast<double> (fpsFrameCounter) / seconds;
std::cout << "\r " << fps << " fps ";
std::cout.flush();
fpsTimer.reset();
fpsFrameCounter = 0;
}
// message processing loop
eventContext.getEventQueue().process();
while (eventContext.getEventQueue().getNumEventsAvailable() > 0) {
Util::UI::Event event = eventContext.getEventQueue().popEvent();
// check for messages
switch (event.type) {
// exit if the window is closed
case Util::UI::EVENT_QUIT:
done = true;
break;
// check for keypresses
case Util::UI::EVENT_KEYBOARD: {
if(event.keyboard.pressed && event.keyboard.key == Util::UI::KEY_ESCAPE) {
done = true;
}
break;
}
} // end switch
} // end of message processing
// apply translation
eh->execute();
// clear screen
Rendering::RenderingContext::clearScreen(Util::Color4f(0.0f, 0.0f, 0.0f, 1.0f));
// enable Camera
fc.setCamera(camNode);
// render Scene
root->display(fc, renderingFlags);
window->swapBuffers();
GET_GL_ERROR();
} // end main loop
// destroy scene graph
MinSG::destroy(root.get());
root = nullptr;
// all is well ;)
std::cout << "Exited cleanly\n";
//system("pause");
return EXIT_SUCCESS;
}
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();
}
TEST(RepoBSONFactoryTest, MakeCameraNodeTest)
{
float aspectRatio = 1.0;
float fCP = 10;
float nCP = 100;
float fov = 500;
repo_vector_t lookAt = { 1.0, 2.0, 3.0 };
repo_vector_t position = { 3.1, 2.2, 3.5 };
repo_vector_t up = { 4.1, 12.2, 23.5 };
std::string name = "CamTest";
CameraNode camera = RepoBSONFactory::makeCameraNode(aspectRatio, fCP, nCP, fov, lookAt, position, up, name);
EXPECT_FALSE(camera.isEmpty());
EXPECT_EQ(aspectRatio, camera.getAspectRatio());
EXPECT_EQ(fCP, camera.getFarClippingPlane());
EXPECT_EQ(nCP, camera.getNearClippingPlane());
EXPECT_EQ(fov, camera.getFieldOfView());
EXPECT_TRUE(compareVectors(lookAt, camera.getLookAt()));
EXPECT_TRUE(compareVectors(position, camera.getPosition()));
EXPECT_TRUE(compareVectors(up, camera.getUp()));
EXPECT_EQ(name, camera.getName());
EXPECT_EQ(camera.getTypeAsEnum(), NodeType::CAMERA);
}
