void DrawShader::drawTextureShader(bool isReflection, Shader& shader, const std::vector<Drawable>& drawables, const glm::mat4& viewMatrix, const glm::vec3& sunDir, float sunIntensity, int lightning, const FrameBufferObject& reflection_fbo) { shader.sendUniform(Uniform::PROJECTION, uniforms, gProjectionMatrix); shader.sendUniform(Uniform::VIEW, uniforms, viewMatrix); shader.sendUniform(Uniform::LIGHTNING, uniforms, lightning); SendSun(shader, uniforms, sunIntensity, sunDir); for (auto& drawable : drawables) { if (drawable.draw_template.shader_type == ShaderType::TEXTURE || drawable.draw_template.shader_type == ShaderType::DEFERRED) { { // Per-Drawable Texture Shader Setup //SendHeightMap(shader, drawable); SendBones(shader, drawable); SendTexture(shader, drawable); if (!isReflection && drawable.draw_template.effects.count(EffectType::IS_WATER)) { shader.sendUniform(Uniform::IS_WATER, uniforms, 1); shader.sendUniform(Uniform::REFLECTION_TEXTURE, uniforms, reflection_fbo.texture_slot()); reflection_fbo.texture().enable(texture_cache_); } else shader.sendUniform(Uniform::IS_WATER, uniforms, 0); drawable.draw_template.material.sendMaterial(shader, uniforms); } if (!drawable.draw_template.effects.count(EffectType::IS_WATER) || !isReflection) drawModelTransforms(shader, drawable, viewMatrix, true, uniforms); } } }
void DepthPeelingStage::postProcess(DrawEnv *pEnv, bool isPing) { Window *win = pEnv->getWindow(); if(win->hasExtOrVersion(_uiFramebufferObjectExt, 0x0300, 0x0200) == false) { FNOTICE(("Framebuffer objects not supported on Window %p!\n", win)); return; } DepthPeelingStageData *pData = pEnv->getData<DepthPeelingStageData *>(_iDataSlotId); if(!pData) return; FrameBufferObject *pBlendFBO = pData->getBlendFBO(); pBlendFBO->activate(pEnv); ChunkMaterial *pMaterial; if (isPing) pMaterial = pData->getPeelPingMaterial(); else pMaterial = pData->getPeelPongMaterial(); pEnv->activateState(pMaterial->getState(), NULL); drawQuad(); pEnv->deactivateState(); pBlendFBO->deactivate(pEnv); }
void FrameBufferObjectBase::onCreate(const FrameBufferObject *source) { Inherited::onCreate(source); if(source != NULL) { FrameBufferObject *pThis = static_cast<FrameBufferObject *>(this); MFUnrecFrameBufferAttachmentPtr::const_iterator ColorAttachmentsIt = source->_mfColorAttachments.begin(); MFUnrecFrameBufferAttachmentPtr::const_iterator ColorAttachmentsEnd = source->_mfColorAttachments.end (); while(ColorAttachmentsIt != ColorAttachmentsEnd) { pThis->pushToColorAttachments(*ColorAttachmentsIt); ++ColorAttachmentsIt; } pThis->setDepthAttachment(source->getDepthAttachment()); pThis->setStencilAttachment(source->getStencilAttachment()); } }
void ShaderShadowMapEngine::updatePointLightRenderTargets(SSMEngineData *data) { if(data->getMFRenderTargets()->empty() == true) { for(UInt16 i = 0; i < 6; ++i) { FrameBufferObjectUnrecPtr newTarget = FrameBufferObject::createLocal(); newTarget->setWidth (this->getWidth ( )); newTarget->setHeight (this->getHeight ( )); newTarget->setDepthAttachment(data->getShadowTexBuffers(i)); data->editMFRenderTargets()->push_back(newTarget); } } else { for(UInt16 i = 0; i < 6; ++i) { FrameBufferObject *target = data->getRenderTargets(i); if((target->getWidth () != this->getWidth ()) || (target->getHeight() != this->getHeight()) ) { target->setWidth (this->getWidth ()); target->setHeight(this->getHeight()); } } } }
void TextRenderer:: render_fps(RenderContext const& ctx, FrameBufferObject& target, float application_fps, float rendering_fps) const { target.bind(ctx); math::mat4 fs_projection = scm::math::make_ortho_matrix( 0.0f, static_cast<float>(target.width()), 0.0f, static_cast<float>(target.height()), -1.0f, 1.0f); text_renderer_->projection_matrix(fs_projection); frame_counter_text_->text_string("Application FPS: " + string_utils::to_string(application_fps) + "\nRendering FPS: " + string_utils::to_string(rendering_fps)); math::vec2i text_ur = math::vec2i(40, target.height() - frame_counter_text_->text_bounding_box().y + 10); text_renderer_->draw_outlined( ctx.render_context, text_ur, frame_counter_text_); target.unbind(ctx); }
int FrameBufferObjectsRepository::releaseFbo(IFrameBufferObject* p) { FrameBufferObject* pp = static_cast<FrameBufferObject*>(p); FboMap::iterator iR = m_FBOs.begin(); while(iR != m_FBOs.end()) { if(iR->second.p == pp) { iR->second.refCnt--; if(iR->second.refCnt == 0) { LOGD("Delete FBO %s and remove it from repository\n", pp->getName()); pp->invalidate(); delete pp; m_FBOs.erase(iR); return 0; } else { LOGD("Released FBO %s to refCnt=%d\n", pp->getName(), iR->second.refCnt); return iR->second.refCnt; } } ++iR; } return -1; }
void DrawShader::SendShadow(Shader& shader, const UniformLocationMap& uniforms, const FrameBufferObject& shadow_map_fbo_, const glm::vec3& deerPos, const glm::vec3& sunDir) { shadow_map_fbo_.texture().enable(texture_cache_); shader.sendUniform(Uniform::HAS_SHADOWS, uniforms, 1); shader.sendUniform(Uniform::SHADOW_MAP_TEXTURE, uniforms, shadow_map_fbo_.texture_slot()); SendInverseShadow(shader, uniforms, sunDir, deerPos); }
//----------------------------------------------------------------------------- void Widget3d::pushFrameBuffer(const FrameBufferObject& iF /*=FrameBufferObject()*/) { mFrameBuffers.push_back(iF); GLint frameBufferId = 0; if(iF.isValid()) frameBufferId = iF.getFrameBufferId(); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, frameBufferId); }
void ObjectManager::deleteEqFrameBufferObject( const void* key ) { FBOHash::iterator i = _impl->eqFrameBufferObjects.find(key); if( i == _impl->eqFrameBufferObjects.end( )) return; FrameBufferObject* frameBufferObject = i->second; _impl->eqFrameBufferObjects.erase( i ); frameBufferObject->exit(); delete frameBufferObject; }
void FrameBufferObjectBase::execSyncV( FieldContainer &oFrom, ConstFieldMaskArg whichField, AspectOffsetStore &oOffsets, ConstFieldMaskArg syncMode, const UInt32 uiSyncInfo) { FrameBufferObject *pThis = static_cast<FrameBufferObject *>(this); pThis->execSync(static_cast<FrameBufferObject *>(&oFrom), whichField, oOffsets, syncMode, uiSyncInfo); }
//Deletes all of the created objects here. void CloseFunc(){ window.window_handle = -1; cylinder.TakeDown();torus.TakeDown();square.TakeDown();square2.TakeDown(); disc.TakeDown();sphere.TakeDown();sphere2.TakeDown();tiger.TakeDown();goldeen.TakeDown(); stadium.TakeDown();coin.TakeDown();ss.TakeDown();healthBar.TakeDown(); shark.TakeDown();bird.TakeDown();sb.TakeDown();arena.TakeDown();skyboxUW.TakeDown();fbo.TakeDown();rain2.TakeDown(); tri2.TakeDown();skybox.TakeDown();skybox2.TakeDown();skybox3.TakeDown();egg.TakeDown();snow2.TakeDown(); star.TakeDown();magneton.TakeDown();haunter.TakeDown();frog.TakeDown(); sph1.TakeDown(); enm.TakeDown(); usr.TakeDown();sq4.TakeDown();soldier.TakeDown();userTeam.TakeDown();cpuTeam.TakeDown(); }
void DisplayFilterStage::resizeStageData(DisplayFilterStageData *pData, Int32 iPixelWidth, Int32 iPixelHeight) { FrameBufferObject *pFBO = pData->getTarget(); if(pFBO == NULL) return; TextureBuffer *pTexBuffer = dynamic_cast<TextureBuffer *>(pFBO->getColorAttachments(0)); if(pTexBuffer == NULL) return; TextureObjChunk *pTex = pTexBuffer->getTexture(); if(pTex == NULL) return; Image *pImg = pTex->getImage(); if(pImg == NULL) return; pImg->set(Image::OSG_RGB_PF, iPixelWidth, iPixelHeight, 1, 1, 1, 0.0, 0, Image::OSG_UINT8_IMAGEDATA, false); pFBO->setSize(iPixelWidth, iPixelHeight); pData->setWidth (iPixelWidth ); pData->setHeight(iPixelHeight); commitChanges(); }
void DrawShader::drawModelTransforms( Shader& shader, const Drawable& drawable, const glm::mat4& view, const FrameBufferObject& deferred_diffuse_fbo, const FrameBufferObject& deferred_position_fbo, const FrameBufferObject& deferred_normal_fbo, bool needsModel, const UniformLocationMap& uniforms) { for(const auto& instance : drawable.draw_instances) { if (instance.material) { instance.material->sendMaterial(shader, uniforms); } const auto model_view = view * instance.model_transform; shader.sendUniform(Uniform::MODEL_VIEW_PROJECTION, uniforms, gProjectionMatrix * model_view); SendModelAndNormal(shader, uniforms, model_view, instance.model_transform, needsModel); for (int i = 0; i < LAST_DEFERRED; ++i) { const auto deferred_type(static_cast<DeferredType>(i)); switch (deferred_type) { case DEFERRED_DIFFUSE: deferred_diffuse_fbo.bind(); break; case DEFERRED_POSITION: deferred_position_fbo.bind(); break; case DEFERRED_NORMAL: deferred_normal_fbo.bind(); break; default: break; } shader.sendUniform(Uniform::OUTPUT_SHADER_TYPE, uniforms, i); shader.drawMesh(drawable.draw_template.mesh); } } }
int main(int argc, char * argv[]) { window.timer_period = 1000 / 60; glutInit(&argc , argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowPosition(0 , 0); glutInitWindowSize(512 , 512); if ((window.window_handle = glutCreateWindow("Frame Buffer Demo")) < 1) { cerr << "Window creation failed." << endl; return 0; } if (glewInit() != GLEW_OK) { cerr << "Glew failed to initialize." << endl; return 0; } if (!fbo.Initialize(glm::ivec2(512, 512), 2, true)) { cerr << "Frame buffer failed to initialize." << endl; return 0; } glutDisplayFunc(DisplayFunc); glutReshapeFunc(ReshapeFunc); glutKeyboardFunc(KeyboardFunc); glutTimerFunc(window.timer_period, TimerFunc, 0); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); glutCloseFunc(CloseFunc); glutMainLoop(); return 0; }
void HDRStage::resizeStageData(HDRStageData *pData, Int32 iPixelWidth, Int32 iPixelHeight) { FrameBufferObject *pSceneFBO = this->getRenderTarget(); pSceneFBO->resizeAll(iPixelWidth, iPixelHeight); FrameBufferObject *pShrinkFBO = pData->getShrinkRenderTarget(); pShrinkFBO->resizeAll(iPixelWidth / 2, iPixelHeight / 2); FrameBufferObject *pBlurFBO = pData->getBlurRenderTarget(); pBlurFBO->resizeAll(iPixelWidth / 4, iPixelHeight / 4); SimpleSHLChunk *pHBlurShader = pData->getHBlurShader(); std::string szNewFragProg = generate1DConvolutionFilterFPString(getBlurWidth(), false, true, iPixelWidth / 2, iPixelHeight / 2); pHBlurShader->setFragmentProgram(szNewFragProg); szNewFragProg = generate1DConvolutionFilterFPString(getBlurWidth(), true, true, iPixelWidth / 2, iPixelHeight / 2); SimpleSHLChunkUnrecPtr pVBlurShader = pData->getVBlurShader(); pVBlurShader->setFragmentProgram(szNewFragProg); commitChanges(); }
void DepthPeelingStage::resizeStageData(DepthPeelingStageData *pData, Int32 iPixelWidth, Int32 iPixelHeight) { FrameBufferObject *pSceneFBO = pData->getBlendFBO(); pSceneFBO->resizeAll(iPixelWidth, iPixelHeight); FrameBufferObject *pPeelPingFBO = pData->getPeelPingFBO(); pPeelPingFBO->resizeAll(iPixelWidth, iPixelHeight); FrameBufferObject *pPeelPongFBO = pData->getPeelPongFBO(); pPeelPongFBO->resizeAll(iPixelWidth, iPixelHeight); commitChanges(); }
static void AttachCubeSide(int i, FrameBufferObject & reflection_fbo, std::ostream & error_output) { switch (i) { case 0: reflection_fbo.SetCubeSide(FrameBufferTexture::POSX); break; case 1: reflection_fbo.SetCubeSide(FrameBufferTexture::NEGX); break; case 2: reflection_fbo.SetCubeSide(FrameBufferTexture::POSY); break; case 3: reflection_fbo.SetCubeSide(FrameBufferTexture::NEGY); break; case 4: reflection_fbo.SetCubeSide(FrameBufferTexture::POSZ); break; case 5: reflection_fbo.SetCubeSide(FrameBufferTexture::NEGZ); break; default: error_output << "Reached odd spot while attaching cubemap side. How many sides are in a cube, anyway? " << i << "?" << std::endl; assert(0); break; }; CheckForOpenGLErrors("cubemap generation: FBO cube side attachment", error_output); }
int main(int argc, char * argv[]) { glutInit(&argc , argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(0 , 0); glutInitWindowSize(window_width, window_height); glutCreateWindow("Warp"); glutDisplayFunc(DisplayFunc); glutTimerFunc(1000 / 60, TimerFunc, 1000 / 60); glutReshapeFunc(ReshapeFunc); glutSpecialFunc(SpecialFunc); glutKeyboardFunc(KeyboardFunc); glutMouseFunc(MouseFunc); glutMotionFunc(MotionFunc); glutCloseFunc(CloseFunc); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); glEnable(GL_DEPTH_TEST); ilInit(); iluInit(); ilutInit(); ilutRenderer(ILUT_OPENGL); if (glewInit() != GLEW_OK) { cerr << "GLEW failed to initialize." << endl; return 0; } if (!shader.Initialize("stub.vert", "stub.frag")) { return 0; } if (!background.Initialize("back.vert", "back.frag")) { return 0; } image_1_handle = ilutGLLoadImage("lotr-scene.jpg"); image_1_w = ilGetInteger(IL_IMAGE_WIDTH); image_1_h = ilGetInteger(IL_IMAGE_HEIGHT); tex_handle = ilutGLLoadImage("Home-Theater.jpg"); tex_w = ilGetInteger(IL_IMAGE_WIDTH); tex_h = ilGetInteger(IL_IMAGE_HEIGHT); left_overlay_handle = ilutGLLoadImage("left-over.jpg"); right_overlay_handle = ilutGLLoadImage("right-over.jpg"); left_curtain_handle = ilutGLLoadImage("left-curtain.jpg"); cout << "Image 1: " << image_1_w << " x " << image_1_h << endl; cout << "Background: " << tex_w << " x " << tex_h << endl; if (!frame.Initialize(glm::ivec2(image_1_w, image_1_h), 1, true)) { cerr << "Frame buffer 1 failed to initialize." << endl; return 0; } cout << "Window Size: " << window_width << " x " << window_height << endl; cout << "Frame buffer 1 size: " << frame.size.x << " x " << frame.size.y << endl; glutMainLoop(); return 0; }
FrameBufferObject::Binder::Binder( const FrameBufferObject& fbo ) : m_fbo( fbo ) { KVS_ASSERT( fbo.isCreated() ); fbo.bind(); }
int main(int argc, char * argv[]) { glewInit(); glutInit(&argc, argv); glutInitWindowSize(1024, 512); glutInitWindowPosition(0, 0); glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); //Initialize object's colors / values torus.color = vec3(1.0f, 0.1f, 0.0f); square.color1 = vec3(1.0, 1.0, 1.0); square2.color1 = vec3(0.95f, 0.1f, 0.7f); square2.color2 = vec3(1.0f, 1.0f, 0.0f); disc.color = vec3(0.1f, 0.5f, 1.0f); sphere.color = vec3(0.15f, 0.45f, 0.0f); sphere2.color = vec3(0.45f, 0.05f, 0.25f); cylinder.color = vec3(0.0f, 0.5f, 0.0f); arena.texID = 18; egg.texID = 20; star.texID = 22; magneton.texID = 25; haunter.texID = 26; frog.texID = 27; goldeen.texID = 76; rain2.color = vec3(0.4f, 0.4f, 1.0f); snow2.color = vec3(1.0f, 1.0f, 1.0f); fontfilename = "Pokemon.ttf"; //Initialize the precipitation numParts = 300; partX = new float[numParts]; partY = new float[numParts]; partOffset = new float[numParts]; for(int i=0; i<numParts; i++){ partX[i] = (float)(rand() % 1200); partX[i] = (partX[i] - 600)/100; partY[i] = (float)(rand() % 1200); partY[i] = (partY[i] - 600)/100; partOffset[i] = (float)(rand() % 360 + 1); } sphere.lava = true;sphere2.lava = false; //Initialize sphere statuses window.window_handle = glutCreateWindow("Solar System"); glutReshapeFunc(ReshapeFunc); glutCloseFunc(CloseFunc); glutMotionFunc(mouseMovement); glutPassiveMotionFunc(mouseMovement); //check for mouse movement glutKeyboardFunc(KeyboardFunc); glutSpecialFunc(SpecialFunc); glutTimerFunc(window.interval, TimerFunc, 0); glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION); //Initialize everything if (glewInit() != GLEW_OK) { cerr << "GLEW failed to initialize." << endl; return 0; } init_resources(); glutDisplayFunc(DisplayFunc); if (!fbo.Initialize(glm::ivec2(512, 512), 1, true)){ cerr << "Frame buffer failed to initialize." << endl; return 0; } sph1.color = vec3(1.0f, 0.85f, 0.0f); if (!sph1.Initialize(8,1.0f, "phong3.vert", "phong3.frag")){return 0;} enm.color = vec3(0.75f, 0.0f, 0.75f); if (!enm.Initialize(2,0.05f, "phong.vert", "phong.frag")){return 0;} usr.color = vec3(0.0f, 0.0f, 0.5f); if (!usr.Initialize(2,0.05f, "phong.vert", "phong.frag")){return 0;} //if (!sb.Initialize()){return 0;} //if (!coin.Initialize()){return 0;} //if (!stadium.Initialize(0)){return 0;} if (!skybox.Initialize(0, 5000, "basic_skybox_shader.vert", "basic_skybox_shader.frag")){return 0;} if (!skybox2.Initialize(1, 5025, "basic_skybox_shader.vert", "basic_skybox_shader.frag")){return 0;} if (!skybox3.Initialize(2, 5050, "basic_skybox_shader.vert", "basic_skybox_shader.frag")){return 0;} if (!skyboxUW.Initialize(3, 5075, "basic_skybox_shader.vert", "basic_skybox_shader.frag")){return 0;} arena.order = 1; if (!sphere.Initialize(15, 1, "sphereShader2.vert", "sphereShader2.frag")){return 0;} if (!sphere2.Initialize(15, 1, "sphereShader2.vert", "sphereShader2.frag")){return 0;} if (!rain2.Initialize(2, 0.02f, "phong.vert", "phong.frag")){return 0;} if (!snow2.Initialize(3, 0.02f, "phong.vert", "phong.frag")){return 0;} //if (!egg.Initialize(15, 1, "./textures/alienEgg.jpg", "basic_texture_shader.vert", "basic_texture_shader.frag")){return 0;} if (!square.Initialize(1, 3.0f, "phong.vert", "phong.frag")) {return 0;} if (!sq4.Initialize(1, 5.0f, "basic_texture_shader.vert", "basic_texture_shader.frag")) {return 0;} if (!disc.Initialize(8, 1.0f, "phong3.vert", "phong3.frag")) {return 0;} if (!healthBar.Initialize(2, 1.0f, 1.f, 1.f, "phong3.vert", "phong3.frag")) {return 0;} if (!soldier.Initialize()) {return 0;} if (!ss.Initialize()) {return 0;} userTeam.userTeam = true; if (!userTeam.Initialize()) {return 0;} if (!cpuTeam.Initialize()) {return 0;} glutMainLoop(); }
void DeferredShadingStage::updateStageData( DSStageData *data, FrameBufferObject *shadingTarget, RenderPartition *parentPart ) { FrameBufferObject *gBufferTarget = data->getGBufferTarget(); Int32 targetWidth; Int32 targetHeight; Int32 targetLeft; Int32 targetBottom; if(shadingTarget != NULL) { targetWidth = shadingTarget->getWidth (); targetHeight = shadingTarget->getHeight(); targetLeft = 0; targetBottom = 0; } else { targetWidth = parentPart->getDrawEnv().getPixelWidth (); targetHeight = parentPart->getDrawEnv().getPixelHeight(); targetLeft = parentPart->getDrawEnv().getPixelLeft (); targetBottom = parentPart->getDrawEnv().getPixelBottom(); } if(gBufferTarget->getWidth () != targetWidth || gBufferTarget->getHeight() != targetHeight ) { _targetSizeChanged = true; } if(_targetSizeChanged == true) { gBufferTarget->setSize(targetWidth, targetHeight); } if(getMFPixelFormats()->size() != getMFPixelTypes()->size()) { SWARNING << "DeferredShadingStage::updateStageData: " << "Number of PixelFormats and PixelTypes inconsistent." << std::endl; } UInt32 lightCount = getMFLights ()->size(); UInt32 bufferCount = osgMin(getMFPixelFormats()->size(), getMFPixelTypes ()->size() ); // buffers changed - remove them here, recreate below if((_changeCache & (PixelFormatsFieldMask | PixelTypesFieldMask )) != 0) { gBufferTarget->editMFColorAttachments()->clear ( ); gBufferTarget->editMFColorAttachments()->resize(bufferCount, NULL ); gBufferTarget->editMFDrawBuffers ()->clear ( ); gBufferTarget->editMFDrawBuffers ()->resize(bufferCount, GL_NONE); } for(UInt32 i = 0; i < bufferCount; ++i) { TextureBuffer *buf = dynamic_cast<TextureBuffer *>(gBufferTarget->getColorAttachments(i)); if(buf == NULL) { TextureBufferUnrecPtr newBuf = createGBuffer(i, targetWidth, targetHeight); buf = newBuf; gBufferTarget->editMFColorAttachments()->replace(i, newBuf ); gBufferTarget->editMFDrawBuffers ()->replace(i, GL_COLOR_ATTACHMENT0_EXT + i); } else { updateGBuffer(buf, i, targetWidth, targetHeight); } } if((_changeCache & LightsFieldMask) != 0) { data->editMFLightChunks ()->resize( lightCount, NULL); data->editMFShadingStates ()->resize(1 + lightCount, NULL); data->editMFShadingProgramChunks()->resize(1 + lightCount, NULL); } // update shading states if((_changeCache & (PixelFormatsFieldMask | PixelTypesFieldMask | AmbientProgramFieldMask | LightProgramsFieldMask | LightsFieldMask )) != 0) { // copy ambient and light programs DSStageData::MFShadingProgramChunksType::const_iterator spcIt = data->editMFShadingProgramChunks()->begin(); DSStageData::MFShadingProgramChunksType::const_iterator spcEnd = data->editMFShadingProgramChunks()->end (); for(UInt32 progIdx = 0; spcIt != spcEnd; ++spcIt, ++progIdx) { if(*spcIt == NULL) { ShaderProgramChunkUnrecPtr newSPC = ShaderProgramChunk::createLocal(); //*spcIt = newSPC; data->editMFShadingProgramChunks()->replace(progIdx, newSPC); } (*spcIt)->clearVertexShaders (); (*spcIt)->clearGeometryShaders(); (*spcIt)->clearFragmentShaders(); if(progIdx == 0 && getAmbientProgram() != NULL) { // ambient program copyProgramChunk(*spcIt, getAmbientProgram()); // TODO: there must be a better way to add this uniform (*spcIt)->getFragmentShader(0)->addUniformVariable( "vpOffset", Vec2f(targetLeft, targetBottom)); } else { // light programs if(_mfLightPrograms.size() == 1) { copyProgramChunk(*spcIt, getLightPrograms(0)); // TODO: there must be a better way to add this uniform (*spcIt)->getFragmentShader(0)->addUniformVariable( "vpOffset", Vec2f(targetLeft, targetBottom)); } else if(_mfLightPrograms.size() == _mfLights.size()) { copyProgramChunk(*spcIt, getLightPrograms(progIdx - 1)); // TODO: there must be a better way to add this uniform (*spcIt)->getFragmentShader(0)->addUniformVariable( "vpOffset", Vec2f(targetLeft, targetBottom)); } else { SWARNING << "DeferredShadingStage::updateStageData: " << "Number of Lights and LightPrograms " << "inconsistent." << std::endl; } } } // create light chunks DSStageData::MFLightChunksType::const_iterator lcIt = data->editMFLightChunks()->begin(); DSStageData::MFLightChunksType::const_iterator lcEnd = data->editMFLightChunks()->end (); for(UInt32 lightIdx = 0; lcIt != lcEnd; ++lcIt, ++lightIdx) { if(*lcIt == NULL) { DSLightChunkUnrecPtr newLC = DSLightChunk::createLocal(); //*lcIt = newLC; data->editMFLightChunks()->replace(lightIdx, newLC); } updateLightChunk(*lcIt, getLights(lightIdx)); } // populate shading states DSStageData::MFShadingStatesType::const_iterator stateIt = data->editMFShadingStates()->begin(); DSStageData::MFShadingStatesType::const_iterator stateEnd = data->editMFShadingStates()->end (); for(UInt32 stateIdx = 0; stateIt != stateEnd; ++stateIt, ++stateIdx) { if(*stateIt == NULL) { StateUnrecPtr newState = State::createLocal(); //*stateIt = newState; data->editMFShadingStates()->replace(stateIdx, newState); } // remove all chunks (*stateIt)->clearChunks(); // add G Buffer textures for(UInt32 bufferIdx = 0; bufferIdx < bufferCount; ++bufferIdx) { TextureBuffer *buf = static_cast<TextureBuffer *>( gBufferTarget->getColorAttachments(bufferIdx)); TextureObjChunk *bufTex = buf->getTexture(); (*stateIt)->addChunk(bufTex, bufferIdx); } // add ambient/light programs and light chunks if(stateIdx == 0) { if(getAmbientProgram() != NULL) { (*stateIt)->addChunk( data->getShadingProgramChunks(stateIdx)); } } else { (*stateIt)->addChunk( data->getShadingProgramChunks(stateIdx )); (*stateIt)->addChunk( data->getLightChunks (stateIdx - 1)); } // add blend chunk to light states if(stateIdx > 0) { (*stateIt)->addChunk(data->getBlendChunk()); } } } _changeCache = TypeTraits<BitVector>::BitsClear; _targetSizeChanged = false; }
void ShaderShadowMapEngine::handleSpotLightEnter( SpotLight *spotL, RenderAction *ract, SSMEngineData *data) { RenderPartition *parentPart = ract->getActivePartition(); // Real cosSpotCutOff = osgCos(spotL->getSpotCutOff()); Matrix matEyeToWorld (parentPart->getCameraToWorld()); Matrix matWorldToLight; Matrix matEyeToLight; calcSpotLightMatrices(matWorldToLight, matEyeToLight, spotL, matEyeToWorld ); Real32 lightNear; Real32 lightFar; calcPointLightRange(spotL, 0.001f, parentPart->getNear(), parentPart->getFar(), lightNear, lightFar ); if(getShadowNear() != 0.f) { lightNear = getShadowNear(); } if(getShadowFar() != 0.f) { lightFar = getShadowFar(); } Matrix matLightProj; Matrix matLightProjTrans; MatrixPerspective(matLightProj, spotL->getSpotCutOff(), 1.f, lightNear, lightFar ); updateShadowTexImage (data); updateShadowTexBuffers(data); updateRenderTargets (data); Int32 shadowTexUnit = (this->getForceTextureUnit() > 0) ? this->getForceTextureUnit() : 7; ShaderProgram *shadowFP = this->getShadowFragmentProgram(); if(shadowFP == NULL) { ShaderProgramUnrecPtr newShadowFP = ShaderProgram::createLocal(); newShadowFP->setShaderType(GL_FRAGMENT_SHADER); newShadowFP->setProgram (_spotFPCode ); newShadowFP->addUniformVariable("SSME_matEyeToLight", matEyeToLight); newShadowFP->addUniformVariable("SSME_matLightProj", matLightProj ); newShadowFP->addUniformVariable("SSME_texShadow", shadowTexUnit); this->setShadowFragmentProgram(newShadowFP); shadowFP = newShadowFP; } else { shadowFP->updateUniformVariable("SSME_matEyeToLight", matEyeToLight); shadowFP->updateUniformVariable("SSME_matLightProj", matLightProj ); } commitChanges(); this->pushPartition(ract); { RenderPartition *part = ract->getActivePartition( ); Window *win = ract->getWindow ( ); FrameBufferObject *target = data->getRenderTargets (0); Background *back = data->getBackground ( ); part->setRenderTarget(target); part->setWindow (win ); part->calcViewportDimension(0.f, 0.f, 1.f, 1.f, target->getWidth (), target->getHeight() ); part->setupProjection(matLightProj, matLightProjTrans); part->setupViewing (matWorldToLight ); part->setNear (parentPart->getNear()); part->setFar (parentPart->getFar ()); part->calcFrustum ( ); part->setBackground (back ); // force material for shadow map generation part->overrideMaterial(data->getLightPassMaterials(0), ract->getActNode ( ) ); this->recurseFrom(ract, spotL); ract->useNodeList(false ); // undo override part->overrideMaterial(NULL, ract->getActNode ( ) ); } this->popPartition(ract); }
void ShaderShadowMapEngine::handleDirectionalLightEnter( DirectionalLight *dirL, RenderAction *ract, SSMEngineData *data) { RenderPartition *parentPart = ract ->getActivePartition(); FrustumVolume camFrust = parentPart->getFrustum (); Matrix matEyeToWorld (parentPart->getCameraToWorld()); Matrix matWorldToLight; Matrix matEyeToLight; calcDirectionalLightMatrices(matWorldToLight, matEyeToLight, dirL, matEyeToWorld ); // place light camera outside the scene bounding box: // - project camera frustum and scene bounding box into a // coordinate system where the directional light shines // along the -z axis. // - compute 2 AABBs that contain the projected frustum and // scene BB // - width and height of the ortho projection are determined from // the frustum AABB, while near and far are determined by the // scene AABB (offscreen objects cast shadows into the view volume) Pnt3f camVerts [10]; Pnt3f sceneVerts[10]; const Matrix &matSceneToWorld = ract->topMatrix (); BoxVolume sceneBB = ract->getActNode()->getVolume(); camFrust.getCorners(camVerts [0], camVerts [1], camVerts [2], camVerts [3], camVerts [4], camVerts [5], camVerts [6], camVerts [7] ); sceneBB .getCorners(sceneVerts[0], sceneVerts[1], sceneVerts[2], sceneVerts[3], sceneVerts[4], sceneVerts[5], sceneVerts[6], sceneVerts[7] ); camVerts [8].setValues(TypeTraits<Real32>::getMax(), TypeTraits<Real32>::getMax(), TypeTraits<Real32>::getMax() ); camVerts [9].setValues(TypeTraits<Real32>::getMin(), TypeTraits<Real32>::getMin(), TypeTraits<Real32>::getMin() ); sceneVerts[8].setValues(TypeTraits<Real32>::getMax(), TypeTraits<Real32>::getMax(), TypeTraits<Real32>::getMax() ); sceneVerts[9].setValues(TypeTraits<Real32>::getMin(), TypeTraits<Real32>::getMin(), TypeTraits<Real32>::getMin() ); for(UInt32 i = 0; i < 8; ++i) { matWorldToLight.mult(camVerts [i], camVerts [i]); matSceneToWorld.mult(sceneVerts[i], sceneVerts[i]); matWorldToLight.mult(sceneVerts[i], sceneVerts[i]); camVerts [8][0] = osgMin(camVerts [8][0], camVerts [i][0]); camVerts [9][0] = osgMax(camVerts [9][0], camVerts [i][0]); camVerts [8][1] = osgMin(camVerts [8][1], camVerts [i][1]); camVerts [9][1] = osgMax(camVerts [9][1], camVerts [i][1]); sceneVerts[8][0] = osgMin(sceneVerts[8][0], sceneVerts[i][0]); sceneVerts[9][0] = osgMax(sceneVerts[9][0], sceneVerts[i][0]); sceneVerts[8][1] = osgMin(sceneVerts[8][1], sceneVerts[i][1]); sceneVerts[9][1] = osgMax(sceneVerts[9][1], sceneVerts[i][1]); sceneVerts[8][2] = osgMin(sceneVerts[8][2], sceneVerts[i][2]); sceneVerts[9][2] = osgMax(sceneVerts[9][2], sceneVerts[i][2]); } // these points are the corners of the ortho shadow view volume Pnt3f lightMin(osgMax(camVerts[8][0], sceneVerts[8][0]), osgMax(camVerts[8][1], sceneVerts[8][1]), -sceneVerts[9][2]); Pnt3f lightMax(osgMin(camVerts[9][0], sceneVerts[9][0]), osgMin(camVerts[9][1], sceneVerts[9][1]), -sceneVerts[8][2]); // enlarge by 2% in x, y, z direction lightMin[0] -= (lightMax[0] - lightMin[0]) * 0.01f; lightMin[1] -= (lightMax[1] - lightMin[1]) * 0.01f; lightMin[2] -= (lightMax[2] - lightMin[2]) * 0.01f; lightMax[0] += (lightMax[0] - lightMin[0]) * 0.01f; lightMax[1] += (lightMax[1] - lightMin[1]) * 0.01f; lightMax[2] += (lightMax[2] - lightMin[2]) * 0.01f; Matrix matLightProj; Matrix matLightProjTrans; MatrixOrthogonal(matLightProj, lightMin[0], lightMax[0], lightMin[1], lightMax[1], lightMin[2], lightMax[2] ); updateShadowTexImage (data); updateShadowTexBuffers(data); updateRenderTargets (data); Int32 shadowTexUnit = (this->getForceTextureUnit() > 0) ? this->getForceTextureUnit() : 7; ShaderProgram *shadowFP = this->getShadowFragmentProgram(); if(shadowFP == NULL) { ShaderProgramUnrecPtr newShadowFP = ShaderProgram::createLocal(); newShadowFP->setShaderType(GL_FRAGMENT_SHADER); newShadowFP->setProgram (_dirFPCode ); newShadowFP->addUniformVariable("SSME_matEyeToLight", matEyeToLight); newShadowFP->addUniformVariable("SSME_matLightProj", matLightProj ); newShadowFP->addUniformVariable("SSME_texShadow", shadowTexUnit); this->setShadowFragmentProgram(newShadowFP); shadowFP = newShadowFP; } else { shadowFP->updateUniformVariable("SSME_matEyeToLight", matEyeToLight); shadowFP->updateUniformVariable("SSME_matLightProj", matLightProj ); } commitChanges(); this->pushPartition(ract); { RenderPartition *part = ract->getActivePartition( ); Window *win = ract->getWindow ( ); FrameBufferObject *target = data->getRenderTargets (0); Background *back = data->getBackground ( ); part->setRenderTarget(target); part->setWindow (win ); part->calcViewportDimension(0.f, 0.f, 1.f, 1.f, target->getWidth (), target->getHeight() ); part->setupProjection(matLightProj, matLightProjTrans); part->setupViewing (matWorldToLight ); part->setNear (parentPart->getNear()); part->setFar (parentPart->getFar ()); part->calcFrustum ( ); part->setBackground (back ); // force material for shadow map generation part->overrideMaterial(data->getLightPassMaterials(0), ract->getActNode ( ) ); this->recurseFrom(ract, dirL); ract->useNodeList(false ); // undo override part->overrideMaterial(NULL, ract->getActNode ( ) ); } this->popPartition(ract); }
void ShaderShadowMapEngine::handlePointLightEnter( PointLight *pointL, RenderAction *ract, SSMEngineData *data) { RenderPartition *parentPart = ract->getActivePartition(); Matrix matEyeToWorld(parentPart->getCameraToWorld()); Matrix matLightProj; Real32 lightNear; Real32 lightFar; calcPointLightRange(pointL, 0.001f, parentPart->getNear(), parentPart->getFar(), lightNear, lightFar ); MatrixPerspective(matLightProj, Pi / 4.f, 1.f, lightNear, lightFar ); Matrix matWorldToLight; Matrix matEyeToLight; calcPointLightMatrices(matWorldToLight, matEyeToLight, pointL, matEyeToWorld ); updatePointLightShadowTexImage (data); updatePointLightShadowTexBuffers(data); updatePointLightRenderTargets (data); Int32 shadowTexUnit = (this->getForceTextureUnit() > 0) ? this->getForceTextureUnit() : 7; ShaderProgram *shadowFP = this->getShadowFragmentProgram(); if(shadowFP == NULL) { ShaderProgramUnrecPtr newShadowFP = ShaderProgram::createLocal(); newShadowFP->setShaderType(GL_FRAGMENT_SHADER); newShadowFP->setProgram (_pointFPCode ); newShadowFP->addUniformVariable("SSME_matEyeToLight", matEyeToLight); newShadowFP->addUniformVariable("SSME_matLightProj", matLightProj ); newShadowFP->addUniformVariable("SSME_texShadow", shadowTexUnit); this->setShadowFragmentProgram(newShadowFP); shadowFP = newShadowFP; } else { shadowFP->updateUniformVariable("SSME_matEyeToLight", matEyeToLight); shadowFP->updateUniformVariable("SSME_matLightProj", matLightProj ); } commitChanges(); // schedule rendering of cube faces for(UInt16 i = 0; i < 6; ++i) { Matrix matWorldToLightFace(matWorldToLight); matWorldToLightFace.multLeft(_matCubeFaceInv[i]); this->pushPartition(ract); { RenderPartition *part = ract->getActivePartition( ); Window *win = ract->getWindow ( ); FrameBufferObject *target = data->getRenderTargets (i); Background *back = data->getBackground ( ); part->setRenderTarget(target); part->setWindow (win ); part->calcViewportDimension(0.f, 0.f, 1.f, 1.f, target->getWidth (), target->getHeight() ); part->setupProjection(matLightProj, Matrix::identity()); part->setupViewing (matWorldToLightFace ); part->setNear (parentPart->getNear()); part->setFar (parentPart->getFar ()); part->calcFrustum ( ); part->setBackground (back ); // force material for shadow map generation part->overrideMaterial(data->getLightPassMaterials(0), ract->getActNode ( ) ); this->recurseFrom(ract, pointL); ract->useNodeList(false ); // undo override part->overrideMaterial(NULL, ract->getActNode ( ) ); } this->popPartition(ract); } }
void DeferredShadingStage::setupShadingPartition( RenderPartition *part, RenderAction *ract, DSStageData *data) { Window *win = ract->getWindow (); FrameBufferObject *target = data->getShadingTarget (); Camera *cam = this->getCamera (); Background *back = this->getBackground (); part->setRenderTarget(target); part->setWindow (win ); if(target != NULL) { part->calcViewportDimension(this->getLeft (), this->getBottom (), this->getRight (), this->getTop (), target->getWidth (), target->getHeight() ); } else if(win != NULL) { part->calcViewportDimension(this->getLeft (), this->getBottom(), this->getRight (), this->getTop (), win->getWidth (), win->getHeight () ); } else { SWARNING << "DeferredShadingStage::setupShadingPartition: " << "No target or window." << std::endl; } // setup ortho projection Matrix matProjection; Matrix matProjectionTranslation; Matrix matViewing; matProjectionTranslation.setIdentity(); matViewing .setIdentity(); MatrixOrthogonal(matProjection, -1.f, 1.f, -1.f, 1.f, -1.f, 1.f ); part->setupProjection(matProjection, matProjectionTranslation); part->setupViewing (matViewing ); part->setNear(-1.f); part->setFar ( 1.f); // setup VPCamera matrices to original projection -- TODO copy from GBuffer pass? cam->getProjection (matProjection, part->getViewportWidth (), part->getViewportHeight() ); cam->getProjectionTranslation(matProjectionTranslation, part->getViewportWidth (), part->getViewportHeight() ); Matrix matProjectionFull = matProjection; matProjectionFull.mult(matProjectionTranslation); Matrix matToWorld; Matrix matWorldToScreen; cam->getViewing(matViewing, part->getViewportWidth (), part->getViewportHeight() ); matToWorld.invertFrom(matViewing); matWorldToScreen = matProjectionFull; matWorldToScreen.mult(matToWorld); part->setVPCameraMatrices(matProjectionFull, matProjection, matProjectionTranslation, matViewing, matToWorld, matWorldToScreen ); part->setBackground(back); part->setSetupMode(RenderPartition::ProjectionSetup | RenderPartition::BackgroundSetup ); }
void DrawShader::Draw(glm::vec3 flowerFade, const FrameBufferObject& shadow_map_fbo_, const FrameBufferObject& reflection_fbo, const FrameBufferObject& deferred_diffuse_fbo_, const FrameBufferObject& deferred_position_fbo_, const FrameBufferObject& deferred_normal_fbo_, const vector<CulledDrawable>& culledDrawables, const glm::mat4& viewMatrix, int useBlinnPhong, const glm::vec3& deerPos, const glm::vec3& sunDir, float sunIntensity, int lightning) { glm::mat4 curView; //For deferred shading. for(auto& shader_pair : shaders.getMap()) { Shader& shader = shader_pair.second; shader.use(); switch (shader_pair.first) { case ShaderType::SHADOW: if(printCurrentShaderName) printf("Shadow\n"); { const auto shadow_view = glm::lookAt(sunDir + deerPos, deerPos, glm::vec3(0.0, 1.0, 0.0)); const auto view_projection = kShadowProjection * shadow_view; // Shadow Culling. Frustum frustum(view_projection); const auto shadow_drawables = frustum.cullShadowDrawables(culledDrawables); if(!debug) { shadow_map_fbo_.bind(); glClear(GL_DEPTH_BUFFER_BIT); } { glPolygonMode(GL_FRONT, GL_FILL); const auto drawables = Drawable::fromCulledDrawables(shadow_drawables, CullType::VIEW_CULLING); for (auto& drawable : drawables) { SendBones(shader, drawable); if (drawable.draw_template.effects.count(EffectType::CASTS_SHADOW)) { SendTexture(shader, drawable); for(auto& instance : drawable.draw_instances) { shader.sendUniform(Uniform::MODEL_VIEW_PROJECTION, uniforms, view_projection * instance.model_transform); shader.sendUniform(Uniform::MODEL, uniforms, instance.model_transform); shader.drawMesh(drawable.draw_template.mesh); } } } } if(!debug) { glBindFramebuffer(GL_FRAMEBUFFER, 0); shadow_map_fbo_.texture().enable(texture_cache_); } } break; case ShaderType::REFLECTION: if (!gReflections) break; { reflection_fbo.bind(); glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); // Cheap hack: just use view culling. auto drawables = Drawable::fromCulledDrawables(culledDrawables, CullType::VIEW_CULLING); // scale everything across the ground. const auto scale = glm::scale(glm::mat4(), glm::vec3(1, -1, 1)); for (std::vector<Drawable>::iterator iter = drawables.begin(); iter != drawables.end();) { // Cheap hack to get rid of the ground plane. DEADLINE // APPROACHES. if (iter->draw_template.height_map) { iter = drawables.erase(iter); } else { for (auto& instance : iter->draw_instances) { instance.model_transform = scale * instance.model_transform; } ++iter; } } const auto reflectSunDir = glm::vec3(scale * glm::vec4(sunDir, 0)); shader.sendUniform(Uniform::HAS_SHADOWS, uniforms, 0); shader.sendUniform(Uniform::USE_BLINN_PHONG, uniforms, useBlinnPhong); glFrontFace(GL_CW); drawTextureShader(true, shader, drawables, viewMatrix, reflectSunDir, sunIntensity, lightning, reflection_fbo); glFrontFace(GL_CCW); } break; case ShaderType::TEXTURE: if (!useTextureShader) break; if(printCurrentShaderName) printf("Texture\n"); glBindFramebuffer(GL_FRAMEBUFFER, 0); { const auto drawables = Drawable::fromCulledDrawables(culledDrawables, CullType::VIEW_CULLING); shader.sendUniform(Uniform::USE_BLINN_PHONG, uniforms, useBlinnPhong); SendShadow(shader, uniforms, shadow_map_fbo_, deerPos, sunDir); SendScreenSize(shader, uniforms); drawTextureShader(false, shader, drawables, viewMatrix, sunDir, sunIntensity, lightning, reflection_fbo); } break; case ShaderType::SKYBOX: if(printCurrentShaderName) printf("Skybox\n"); shader.sendUniform(Uniform::PROJECTION, uniforms, gProjectionMatrix); for (auto& drawable : culledDrawables) { if (drawable.draw_template.shader_type == ShaderType::SKYBOX) { /* doesn't use drawModelTransforms because no normals */ for(const auto& instance : drawable.draw_instances) { shader.sendUniform(Uniform::TEXTURE, uniforms, (*drawable.draw_template.texture).texture_slot()); (*drawable.draw_template.texture).enable(texture_cache_); if (drawable.draw_template.effects.count(EffectType::IS_TITLE_SCREEN)) { shader.sendUniform(Uniform::IS_TITLE_SCREEN, uniforms, 1); curView = glm::lookAt( glm::vec3(2.0f, 0.f,0.0f),glm::vec3(0.f, 0.f, 0.f),glm::vec3( 0.0f, 1.0f, 0.0f ) ); } else { shader.sendUniform(Uniform::IS_TITLE_SCREEN, uniforms, 0); curView = viewMatrix; } shader.sendUniform(Uniform::MODEL_VIEW, uniforms, curView * instance.instance.model_transform); shader.drawMesh(drawable.draw_template.mesh); } } } break; case ShaderType::DEFERRED: if (useTextureShader) break; if(printCurrentShaderName) printf("Deferred\n"); for (size_t i = 0; i < LAST_DEFERRED; ++i) { DeferredType deferred_type = static_cast<DeferredType>(i); switch (deferred_type) { case DEFERRED_DIFFUSE: deferred_diffuse_fbo_.bind(); break; case DEFERRED_POSITION: deferred_position_fbo_.bind(); break; case DEFERRED_NORMAL: deferred_normal_fbo_.bind(); break; default: break; } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } SendShadow(shader, uniforms, shadow_map_fbo_, deerPos, sunDir); for (auto& drawable : culledDrawables) { Drawable newDrawable = Drawable::fromCulledDrawable(drawable, CullType::VIEW_CULLING); if (newDrawable.draw_template.shader_type == ShaderType::DEFERRED) { if (drawable.draw_template.effects.count(EffectType::IS_FLOWER)) shader.sendUniform(Uniform::FLOWER_FADE, uniforms, glm::vec3(1.0f)); else shader.sendUniform(Uniform::FLOWER_FADE, uniforms, flowerFade); newDrawable.draw_template.material.sendMaterial(shader, uniforms); //SendHeightMap(shader, newDrawable); SendBones(shader, newDrawable); SendTexture(shader, newDrawable); { const int vary_material = drawable.draw_template.effects.count(EffectType::VARY_MATERIAL); shader.sendUniform(Uniform::VARY_MATERIAL, uniforms, vary_material); } drawModelTransforms(shader, newDrawable, viewMatrix, deferred_diffuse_fbo_, deferred_position_fbo_, deferred_normal_fbo_, true, uniforms); } } glBindFramebuffer(GL_FRAMEBUFFER, 0); break; case ShaderType::FINAL_LIGHT_PASS: if (useTextureShader) break; glm::mat4 lookAt = glm::lookAt( glm::vec3(2.0f, 0.f,0.0f),glm::vec3(0.f, 0.f, 0.f),glm::vec3( 0.0f, 1.0f, 0.0f ) ); glBindFramebuffer(GL_FRAMEBUFFER, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); deferred_diffuse_fbo_.texture().enable(texture_cache_); shader.sendUniform(Uniform::FINAL_PASS_DIFFUSE_TEXTURE, uniforms, deferred_diffuse_fbo_.texture_slot()); deferred_position_fbo_.texture().enable(texture_cache_); shader.sendUniform(Uniform::FINAL_PASS_POSITION_TEXTURE, uniforms, deferred_position_fbo_.texture_slot()); deferred_normal_fbo_.texture().enable(texture_cache_); shader.sendUniform(Uniform::FINAL_PASS_NORMAL_TEXTURE, uniforms, deferred_normal_fbo_.texture_slot()); SendSun(shader, uniforms, sunIntensity, sunDir); shader.sendUniform(Uniform::PROJECTION, uniforms, gProjectionMatrix); SendScreenSize(shader, uniforms); shader.sendUniform(Uniform::LIGHTNING, uniforms, lightning); for (auto& drawable : culledDrawables) { Drawable newDrawable = Drawable::fromCulledDrawable(drawable, CullType::VIEW_CULLING); if(newDrawable.draw_template.shader_type == ShaderType::FINAL_LIGHT_PASS) { if (drawable.draw_template.effects.count(EffectType::IS_WATER)) { shader.sendUniform(Uniform::IS_WATER, uniforms, 1); shader.sendUniform(Uniform::TEXTURE, uniforms, reflection_fbo.texture_slot()); reflection_fbo.texture().enable(texture_cache_); } else shader.sendUniform(Uniform::IS_WATER, uniforms, 0); shader.sendUniform(Uniform::IS_FIREFLY, uniforms, 0); if (drawable.draw_template.effects.count(EffectType::IS_GOD_RAY)) { shader.sendUniform(Uniform::IS_GOD_RAY, uniforms, 1); if(drawable.draw_template.effects.count(EffectType::IS_FIREFLY)) shader.sendUniform(Uniform::IS_FIREFLY, uniforms, 1); curView = viewMatrix; } else if(drawable.draw_template.effects.count(EffectType::IS_WATER)) { curView = viewMatrix; } else { shader.sendUniform(Uniform::IS_GOD_RAY, uniforms, 0); curView = lookAt; } for(const auto& instance : drawable.draw_instances) { if (drawable.draw_template.effects.count(EffectType::IS_GOD_RAY)) { glm::vec3 ray_pos = glm::vec3(instance.instance.model_transform * glm::vec4(0,0,0,1)); shader.sendUniform(Uniform::GOD_RAY_CENTER, uniforms, ray_pos); } shader.sendUniform(Uniform::MODEL, uniforms, instance.instance.model_transform); shader.sendUniform(Uniform::VIEW, uniforms, curView); shader.sendUniform(Uniform::NORMAL, uniforms, glm::transpose(glm::inverse(curView * instance.instance.model_transform))); shader.drawMesh(drawable.draw_template.mesh); } } } break; } } }
Action::ResultE PostShaderStage::renderEnter(Action *action) { RenderAction *a = dynamic_cast<RenderAction *>(action); a->disableDefaultPartition(); this->beginPartitionGroup(a); { this->pushPartition(a); { RenderPartition *pPart = a->getActivePartition(); FrameBufferObject *pTarget = this->getRenderTarget(); Viewarea *pArea = a->getViewarea(); Camera *pCam = a->getCamera (); Background *pBack = a->getBackground(); if(pTarget == NULL) { this->initData(a); pTarget = this->getRenderTarget(); } pPart->setRenderTarget(pTarget); #ifdef OSG_DEBUGX std::string szMessage("RenderPartition\n"); pPart->setDebugString(szMessage ); #endif if(pArea != NULL) { // pPart->setViewport(pPort ); pPart->setWindow (a->getWindow()); if(pTarget != NULL) { #if 0 pPart->calcViewportDimension(pArea->getLeft (), pArea->getBottom(), pArea->getRight (), pArea->getTop (), pTarget->getWidth (), pTarget->getHeight ()); #endif pPart->calcViewportDimension(0.f, 0.f, 1.f, 1.f, pTarget->getWidth (), pTarget->getHeight ()); } else { pPart->calcViewportDimension(pArea->getLeft (), pArea->getBottom(), pArea->getRight (), pArea->getTop (), a->getWindow()->getWidth (), a->getWindow()->getHeight()); } if(pCam != NULL) { Matrix m, t; // set the projection pCam->getProjection (m, pPart->getViewportWidth (), pPart->getViewportHeight()); pCam->getProjectionTranslation(t, pPart->getViewportWidth (), pPart->getViewportHeight()); pPart->setupProjection(m, t); pCam->getViewing(m, pPart->getViewportWidth (), pPart->getViewportHeight()); pPart->setupViewing(m); pPart->setNear (pCam->getNear()); pPart->setFar (pCam->getFar ()); pPart->calcFrustum(); } pPart->setBackground(pBack); } this->recurseFromThis(a); } this->popPartition(a); this->pushPartition(a, (RenderPartition::CopyWindow | RenderPartition::CopyViewportSize), RenderPartition::SimpleCallback ); { RenderPartition *pPart = a->getActivePartition(); #ifdef OSG_DEBUGX std::string szMessage("PostProcessPartition\n"); pPart->setDebugString(szMessage ); #endif Matrix m, t; m.setIdentity(); t.setIdentity(); MatrixOrthogonal( m, 0.f, 1.f, 0.f, 1.f, -1.f, 1.f); pPart->setupProjection(m, t); RenderPartition::SimpleDrawCallback f; f = boost::bind(&PostShaderStage::postProcess, this, _1); pPart->dropFunctor(f); } this->popPartition(a); } this->endPartitionGroup(a); RenderPassVector::iterator passIt = _vPostProcessPasses.begin(); //Update the uniform parameters to the shader for(; passIt != _vPostProcessPasses.end(); ++passIt) { (*passIt)->updateUniformVariables(a); } return Action::Skip; }
void DepthPeelingStage::setupRenderScene(RenderAction* a, Int32 iVPWidth, Int32 iVPHeight, bool isInitial, bool isPing ) { this->pushPartition(a); { RenderPartition *pPart = a->getActivePartition(); FrameBufferObject *pTarget = NULL; Viewarea *pArea = a->getViewarea (); Camera *pCam = a->getCamera (); Background *pBack = NULL; DepthPeelingStageDataUnrecPtr pData = a->getData<DepthPeelingStageData *>(_iDataSlotId); if(!pData) { this->initData(a, iVPWidth, iVPHeight); } else { this->updateData(a, iVPWidth, iVPHeight); } pData = a->getData<DepthPeelingStageData *>(_iDataSlotId); if (isInitial) { pTarget = pData->getBlendFBO(); pBack = a->getBackground (); } else { if (isPing) pTarget = pData->getPeelPingFBO(); else pTarget = pData->getPeelPongFBO(); pBack = pData->getBackground(); } pPart->setRenderTarget(pTarget); if(pArea != NULL) { pPart->setWindow (a->getWindow()); if(pTarget != NULL) { pPart->calcViewportDimension(pArea->getLeft (), pArea->getBottom(), pArea->getRight (), pArea->getTop (), pTarget->getWidth (), pTarget->getHeight ()); } else { pPart->calcViewportDimension(pArea->getLeft (), pArea->getBottom(), pArea->getRight (), pArea->getTop (), a->getWindow()->getWidth (), a->getWindow()->getHeight()); } if(pCam != NULL) { Matrix m, t; // set the projection pCam->getProjection (m, pPart->getViewportWidth (), pPart->getViewportHeight()); pCam->getProjectionTranslation(t, pPart->getViewportWidth (), pPart->getViewportHeight()); pPart->setupProjection(m, t); pCam->getViewing(m, pPart->getViewportWidth (), pPart->getViewportHeight()); pPart->setupViewing(m); pPart->setNear (pCam->getNear()); pPart->setFar (pCam->getFar ()); pPart->calcFrustum(); } pPart->setBackground(pBack); } pPart->addSetupModeBit(RenderPartition::BackgroundSetup); pPart->pushState(); if (!isInitial) { FrameBufferObject* fbo = isPing ? pData->getPeelPongFBO() : pData->getPeelPingFBO(); TextureBuffer* texbuf = static_cast<TextureBuffer *>(fbo->getDepthAttachment()); TextureObjChunk* depthTexChunk = texbuf->getTexture(); pPart->addOverride(depthTexChunk->getClassId() + getDepthTexUnit(), depthTexChunk ); pPart->addOverride(pData->getSpvIsPeelChunk()->getClassId(), pData->getSpvIsPeelChunk() ); } else { pPart->addOverride(pData->getSpvIsInitialChunk()->getClassId(), pData->getSpvIsInitialChunk() ); } pPart->addOverride(pData->getDepthChunk()->getClassId(), pData->getDepthChunk() ); this->recurseFromThis(a); a->useNodeList(false); pPart->popState(); } this->popPartition(a); }
void RenderIntoBuffer(FrameBufferObject fbo, GLuint handle) { fbo.Bind(); glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-fbo.size.x/2, fbo.size.x/2, -fbo.size.y/2, fbo.size.y/2, 1, 10); if (sh_vertices.size() == 0) { for (float i = -1.0; i <= 1.0; i += 0.01f) { for (float j = -1.0; j <= 1.0; j += 0.01f ) { sh_vertices.push_back(glm::vec2( j, i )); sh_vertices.push_back(glm::vec2( j + 0.01, i )); sh_vertices.push_back(glm::vec2( j + 0.01, i + 0.01)); sh_vertices.push_back(glm::vec2( j, i + 0.01)); tex_vertices.push_back(glm::vec2( (j+1)/2.0f, (i+1)/2.0f )); tex_vertices.push_back(glm::vec2( ((j + 0.01)+1)/2.0f, (i+1)/2.0f )); tex_vertices.push_back(glm::vec2( ((j + 0.01)+1)/2.0f, ((i + 0.01)+1)/2.0f)); tex_vertices.push_back(glm::vec2( (j+1)/2.0f, ((i + 0.01)+1)/2.0f)); //Uncomment the code below to see the vertices /* cout << "Vertex Coords: " << i << ", " << j << " - "; cout << i + 0.01 << ", " << j << " - "; cout << i + 0.01 << ", " << j + 0.01 << " - "; cout << i << ", " << j + 0.01 << endl; //*/ } } glGenBuffers(1, &vertex_coordinate_handle); assert(vertex_coordinate_handle != (GLuint) -1); glBindBuffer(GL_ARRAY_BUFFER, vertex_coordinate_handle); glBufferData(GL_ARRAY_BUFFER, sh_vertices.size() * sizeof(glm::vec2), &sh_vertices[0], GL_STATIC_DRAW); glGenBuffers(1, &tex_coord_handle); assert(tex_coord_handle != (GLuint) -1); glBindBuffer(GL_ARRAY_BUFFER, tex_coord_handle); glBufferData(GL_ARRAY_BUFFER, tex_vertices.size() * sizeof(glm::vec2), &tex_vertices[0], GL_STATIC_DRAW); glGenVertexArrays(1, &vertex_array_handle); glBindVertexArray(vertex_array_handle); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER, vertex_coordinate_handle); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (GLubyte *) NULL); glBindBuffer(GL_ARRAY_BUFFER, tex_coord_handle); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (GLubyte *) NULL); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); } shader.Use(); glUniform2i(shader.size_handle, fbo.size.x, fbo.size.y); glUniform2f(shader.mouse_handle, mouse.x, mouse.y); glUniform2f(shader.mouse_start_handle, mouse_start.x, mouse_start.y); glBindTexture(GL_TEXTURE_2D, handle); glUniform1i(shader.image_handle, GL_TEXTURE0 + handle); glViewport(0, 0, fbo.size.x, fbo.size.y); glClearColor(0, 0, 0.5, 0); glClear(GL_COLOR_BUFFER_BIT); assert(vertex_array_handle != (GLuint) -1); glBindVertexArray(vertex_array_handle); glDrawArrays(GL_QUADS, 0, (GLsizei) sh_vertices.size()); glBindVertexArray(0); glUseProgram(0); glEnable(GL_DEPTH_TEST); fbo.Unbind(); }
void CloseFunc() { shader.TakeDown(); frame.TakeDown(); }