void WaterRTT::create() { if (!mSceneMgr) return; mCamera = mSceneMgr->createCamera("PlaneReflectionRefraction"); if (mViewerCamera) { mCamera->setFarClipDistance(mViewerCamera->getFarClipDistance()); mCamera->setNearClipDistance(mViewerCamera->getNearClipDistance()); mCamera->setAspectRatio(mViewerCamera->getAspectRatio()); } for (unsigned int i = 0; i < 2; ++i) { if (i==0 && !mReflect) continue; if (i==1 && !mRefract) continue; TexturePtr tex = TextureManager::getSingleton().createManual(i == 0 ? "PlaneReflection" : "PlaneRefraction", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, mRTTSize, mRTTSize, 0, PF_R8G8B8, TU_RENDERTARGET); RenderTarget* rtt = tex->getBuffer()->getRenderTarget(); Viewport* vp = rtt->addViewport(mCamera); vp->setOverlaysEnabled(false); vp->setBackgroundColour(ColourValue(0.8f, 0.9f, 1.0f)); vp->setShadowsEnabled(false); vp->setMaterialScheme ("reflection"); vp->setVisibilityMask( i == 0 ? RV_WaterReflect : RV_WaterRefract); rtt->addListener(this); if (i == 0) mReflectionTarget = rtt; else mRefractionTarget = rtt; } sh::Factory::getInstance ().setTextureAlias ("WaterReflection", "PlaneReflection"); sh::Factory::getInstance ().setTextureAlias ("WaterRefraction", "PlaneRefraction"); }
void CarReflection::Create() { //bFirstFrame = true; if (pSet->refl_mode == 1) cubetexName = "ReflectionCube"; // single: use 1st cubemap else if (pSet->refl_mode == 2) { cubetexName = "ReflectionCube" + toStr(iIndex); // first cubemap: no index if (cubetexName == "ReflectionCube0") cubetexName = "ReflectionCube"; } else /* static */ cubetexName = "ReflectionCube"; TextureManager* tm = TextureManager::getSingletonPtr(); int size = ciShadowSizesA[pSet->refl_size]; // /2 ? // create cube render texture if ( !(pSet->refl_mode == 1 && iIndex != 0) ) { cubetex = tm->createManual(cubetexName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_CUBE_MAP, size,size, 0/*mips*/, PF_R8G8B8, TU_RENDERTARGET); //LogO("created rt cube"); for (int face = 0; face < 6; face++) { Camera* mCam = pSceneMgr->createCamera("Reflect_" + toStr(iIndex) + "_" + toStr(face)); mCam->setAspectRatio(1.0f); mCam->setFOVy(Degree(90)); mCam->setNearClipDistance(0.1); mCam->setFarClipDistance(pSet->refl_dist * 1.1f); RenderTarget* mRT = cubetex->getBuffer(face)->getRenderTarget(); //LogO( "rt face Name: " + mRT->getName() ); mRT->removeAllViewports(); Viewport* vp = mRT->addViewport(mCam); vp->setOverlaysEnabled(false); vp->setVisibilityMask(RV_MaskReflect); vp->setShadowsEnabled(false); vp->setMaterialScheme ("reflection"); mRT->setAutoUpdated(false); //mRT->addListener(this); //- mCam->setPosition(Vector3::ZERO); Vector3 lookAt(0,0,0), up(0,0,0), right(0,0,0); switch(face) { case 0: lookAt.x =-1; up.y = 1; right.z = 1; break; // +X case 1: lookAt.x = 1; up.y = 1; right.z =-1; break; // -X case 2: lookAt.y =-1; up.z = 1; right.x = 1; break; // +Y case 3: lookAt.y = 1; up.z =-1; right.x = 1; break; // -Y case 4: lookAt.z = 1; up.y = 1; right.x =-1; break; // +Z case 5: lookAt.z =-1; up.y = 1; right.x =-1; break; // -Z } Quaternion orient( right, up, lookAt ); mCam->setOrientation( orient ); pCams[face] = mCam; pRTs[face] = mRT; } } }
KDvoid Sample_Fresnel::setupWater ( KDvoid ) { // create our reflection & refraction render textures, and setup their render targets for ( KDuint i = 0; i < 2; i++ ) { TexturePtr pTex = TextureManager::getSingleton ( ).createManual ( i == 0 ? "refraction" : "reflection", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); RenderTarget* pRtt = pTex->getBuffer ( )->getRenderTarget ( ); pRtt->addViewport ( m_pCamera )->setOverlaysEnabled ( false ); pRtt->addListener ( this ); if ( i == 0 ) { m_pRefractionTarget = pRtt; } else { m_pReflectionTarget = pRtt; } } // create our water plane mesh m_tWaterPlane = Plane ( Vector3::UNIT_Y, 0 ); MeshManager::getSingleton ( ).createPlane ( "water", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, m_tWaterPlane, 700, 1300, 10, 10, true, 1, 3, 5, Vector3::UNIT_Z ); // create a water entity using our mesh, give it the shader material, and attach it to the origin m_pWater = m_pSceneMgr->createEntity ( "Water", "water" ); m_pWater->setMaterialName ( "Examples/FresnelReflectionRefraction" ); m_pSceneMgr->getRootSceneNode ( )->attachObject ( m_pWater ); }
//------------------------------------------------------------------------------------- void BasicTutorial2::createScene(void) { mSceneMgr->setAmbientLight(Ogre::ColourValue(0, 0, 0)); //mSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE); Ogre::Entity* entNinja = mSceneMgr->createEntity("Ninja", "ninja.mesh"); entNinja->setCastShadows(true); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(entNinja); Ogre::Plane plane(Ogre::Vector3::UNIT_Y, 0); Ogre::MeshManager::getSingleton().createPlane("ground", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 1500, 1500, 20, 20, true, 1, 5, 5, Ogre::Vector3::UNIT_Z); Ogre::Entity* entGround = mSceneMgr->createEntity("GroundEntity", "ground"); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(entGround); entGround->setMaterialName("Examples/Rockwall"); //entGround->setMaterialName("RttMat"); entGround->setCastShadows(false); Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh"); Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("HeadNode"); headNode->attachObject(ogreHead); headNode->setPosition(50,120,0); Ogre::Light* pointLight = mSceneMgr->createLight("pointLight"); pointLight->setType(Ogre::Light::LT_POINT); pointLight->setPosition(Ogre::Vector3(0, 150, 250)); pointLight->setDiffuseColour(1.0, 0.0, 0.0); pointLight->setSpecularColour(1.0, 0.0, 0.0); Ogre::Light* directionalLight = mSceneMgr->createLight("directionalLight"); directionalLight->setType(Ogre::Light::LT_DIRECTIONAL); directionalLight->setDiffuseColour(Ogre::ColourValue(.25, .25, 0)); directionalLight->setSpecularColour(Ogre::ColourValue(.25, .25, 0)); directionalLight->setDirection(Ogre::Vector3( 0, -1, 1 )); Ogre::Light* spotLight = mSceneMgr->createLight("spotLight"); spotLight->setType(Ogre::Light::LT_SPOTLIGHT); spotLight->setDiffuseColour(0, 0, 1.0); spotLight->setSpecularColour(0, 0, 1.0); spotLight->setDirection(-1, -1, 0); spotLight->setPosition(Ogre::Vector3(300, 300, 0)); spotLight->setSpotlightRange(Ogre::Degree(35), Ogre::Degree(50)); //------------------ using namespace Ogre; TexturePtr texture = TextureManager::getSingleton(). createManual( "RttTex",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D,512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); RenderTarget *rttTex = texture->getBuffer()->getRenderTarget(); mReflectCam = mSceneMgr->createCamera("ReflectCam"); mReflectCam->setOrientation(mCamera->getOrientation()); mReflectCam->setPosition(mCamera->getPosition()); mReflectCam->setNearClipDistance(mCamera->getNearClipDistance()); mReflectCam->setFarClipDistance(mCamera->getFarClipDistance()); mReflectCam->setAspectRatio( (Real)mWindow->getViewport(0)->getActualWidth() / (Real)mWindow->getViewport(0)->getActualHeight()); Viewport *v = rttTex->addViewport( mReflectCam ); v->setClearEveryFrame( true ); v->setBackgroundColour( ColourValue::Black ); //MaterialPtr mat = MaterialManager::getSingleton().create("RttMat",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); //TextureUnitState* t = mat->getTechnique(0)->getPass(0)->createTextureUnitState("RustedMetal.jpg"); MaterialPtr mat; TextureUnitState *t = NULL; Entity *entMaterial = entGround ; int nCnt = entGround->getNumSubEntities(); for ( int i=0; i<nCnt; i++) { SubEntity* _SubEnt = entMaterial->getSubEntity(i); MaterialPtr _MaterPtr; Pass * _Pass; mat = _SubEnt->getMaterial(); break; } t = mat->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex"); // Blend with base texture t->setColourOperationEx(LBX_BLEND_MANUAL, LBS_TEXTURE, LBS_CURRENT,ColourValue::White, ColourValue::White, 0.65); t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); t->setProjectiveTexturing(true, mReflectCam); rttTex->addListener(this); // set up linked reflection mReflectCam->enableReflection(plane); // Also clip mReflectCam->enableCustomNearClipPlane(plane); //------------------ #if 0 // skybox //mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox");//, 10); //mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 5000, false); #endif #if 0 // skydome mSceneMgr->setSkyDome(true, "Examples/CloudySky", 5, 8); #endif #if 0 //skyplane Ogre::Plane plane2; plane2.d = 1000; plane2.normal = Ogre::Vector3::NEGATIVE_UNIT_Y; //mSceneMgr->setSkyPlane(true, plane2, "Examples/SpaceSkyPlane", 1500, 75); mSceneMgr->setSkyPlane(true, plane, "Examples/CloudySky", 1500, 40, true, 1.5f, 150, 150); #endif #if 0 Ogre::ColourValue fadeColour(0.9, 0.9, 0.9); mWindow->getViewport(0)->setBackgroundColour(fadeColour); //mSceneMgr->setFog(Ogre::FOG_LINEAR, fadeColour, 0.0, 50, 500); //mSceneMgr->setFog(Ogre::FOG_EXP, fadeColour, 0.005); mSceneMgr->setFog(Ogre::FOG_EXP2, fadeColour, 0.003); #endif { Ogre::ColourValue fadeColour(0.1, 0.1, 0.1); mWindow->getViewport(0)->setBackgroundColour(fadeColour); mSceneMgr->setFog(Ogre::FOG_LINEAR, fadeColour, 0.0, 10, 150); Ogre::Plane plane; plane.d = 10; plane.normal = Ogre::Vector3::NEGATIVE_UNIT_Y; mSceneMgr->setSkyPlane(true, plane, "Examples/SpaceSkyPlane", 100, 45, true, 0.5, 150, 150); } }
//--------------------------------------------------------------------- void TerrainMaterialGenerator::_renderCompositeMap(size_t size, const Rect& rect, const MaterialPtr& mat, const TexturePtr& destCompositeMap) { if (!mCompositeMapSM) { // dedicated SceneManager mCompositeMapSM = Root::getSingleton().createSceneManager(DefaultSceneManagerFactory::FACTORY_TYPE_NAME); float camDist = 100; float halfCamDist = camDist * 0.5f; mCompositeMapCam = mCompositeMapSM->createCamera("cam"); mCompositeMapCam->setPosition(0, 0, camDist); mCompositeMapCam->lookAt(Vector3::ZERO); mCompositeMapCam->setProjectionType(PT_ORTHOGRAPHIC); mCompositeMapCam->setNearClipDistance(10); mCompositeMapCam->setFarClipDistance(500); mCompositeMapCam->setOrthoWindow(camDist, camDist); // Just in case material relies on light auto params mCompositeMapLight = mCompositeMapSM->createLight(); mCompositeMapLight->setType(Light::LT_DIRECTIONAL); RenderSystem* rSys = Root::getSingleton().getRenderSystem(); Real hOffset = rSys->getHorizontalTexelOffset() / (Real)size; Real vOffset = rSys->getVerticalTexelOffset() / (Real)size; // set up scene mCompositeMapPlane = mCompositeMapSM->createManualObject(); mCompositeMapPlane->begin(mat->getName()); mCompositeMapPlane->position(-halfCamDist, halfCamDist, 0); mCompositeMapPlane->textureCoord(0 - hOffset, 0 - vOffset); mCompositeMapPlane->position(-halfCamDist, -halfCamDist, 0); mCompositeMapPlane->textureCoord(0 - hOffset, 1 - vOffset); mCompositeMapPlane->position(halfCamDist, -halfCamDist, 0); mCompositeMapPlane->textureCoord(1 - hOffset, 1 - vOffset); mCompositeMapPlane->position(halfCamDist, halfCamDist, 0); mCompositeMapPlane->textureCoord(1 - hOffset, 0 - vOffset); mCompositeMapPlane->quad(0, 1, 2, 3); mCompositeMapPlane->end(); mCompositeMapSM->getRootSceneNode()->attachObject(mCompositeMapPlane); } // update mCompositeMapPlane->setMaterialName(0, mat->getName()); TerrainGlobalOptions& globalopts = TerrainGlobalOptions::getSingleton(); mCompositeMapLight->setDirection(globalopts.getLightMapDirection()); mCompositeMapLight->setDiffuseColour(globalopts.getCompositeMapDiffuse()); mCompositeMapSM->setAmbientLight(globalopts.getCompositeMapAmbient()); // check for size change (allow smaller to be reused) if (mCompositeMapRTT && size != mCompositeMapRTT->getWidth()) { TextureManager::getSingleton().remove(mCompositeMapRTT->getHandle()); mCompositeMapRTT = 0; } if (!mCompositeMapRTT) { mCompositeMapRTT = TextureManager::getSingleton().createManual( mCompositeMapSM->getName() + "/compRTT", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, size, size, 0, PF_BYTE_RGBA, TU_RENDERTARGET).get(); RenderTarget* rtt = mCompositeMapRTT->getBuffer()->getRenderTarget(); // don't render all the time, only on demand rtt->setAutoUpdated(false); Viewport* vp = rtt->addViewport(mCompositeMapCam); // don't render overlays vp->setOverlaysEnabled(false); } // calculate the area we need to update Real vpleft = (Real)rect.left / (Real)size; Real vptop = (Real)rect.top / (Real)size; Real vpright = (Real)rect.right / (Real)size; Real vpbottom = (Real)rect.bottom / (Real)size; RenderTarget* rtt = mCompositeMapRTT->getBuffer()->getRenderTarget(); mCompositeMapCam->setWindow(vpleft, vptop, vpright, vpbottom); rtt->update(); // We have an RTT, we want to copy the results into a regular texture // That's because in non-update scenarios we don't want to keep an RTT // around. We use a single RTT to serve all terrain pages which is more // efficient. Image::Box box(rect.left, rect.top, rect.right, rect.bottom); destCompositeMap->getBuffer()->blit(mCompositeMapRTT->getBuffer(), box, box); }
//----------------------------------------------------------------------- void CompositorInstance::createResources() { static size_t dummyCounter = 0; freeResources(); /// Create temporary textures /// In principle, temporary textures could be shared between multiple viewports /// (CompositorChains). This will save a lot of memory in case more viewports /// are composited. CompositionTechnique::TextureDefinitionIterator it = mTechnique->getTextureDefinitionIterator(); while(it.hasMoreElements()) { CompositionTechnique::TextureDefinition *def = it.getNext(); /// Determine width and height size_t width = def->width; size_t height = def->height; uint fsaa = 0; bool hwGammaWrite = false; deriveTextureRenderTargetOptions(def->name, &hwGammaWrite, &fsaa); if(width == 0) width = static_cast<size_t>( static_cast<float>(mChain->getViewport()->getActualWidth()) * def->widthFactor); if(height == 0) height = static_cast<size_t>( static_cast<float>(mChain->getViewport()->getActualHeight()) * def->heightFactor); /// Make the tetxure RenderTarget* rendTarget; if (def->formatList.size() > 1) { String MRTbaseName = "c" + StringConverter::toString(dummyCounter++) + "/" + def->name + "/" + mChain->getViewport()->getTarget()->getName(); MultiRenderTarget* mrt = Root::getSingleton().getRenderSystem()->createMultiRenderTarget(MRTbaseName); mLocalMRTs[def->name] = mrt; // create and bind individual surfaces size_t atch = 0; for (PixelFormatList::iterator p = def->formatList.begin(); p != def->formatList.end(); ++p, ++atch) { TexturePtr tex = TextureManager::getSingleton().createManual( MRTbaseName + "/" + StringConverter::toString(atch), ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D, (uint)width, (uint)height, 0, *p, TU_RENDERTARGET ); RenderTexture* rt = tex->getBuffer()->getRenderTarget(); rt->setAutoUpdated(false); mrt->bindSurface(atch, rt); // Also add to local textures so we can look up String mrtLocalName = getMRTTexLocalName(def->name, atch); mLocalTextures[mrtLocalName] = tex; } rendTarget = mrt; } else { String texName = "c" + StringConverter::toString(dummyCounter++) + "/" + def->name + "/" + mChain->getViewport()->getTarget()->getName(); // space in the name mixup the cegui in the compositor demo // this is an auto generated name - so no spaces can't hart us. std::replace( texName.begin(), texName.end(), ' ', '_' ); TexturePtr tex = TextureManager::getSingleton().createManual( texName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D, (uint)width, (uint)height, 0, def->formatList[0], TU_RENDERTARGET, 0, hwGammaWrite, fsaa); rendTarget = tex->getBuffer()->getRenderTarget(); mLocalTextures[def->name] = tex; } /// Set up viewport over entire texture rendTarget->setAutoUpdated( false ); Camera* camera = mChain->getViewport()->getCamera(); // Save last viewport and current aspect ratio Viewport* oldViewport = camera->getViewport(); Real aspectRatio = camera->getAspectRatio(); Viewport* v = rendTarget->addViewport( camera ); v->setClearEveryFrame( false ); v->setOverlaysEnabled( false ); v->setBackgroundColour( ColourValue( 0, 0, 0, 0 ) ); // Should restore aspect ratio, in case of auto aspect ratio // enabled, it'll changed when add new viewport. camera->setAspectRatio(aspectRatio); // Should restore last viewport, i.e. never disturb user code // which might based on that. camera->_notifyViewport(oldViewport); } }
void CarReflection::Create() { bFirstFrame = true; if (pSet->refl_mode == "single") cubetexName = "ReflectionCube"; // single: use 1st cubemap else if (pSet->refl_mode == "full") { cubetexName = "ReflectionCube" + toStr(iIndex); // first cubemap: no index if (cubetexName == "ReflectionCube0") cubetexName = "ReflectionCube"; } else /* static */ cubetexName = "ReflectionCube"; TextureManager* tm = TextureManager::getSingletonPtr(); int size = ciShadowSizesA[pSet->refl_size]; // /2 ? // create cube render texture if (! (pSet->refl_mode == "single" && iIndex != 0) ) { cubetex = tm->createManual(cubetexName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_CUBE_MAP, size,size, 0/*mips*/, PF_R8G8B8, TU_RENDERTARGET); //LogO("created rt cube"); for (int face = 0; face < 6; face++) { Camera* mCam = pSceneMgr->createCamera("Reflect_" + toStr(iIndex) + "_" + toStr(face)); mCam->setAspectRatio(1.0f); mCam->setFOVy(Degree(90)); mCam->setNearClipDistance(0.1); //mCam->setFarClipDistance(pSet->refl_dist); //sky- RenderTarget* mRT = cubetex->getBuffer(face)->getRenderTarget(); //LogO( "rt face Name: " + mRT->getName() ); mRT->removeAllViewports(); Viewport* vp = mRT->addViewport(mCam); vp->setOverlaysEnabled(false); vp->setVisibilityMask(RV_MaskReflect); mRT->setAutoUpdated(false); //mRT->addListener(this); //- mCam->setPosition(Vector3::ZERO); Vector3 lookAt(0,0,0), up(0,0,0), right(0,0,0); switch(face) { case 0: lookAt.x =-1; up.y = 1; right.z = 1; break; // +X case 1: lookAt.x = 1; up.y = 1; right.z =-1; break; // -X case 2: lookAt.y =-1; up.z = 1; right.x = 1; break; // +Y case 3: lookAt.y = 1; up.z =-1; right.x = 1; break; // -Y case 4: lookAt.z = 1; up.y = 1; right.x =-1; break; // +Z case 5: lookAt.z =-1; up.y = 1; right.x =-1; break; // -Z } Quaternion orient( right, up, lookAt ); mCam->setOrientation( orient ); pCams[face] = mCam; pRTs[face] = mRT; } } // Iterate through our materials and add an index to ReflectionCube texture reference for (int i=0; i < NumMaterials; i++) { MaterialPtr mtr = MaterialManager::getSingleton().getByName(sMtr[i]); if (!mtr.isNull()) { Material::TechniqueIterator techIt = mtr->getTechniqueIterator(); while (techIt.hasMoreElements()) { Technique* tech = techIt.getNext(); Technique::PassIterator passIt = tech->getPassIterator(); while (passIt.hasMoreElements()) { Pass* pass = passIt.getNext(); Pass::TextureUnitStateIterator tusIt = pass->getTextureUnitStateIterator(); while (tusIt.hasMoreElements()) { TextureUnitState* tus = tusIt.getNext(); if (tus->getTextureName() == "ReflectionCube") tus->setTextureName(cubetexName); } } } } } }
void WaterZone::build(){ mReflectionListener = new ReflectionTextureListener(); mRefractionListener = new RefractionTextureListener(); mReflectionListener->setWater(this); mRefractionListener->setWater(this); RenderTarget *rttTex; TexturePtr mRefractionTexture = TextureManager::getSingleton().createManual( "Refraction", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); //RenderTexture* rttTex = mRoot->getRenderSystem()->createRenderTexture( "Refraction", 512, 512 ); rttTex = mRefractionTexture->getBuffer()->getRenderTarget(); { Viewport *v = rttTex->addViewport( Level::getSingleton()->getCamera() ); MaterialPtr mat = MaterialManager::getSingleton().getByName(mMaterialName); mat->getTechnique(0)->getPass(0)->getTextureUnitState(2)->setTextureName("Refraction"); v->setOverlaysEnabled(false); rttTex->addListener(mRefractionListener); } TexturePtr mReflectionTexture = TextureManager::getSingleton().createManual( "Reflection", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); //rttTex = mRoot->getRenderSystem()->createRenderTexture( "Reflection", 512, 512 ); rttTex = mReflectionTexture->getBuffer()->getRenderTarget(); { Viewport *v = rttTex->addViewport( Level::getSingleton()->getCamera() ); MaterialPtr mat = MaterialManager::getSingleton().getByName(mMaterialName); mat->getTechnique(0)->getPass(0)->getTextureUnitState(1)->setTextureName("Reflection"); v->setOverlaysEnabled(false); rttTex->addListener(mReflectionListener); } /*mRefractionTexture = Core::getSingleton()->getRoot()->getRenderSystem()->createRenderTexture( "Refraction", 256, 256 ); { Viewport *v = mRefractionTexture->addViewport( Level::getSingleton()->getCurrentSegment()->getActiveCamera()->getCamera() ); MaterialPtr mat = MaterialManager::getSingleton().getByName("Examples/FresnelReflectionRefraction"); mat->getTechnique(0)->getPass(0)->getTextureUnitState(2)->setTextureName("Refraction"); v->setOverlaysEnabled(false); mRefractionTexture->addListener(mRefractionListener); } mReflectionTexture = Core::getSingleton()->getRoot()->getRenderSystem()->createRenderTexture( "Reflection", 256, 256 ); { Viewport *v = mReflectionTexture->addViewport( Level::getSingleton()->getCurrentSegment()->getActiveCamera()->getCamera() ); MaterialPtr mat = MaterialManager::getSingleton().getByName("Examples/FresnelReflectionRefraction"); mat->getTechnique(0)->getPass(0)->getTextureUnitState(1)->setTextureName("Reflection"); v->setOverlaysEnabled(true); mReflectionTexture->addListener(mReflectionListener); }*/ mReflectionPlane.normal = Vector3::UNIT_Y; mReflectionPlane.d = 0; MeshManager::getSingleton().createPlane("ReflectPlane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, mReflectionPlane, 1000,1000,10,10,true,1,3,5,Vector3::UNIT_Z); /*MeshManager::getSingleton().createPlane("ReflectPlane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, mReflectionPlane, 300,300,10,10,true,1,5,5,Vector3::UNIT_Z);*/ mEntity = Level::getSingleton()->getSceneManager()->createEntity( "plane", "ReflectPlane" ); mEntity->setMaterialName(mMaterialName); //Level::getSingleton()->getSceneManager()->getRootSceneNode()->attachObject(mEntity); mSceneNode->attachObject(mEntity); mSceneNode->setPosition(Vector3(0, 0, 0)); mSceneNode->setOrientation(Ogre::Quaternion::IDENTITY); //mSceneNode->roll((Ogre::Radian)(Ogre::Degree)45); //mSceneMgr->getRootSceneNode()->createChildSceneNode() Parent::build(); }