void OpenGLScene::render(SupportCanvas3D *context) { // Clear the screen in preparation for the next frame. (Use a gray background instead of a // black one for drawing wireframe or normals so they will show up against the background.) if (settings.drawWireframe || settings.drawNormals) glClearColor(0.5f, 0.5f, 0.5f, 0.5f); else glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Get the active camera Camera *camera = context->getCamera(); assert(camera); glm::mat4 viewMatrix = camera->getViewMatrix(); glUseProgram(m_shader); // Set scene uniforms. clearLights(); setLights(viewMatrix); glUniform1i(m_uniformLocs["useLighting"], settings.useLighting); glUniform1i(m_uniformLocs["useArrowOffsets"], GL_FALSE); glUniformMatrix4fv(m_uniformLocs["p"], 1, GL_FALSE, glm::value_ptr(camera->getProjectionMatrix())); glUniformMatrix4fv(m_uniformLocs["v"], 1, GL_FALSE, glm::value_ptr(viewMatrix)); glUniformMatrix4fv(m_uniformLocs["m"], 1, GL_FALSE, glm::value_ptr(glm::mat4())); glUniform3f(m_uniformLocs["allBlack"], 1, 1, 1); renderGeometry(); if (settings.drawWireframe) { glUniform3f(m_uniformLocs["allBlack"], 0, 0, 0); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); renderGeometry(); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } // Render normals if specified. if (settings.drawNormals) { glUseProgram(m_shader); glUniform3f(m_uniformLocs["allBlack"], 0, 0, 0); this->renderNormals(); } glUseProgram(0); }
void SliceExtractor::renderImageImpl(DataContainer& dataContainer, const ImageRepresentationGL::ScopedRepresentation& img) { // prepare OpenGL _shader->activate(); cgt::TextureUnit inputUnit, tfUnit; img->bind(_shader, inputUnit); p_transferFunction.getTF()->bind(_shader, tfUnit); cgt::mat4 identity = cgt::mat4::identity; _shader->setUniform("_texCoordsMatrix", _texCoordMatrix); _shader->setUniform("_modelMatrix", identity); _shader->setUniform("_viewMatrix", _viewMatrix); _shader->setUniform("_projectionMatrix", identity); _shader->setUniform("_useTexturing", true); _shader->setUniform("_useSolidColor", true); // render slice FramebufferActivationGuard f*g(this); createAndAttachColorTexture(); createAndAttachDepthTexture(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); QuadRdr.renderQuad(); if (p_renderCrosshair.getValue()) renderCrosshair(img); renderGeometry(dataContainer, img); _shader->deactivate(); cgt::TextureUnit::setZeroUnit(); dataContainer.addData(p_targetImageID.getValue(), new RenderData(_fbo)); }
void ModelNode::render(RenderPass pass) { // Apply the node's transformation glTranslatef(_position[0], _position[1], _position[2]); glRotatef(_orientation[3], _orientation[0], _orientation[1], _orientation[2]); glRotatef(_rotation[0], 1.0, 0.0, 0.0); glRotatef(_rotation[1], 0.0, 1.0, 0.0); glRotatef(_rotation[2], 0.0, 0.0, 1.0); // Render the node's geometry bool shouldRender = _render && (_indexBuffer.getCount() > 0); if (((pass == kRenderPassOpaque) && _isTransparent) || ((pass == kRenderPassTransparent) && !_isTransparent)) shouldRender = false; if (shouldRender) renderGeometry(); // Render the node's children for (std::list<ModelNode *>::iterator c = _children.begin(); c != _children.end(); ++c) { glPushMatrix(); (*c)->render(pass); glPopMatrix(); } }
Action::ResultE CPUSkinningAlgorithm::renderEnter(Action *action) { Action::ResultE res = Action::Continue; SkinnedGeometry *skinGeo = getSkin (); Skeleton *skel = getSkeleton(); RenderAction *ract = boost::polymorphic_downcast<RenderAction *>(action); OSG_ASSERT(skinGeo != NULL); OSG_ASSERT(skel != NULL); CPUSkinningDataAttachmentUnrecPtr data = getCPUSkinningData(skinGeo); if(data == NULL) { data = CPUSkinningDataAttachment::create(); skinGeo->addAttachment(data); } skel->renderEnter(action, skinGeo); if(data->getDataValid() == false) { transformGeometry(skinGeo, skel, data); data->setDataValid(true); } renderGeometry(ract, skinGeo, data); return res; }
void kit::BakedTerrain::renderShadows(glm::mat4 const & viewMatrix, glm::mat4 const & projectionMatrix) { glDisable(GL_CULL_FACE); auto program = kit::Model::getShadowProgram(false, false, false); program->setUniformMat4("uniform_mvpMatrix", projectionMatrix * viewMatrix * getWorldTransformMatrix()); program->use(); renderGeometry(); }
void SFRenderer::renderGeometry(SFGeometry* geometry,int lod) { // geometry is drawn geometry->drawGeometry(lod); // sons geometry are drawn for (int i=0; i < geometry->getSonsCount(); i++) { renderGeometry(geometry->getSon(i),lod); } }
void RenderColorCube::Process(tgt::Geometry *geometry, tgt::Camera *camera) { // set modelview and projection matrices MatStack.matrixMode(tgt::MatrixStack::PROJECTION); MatStack.pushMatrix(); MatStack.loadMatrix(camera->getProjectionMatrix(frontTarget_->getSize())); MatStack.matrixMode(tgt::MatrixStack::MODELVIEW); MatStack.pushMatrix(); MatStack.loadMatrix(camera->getViewMatrix()); glEnable(GL_DEPTH_TEST); // render front texture if (frontTarget_) { // simple implement //glEnable(GL_DEPTH_CLAMP); //renderGeometry(geometry, camera, frontTarget_, GL_LESS, 1.0f, GL_BACK); //glDisable(GL_DEPTH_CLAMP); // improved method for situation when camera inside volume. renderGeometry(geometry, camera, tmpTarget_, GL_LESS, 1.0f, GL_BACK); // render first front face renderGeometry(geometry, camera, backTarget_, GL_LESS, 1.0f, GL_FRONT); // render first back face fillEntryPoints(backTarget_, tmpTarget_, frontTarget_, geometry, camera); } // render back texture if (backTarget_) { renderGeometry(geometry, camera, backTarget_, GL_GREATER, 0.0f, GL_FRONT); } // restore OpenGL state MatStack.matrixMode(tgt::MatrixStack::PROJECTION); MatStack.popMatrix(); MatStack.matrixMode(tgt::MatrixStack::MODELVIEW); MatStack.popMatrix(); tgt::TextureUnit::setZeroUnit(); LGL_ERROR; }
void SFRenderer::renderNodeContent(SFNode* node,int lod) { SFModel* model=node->getModel(); if(model!=0){ setupRenderingData(model); node->getTransform()->apply(); SFGeometry* rootGeometry=node->getModel()->getRootGeometry(); renderGeometry(rootGeometry,lod); } }
void WaitingForYou::renderImp() { // _modules->getRenderEngine()->getRenderSystem()->clear(0, NULL, Euclid::eClearFlags_Target | Euclid::eClearFlags_ZBuffer, Euclid::Color::Black, 1.0f, 0L); _modules->getRenderEngine()->getRenderSystem()->beginScene(); // renderGeometry(); // _modules->getRenderEngine()->getRenderSystem()->endScene(); }
void RocketRenderingInterface::RenderCompiledGeometry(CompiledGeometryHandle geometry, const Vector2f& translation) { GR_DEBUG_SCOPE("libRocket::RenderCompiledGeometry"); auto geom = reinterpret_cast<CompiledGeometry*>(geometry); auto bitmap = -1; if (geom->texture != nullptr) { bitmap = geom->texture->handle + geom->texture->frame_num; } renderGeometry(geom->vertex_buffer, geom->index_buffer, geom->num_elements, bitmap, translation); }
void RocketRenderingInterface::RenderGeometry(Vertex* vertices, int num_vertices, int* indices, int num_indices, TextureHandle texture, const Vector2f& translation) { gr_update_buffer_data(vertex_stream_buffer, sizeof(*vertices) * num_vertices, vertices); gr_update_buffer_data(index_stream_buffer, sizeof(*indices) * num_indices, indices); int bitmap; if (texture == 0) { bitmap = -1; } else { bitmap = get_texture(texture)->handle + get_texture(texture)->frame_num; } renderGeometry(vertex_stream_buffer, index_stream_buffer, num_indices, bitmap, translation); }
bool WaitingForYou::rendering() { // _modules->getRenderEngine()->getRenderSystem()->clear(0, NULL, Euclid::eClearFlags_Target | Euclid::eClearFlags_ZBuffer, Euclid::Color::Green, 1.0f, 0L); _modules->getRenderEngine()->getRenderSystem()->beginScene(); // renderGeometry(); // _modules->getRenderEngine()->getRenderSystem()->endScene(); _modules->getRenderEngine()->getRenderSystem()->present(NULL, NULL, NULL); // return true; }
int TestApplication::run() { if (!initialize()) return -1; PhysicsSimulation simulation(Vector2f(0.0f, 10.0f), 10); createGeometry(); for (std::vector<CircleBody*>::const_iterator i = _circleBodies.begin(); i != _circleBodies.end(); ++i) simulation.addBody(*i); for (std::vector<PolygonBody*>::const_iterator i = _polygonBodies.begin(); i != _polygonBodies.end(); ++i) simulation.addBody(*i); Timer _timer(1000.0f / 60); //60 updates per second _timer.start(); while (_window.isOpen()) { handleInput(); if (_mouseForce.x < -100.0f) _mouseForce.x = -100.0f; else if (_mouseForce.x > 100.0f) _mouseForce.x = 100.0f; if (_mouseForce.y < -100.0f) _mouseForce.y = -100.0f; else if (_mouseForce.y > 100.0f) _mouseForce.y = 100.0f; _timer.update(); while (_timer.checkTimeStep()) simulation.update(_timer.timeStep() * 0.001f); _camera.update(); _window.clear(); checkMouseCollision(); renderGeometry(); } return 0; }
void ObjectRenderer::renderAtomic(Atomic* atomic, const glm::mat4& worldtransform, GameObject* object, RenderList& render) { RW_CHECK(atomic->getGeometry(), "Can't render an atomic without geometry"); RW_CHECK(atomic->getFrame(), "Can't render an atomic without a frame"); const auto& geometry = atomic->getGeometry(); const auto& frame = atomic->getFrame(); RW::BSGeometryBounds& bounds = geometry->geometryBounds; auto transform = worldtransform * frame->getWorldTransform(); glm::vec3 boundpos = bounds.center + glm::vec3(transform[3]); if (!m_camera.frustum.intersects(boundpos, bounds.radius)) { culled++; return; } renderGeometry(geometry.get(), transform, object, render); }
void kit::BakedTerrain::renderDeferred(kit::Renderer * renderer) { if(!m_valid) { return; } glm::mat4 modelViewMatrix = renderer->getActiveCamera()->getViewMatrix() * getWorldTransformMatrix(); glm::mat4 modelViewProjectionMatrix = renderer->getActiveCamera()->getProjectionMatrix() * renderer->getActiveCamera()->getViewMatrix() * getWorldTransformMatrix(); glDisable(GL_BLEND); glDisable(GL_CULL_FACE); //glCullFace(GL_BACK); m_program->setUniformMat4("uniform_mvMatrix", modelViewMatrix); m_program->setUniformMat4("uniform_mvpMatrix", modelViewProjectionMatrix); m_program->use(); renderGeometry(); }
bool GameRenderer::renderFrame(Model* m, ModelFrame* f, const glm::mat4& matrix, GameObject* object, float opacity, bool queueTransparent) { auto localmatrix = matrix; bool vis = true; if(object && object->skeleton) { // Skeleton is loaded with the correct matrix via Animator. localmatrix *= object->skeleton->getMatrix(f); vis = object->skeleton->getData(f->getIndex()).enabled; } else { localmatrix *= f->getTransform(); } if( vis ) { for(size_t g : f->getGeometries()) { if( !object || !object->animator ) { RW::BSGeometryBounds& bounds = m->geometries[g]->geometryBounds; glm::vec3 boundpos = bounds.center + glm::vec3(localmatrix[3]); if(! _camera.frustum.intersects(boundpos, bounds.radius)) { culled++; continue; } } renderGeometry(m, g, localmatrix, opacity, object); } } for(ModelFrame* c : f->getChildren()) { renderFrame(m, c, localmatrix, object, queueTransparent); } return true; }
void CGlutWindow::renderFrame() { if (stereoSwitch != isStereo) { int w = glutGet( GLUT_WINDOW_WIDTH ); int h = glutGet( GLUT_WINDOW_HEIGHT ); resize(w,h); } stereoSwitch = isStereo; double dAspectRatio = double(m_nWidth)/double(m_nHeight); // The usual OpenGL stuff to clear the screen and set up viewing. glClearColor(.5, .5, 1., 1.); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); GLfloat fTop, fRight, fNear, fFar; fNear = float(m_dCenter - m_dRadius); fFar = float(m_dCenter + m_dRadius); if (dAspectRatio > 1.0) { fRight = fNear * float(tan(DEG2RAD(m_dFieldOfView)/2.0) /m_dZoom); fTop = fRight * float(dAspectRatio); } else { fTop = fNear * float(tan(DEG2RAD(m_dFieldOfView)/2.0) /m_dZoom); fRight = fTop / float(dAspectRatio); } glViewport(0,0,m_nWidth,m_nHeight); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum( -fTop, fTop, -fRight, fRight, fNear, 10*fFar); CMatrix matModel = m_pCameraArcball->getRotatonMatrix().getInverse(); double matrix[16]; matModel.get(matrix[ 0], matrix[ 4], matrix[ 8], matrix[12], matrix[ 1], matrix[ 5], matrix[ 9], matrix[13], matrix[ 2], matrix[ 6], matrix[10], matrix[14], matrix[ 3], matrix[ 7], matrix[11], matrix[15]); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glClear(GL_COLOR_BUFFER_BIT); //Set up window for stereo or non-stereo viewing for( int i=0; i <= (isStereo ? 1 : 0); ++i ) { if ( isStereo ) glViewport( i*(camera->getViewportWidthInPixels()), 0, camera->getViewportWidthInPixels(), camera->getViewportHeightInPixels()); if (i == 0) camera->transform((isStereo ? CAMERA_LEFT : CAMERA_MONO), stereoDistance); else camera->transform(CAMERA_RIGHT, stereoDistance); glTranslated(m_dTranslateX * m_dRadius/(m_dZoom), m_dTranslateY*m_dRadius/(m_dZoom), 0); glMultMatrixd(matrix); renderGeometry(); } displayTF(); glutSwapBuffers(); }
void GameState::render(PlatformWindow *window, RenderContext *render_context, InputManager *input, Assets *assets, Platform *platform, f32 delta) { // for(u32 i = 0; i < assets->skel_dude.skeleton.num_joints; i++) { // const Joint &joint = assets->skel_dude.skeleton.joints[i]; // Vec3 position = Mat4::extractTranslation(joint.world_mat); // if(joint.parent_index > -1) { // const Joint &parent_joint = assets->skel_dude.skeleton.joints[joint.parent_index]; // Vec3 parent_position = Mat4::extractTranslation(parent_joint.world_mat) * Vec3(0.075f) + Vec3(10.0f, 0.0f, 0.0f); // DebugRenderQueue::addLine(parent_position, position * Vec3(0.075f) + Vec3(10.0f, 0.0f, 0.0f), Vec4(0.0f, 1.0f, 0.0f, 1.0f), 0.1f); // } // } if(input->isKeyDownOnce(Key::F5)) generateMap(); pn_prepass.bindForWriting(platform, render_context); pn_prepass.clear(render_context, Vec4(0.0f, 0.0f, 0.0f, 0.0f)); render_context->bindShaderConstant(&per_scene_constants, 0, 0); const float blend_factor[4] = { 0.f, 0.f, 0.f, 0.f }; // render_context->bindBlendState(&alpha_blend, blend_factor, 0xffffffff); render_context->bindRasterState(&raster_state); render_context->bindSampler(&texture_sampler, 0); render_context->bindSampler(&wrap_texture_sampler, 1); PerSceneConstants scene_constants = {}; scene_constants.projection = camera.getProjection(); scene_constants.view = camera.getView(); for(int i = 0; i < ArrayCount(lights); i++) { Light &light = lights[i]; scene_constants.lights[i] = light.calcShaderLight(); } scene_constants.camera_position = Vec4(camera.position, 1.0f); scene_constants.screen_size = Vec4(camera.window_dimensions.x, camera.window_dimensions.y, 0.0f, 0.0f); render_context->updateShaderConstant(&per_scene_constants, &scene_constants); render_context->bindDepthStencilState(&depth_state); render_context->bindShader(&assets->shaders.geometry); // position normal pre-pass // render_context->bindShader(&assets->shaders.geometry_pn); // renderGeometry(window, render_context, input, assets, platform, delta, false); // render_context->bindDepthStencilState(&no_depth_state); // render_context->bindRasterState(&no_depth_raster_state); // pn_prepass.bindForReading(render_context); // { // RenderTexture *rts[] = {&ao_render_texture}; // render_context->bindRenderTextures(platform, rts, 1, 0); // render_context->clearRenderTexture(&ao_render_texture, Vec4(1.0f).xyzw); // render_context->bindTexture2D(&pn_prepass.normal.texture, 0); // render_context->bindTexture2D(&pn_prepass.position.texture, 1); // render_context->bindTexture2D(&ssao_noise_texture, 2); // render_context->bindShader(&assets->shaders.ao_pass); // ssao_pass_constant_data.sceen_size = Vec2(camera.window_dimensions.x, camera.window_dimensions.y); // ssao_pass_constant_data.projection = camera.getProjection(); // render_context->updateShaderConstant(&ao_pass_constants, &ssao_pass_constant_data); // render_context->bindShaderConstant(&ao_pass_constants, 0, 0); // renderFullScreenQuad(render_context); // render_context->bindShader(&assets->shaders.blur); // render_context->updateShaderConstant(&blur_constants, &blur_constants_data); // rts[0] = &blur_render_texture; // render_context->bindRenderTextures(platform, rts, 1, 0); // render_context->bindTexture2D(&ao_render_texture.texture, 0); // render_context->bindShaderConstant(&blur_constants, 0, 0); // renderFullScreenQuad(render_context); // } render_context->bindShaderConstant(&per_scene_constants, 0, 0); RenderTexture *hdr_rts[] = {&hdr_color_render_texture}; render_context->bindRenderTextures(platform, hdr_rts, 1, 0, true); render_context->clearRenderTexture(&hdr_color_render_texture, Vec4(0.0f, 0.0f, 0.0f, 1.0f).xyzw); render_context->bindTexture2D(&assets->test, 0); render_context->bindTexture2D(&assets->irr_map, 1); render_context->bindTexture2D(&assets->env_map, 2); render_context->bindTexture2D(&blur_render_texture.texture, 3); render_context->bindShader(&assets->shaders.geometry); renderGeometry(window, render_context, input, assets, platform, delta, true); scene_constants.projection = camera.getViewProjection(false); render_context->updateShaderConstant(&per_scene_constants, &scene_constants); render_context->bindShader(&assets->shaders.skybox); render_context->bindTexture2D(&assets->env_map, 0); { Vec3 vertices[] = { /* 0 */ Vec3(-1.0f, 1.0f, -1.0f), // Top Front left /* 1 */ Vec3(1.0f, 1.0f, -1.0f), // Top Front right /* 2 */ Vec3(-1.0f, -1.0f, -1.0f), // bottom Front left /* 3 */ Vec3(1.0f, -1.0f, -1.0f), // bottom Front right /* 4 */ Vec3(-1.0f, 1.0f, 1.0f), // Top back left /* 5 */ Vec3(1.0f, 1.0f, 1.0f), // Top back right /* 6 */ Vec3(-1.0f, -1.0f, 1.0f), // bottom back left /* 7*/ Vec3(1.0f, -1.0f, 1.0f), // bottom back right }; u16 indices[] = { 0, 2, 1, 2, 3, 1, 1, 3, 5, 3, 7, 5, 5, 7, 4, 7, 6, 4, 4, 6, 0, 6, 2, 0, 4, 0, 5, 0, 1, 5, 2, 6, 3, 6, 7, 3, }; u32 vertex_count = ArrayCount(vertices); u32 index_count = ArrayCount(indices); VertexBuffer vb = render_context->createVertexBuffer(vertices, sizeof(Vec3), vertex_count); VertexBuffer ib = render_context->createVertexBuffer(indices, sizeof(u16), index_count, RenderContext::BufferType::Index); render_context->bindShaderLayout(&skybox_layout); render_context->bindVertexBuffer(&vb, 0); render_context->bindIndexBuffer(&ib, RenderContext::Format::u16); render_context->sendDrawIndexed(RenderContext::Topology::TriangleList, index_count, 0, 0); render_context->destroyVertexBuffer(&vb); render_context->destroyVertexBuffer(&ib); } render_context->bindDefaultTextures(true); render_context->bindDepthStencilState(&no_depth_state); render_context->bindTexture2D(&hdr_color_render_texture.texture, 0); // Final blit render_context->bindShader(&assets->shaders.hdr_blit); { hdr_blit_constants_data.exposure = 1.0f; render_context->updateShaderConstant(&hdr_blit_constants, &hdr_blit_constants_data); render_context->bindShaderConstant(&hdr_blit_constants, -1, 0); renderFullScreenQuad(render_context);; } render_context->bindDepthStencilState(&depth_state); collision_world->debugDrawWorld(); }