void PlaneNodeProcessor::createRenderToTextures(Ogre::Entity* entity, Plane* plane, MaterialPtr material, XERCES_CPP_NAMESPACE::DOMElement* rttElem) { if(rttElem == NULL) return; Camera* cam = CoreSubsystem::getSingleton().getWorld()->getSceneManager()->createCamera("Cam" + entity->getName()); cam->setNearClipDistance(CoreSubsystem::getSingleton().getWorld()->getActiveCamera()->getNearClipDistance()); cam->setFarClipDistance(CoreSubsystem::getSingleton().getWorld()->getActiveCamera()->getFarClipDistance()); //cam->setFarClipDistance(1000000); cam->setAspectRatio(CoreSubsystem::getSingleton().getWorld()->getActiveCamera()->getAspectRatio()); cam->setFOVy(CoreSubsystem::getSingleton().getWorld()->getActiveCamera()->getFOVy()); AliasTextureNamePairList aliases; if(getAttributeValueAsBool(rttElem, "reflection")) { TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "Reflection" + entity->getName(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); RenderTexture* rttTex = texture->getBuffer()->getRenderTarget(); Viewport *v = rttTex->addViewport( cam ); v->setOverlaysEnabled(false); rttTex->addListener(new PlaneReflectionTextureListener(entity, cam, plane)); aliases["reflection"] = "Reflection" + entity->getName(); cam->enableCustomNearClipPlane((MovablePlane*)plane); } if(getAttributeValueAsBool(rttElem, "refraction")) { TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "Refraction" + entity->getName(), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET ); RenderTexture* rttTex = texture->getBuffer()->getRenderTarget(); Viewport *v = rttTex->addViewport( cam); v->setOverlaysEnabled(false); rttTex->addListener(new PlaneRefractionTextureListener(entity, cam)); aliases["refraction"] = "Refraction" + entity->getName(); plane->normal = Vector3::NEGATIVE_UNIT_Y; cam->enableCustomNearClipPlane((MovablePlane*)plane); } if(!material->applyTextureAliases(aliases)) LOG_ERROR("PLANE", "Texture Aliase konnten nicht angewandt werden"); }
//----------------------------------------------------------------------- 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 int width = def->width.adjust + static_cast<int>(mChain->getViewport()->getActualWidth() * def->width.viewport) + static_cast<int>(mChain->getViewport()->getActualWidth() * def->width.previous); // FIXME int height = def->height.adjust + static_cast<int>(mChain->getViewport()->getActualHeight() * def->height.viewport) + static_cast<int>(mChain->getViewport()->getActualHeight() * def->height.previous); // FIXME if (width <= 0) { // Throw exception? Not that case, because user can't guarantee // provides correct parameters always, since it might related to // viewport dimensions which can't control by user all the way. width = 1; } if (height <= 0) { // Throw exception? Not that case, because user can't guarantee // provides correct parameters always, since it might related to // viewport dimensions which can't control by user all the way. height = 1; } /// Make the tetxure TexturePtr tex = TextureManager::getSingleton().createManual( "CompositorInstanceTexture"+StringConverter::toString(dummyCounter), ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D, (uint)width, (uint)height, 0, def->format, TU_RENDERTARGET ); ++dummyCounter; mLocalTextures[def->name] = tex; /// Set up viewport over entire texture RenderTexture *rtt = tex->getBuffer()->getRenderTarget(); rtt->setAutoUpdated( false ); Camera* camera = mChain->getViewport()->getCamera(); // Save last viewport and current aspect ratio Viewport* oldViewport = camera->getViewport(); Real aspectRatio = camera->getAspectRatio(); Viewport* v = rtt->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); } }
GUI::GUI(Agent *a, Face *face) : agent(a) { #pragma mark CEGUI Resources ogreRenderer = &OgreRenderer::bootstrapSystem(); #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 Imageset::setDefaultResourceGroup("Win32"); CEGUI::Font::setDefaultResourceGroup("Win32"); Scheme::setDefaultResourceGroup("Win32"); WidgetLookManager::setDefaultResourceGroup("Win32"); WindowManager::setDefaultResourceGroup("Win32"); #elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE Imageset::setDefaultResourceGroup("Apple"); CEGUI::Font::setDefaultResourceGroup("Apple"); Scheme::setDefaultResourceGroup("Apple"); WidgetLookManager::setDefaultResourceGroup("Apple"); WindowManager::setDefaultResourceGroup("Apple"); #else Imageset::setDefaultResourceGroup("Unix"); CEGUI::Font::setDefaultResourceGroup("Unix"); Scheme::setDefaultResourceGroup("Unix"); WidgetLookManager::setDefaultResourceGroup("Unix"); WindowManager::setDefaultResourceGroup("Unix"); #endif #pragma mark GUI SchemeManager::getSingleton().create("TaharezLook.scheme"); System::getSingleton().setDefaultMouseCursor("TaharezLook", "MouseArrow"); WindowManager& windowManager = WindowManager::getSingleton(); Window *sheet = windowManager.createWindow("DefaultWindow", "CEGUIDemo/Sheet"); System::getSingleton().setGUISheet(sheet); Root& root = Root::getSingleton(); TexturePtr texturePointer = root.getTextureManager()->createManual("RTT", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D, 512, 512, 0, PF_R8G8B8, TU_RENDERTARGET); RenderTexture *renderTexture = texturePointer->getBuffer()->getRenderTarget(); Camera *guiCamera = root.getSceneManager("PUSPA")->createCamera("RTTCam"); guiCamera->setPosition(100.0f, -100.0f, -400.0f); guiCamera->lookAt(0.0f, 0.0f, -300.0f); Viewport *guiViewport = renderTexture->addViewport(guiCamera); guiViewport->setOverlaysEnabled(false); guiViewport->setClearEveryFrame(true); guiViewport->setBackgroundColour(ColourValue::Black); CEGUI::Texture& guiTexture = ogreRenderer->createTexture(texturePointer); Imageset& imageSet = ImagesetManager::getSingleton().create("RTTImageset", guiTexture); imageSet.defineImage("RTTImage", CEGUI::Point(0.0f, 0.0f), CEGUI::Size(guiTexture.getSize().d_width, guiTexture.getSize().d_height), CEGUI::Point(0.0f, 0.0f)); Window *staticImage = WindowManager::getSingleton().createWindow("TaharezLook/StaticImage"); staticImage->setSize(UVector2(UDim(1.0f, 0.0f), UDim(0.1f, 0.0f))); staticImage->setPosition(UVector2(UDim(0.0f, 0.0f), UDim(0.9f, 0.0f))); staticImage->setProperty("Image", PropertyHelper::imageToString(&imageSet.getImage("RTTImage"))); sheet->addChildWindow(staticImage); guiConsole = windowManager.loadWindowLayout("Console.layout"); guiConsole->subscribeEvent(Window::EventKeyDown, Event::Subscriber(&GUI::handleKeyDown, this)); guiConsole->getChild(EntryBoxID)->subscribeEvent(Editbox::EventTextAccepted, Event::Subscriber(&GUI::handleSubmit, this)); staticImage->addChildWindow(guiConsole); face->gui = this; }
void ImpostorTexture::renderTextures(bool force) { #ifdef IMPOSTOR_FILE_SAVE TexturePtr renderTexture; #else TexturePtr renderTexture(texture); //if we're not using a file image we need to set up a resource loader, so that the texture is regenerated if it's ever unloaded (such as switching between fullscreen and the desktop in win32) loader = std::auto_ptr<ImpostorTextureResourceLoader>(new ImpostorTextureResourceLoader(*this)); #endif RenderTexture *renderTarget; Camera *renderCamera; Viewport *renderViewport; SceneNode *camNode; //Set up RTT texture uint32 textureSize = ImpostorPage::impostorResolution; if (renderTexture.isNull()) { renderTexture = TextureManager::getSingleton().createManual(getUniqueID("ImpostorTexture"), "Impostors", TEX_TYPE_2D, textureSize * IMPOSTOR_YAW_ANGLES, textureSize * IMPOSTOR_PITCH_ANGLES, 0, PF_A8R8G8B8, TU_RENDERTARGET, loader.get()); } renderTexture->setNumMipmaps(MIP_UNLIMITED); //Set up render target renderTarget = renderTexture->getBuffer()->getRenderTarget(); renderTarget->setAutoUpdated(false); //Set up camera camNode = sceneMgr->getSceneNode("ImpostorPage::cameraNode"); renderCamera = sceneMgr->createCamera(getUniqueID("ImpostorCam")); camNode->attachObject(renderCamera); renderCamera->setLodBias(1000.0f); renderViewport = renderTarget->addViewport(renderCamera); renderViewport->setOverlaysEnabled(false); renderViewport->setClearEveryFrame(true); renderViewport->setShadowsEnabled(false); renderViewport->setBackgroundColour(ImpostorPage::impostorBackgroundColor); //Set up scene node SceneNode* node = sceneMgr->getSceneNode("ImpostorPage::renderNode"); Ogre::SceneNode* oldSceneNode = entity->getParentSceneNode(); if (oldSceneNode) { oldSceneNode->detachObject(entity); } node->attachObject(entity); node->setPosition(-entityCenter); //Set up camera FOV const Real objDist = entityRadius * 100; const Real nearDist = objDist - (entityRadius + 1); const Real farDist = objDist + (entityRadius + 1); renderCamera->setAspectRatio(1.0f); renderCamera->setFOVy(Math::ATan(entityDiameter / objDist)); renderCamera->setNearClipDistance(nearDist); renderCamera->setFarClipDistance(farDist); //Disable mipmapping (without this, masked textures look bad) MaterialManager *mm = MaterialManager::getSingletonPtr(); FilterOptions oldMinFilter = mm->getDefaultTextureFiltering(FT_MIN); FilterOptions oldMagFilter = mm->getDefaultTextureFiltering(FT_MAG); FilterOptions oldMipFilter = mm->getDefaultTextureFiltering(FT_MIP); mm->setDefaultTextureFiltering(FO_POINT, FO_LINEAR, FO_NONE); //Disable fog FogMode oldFogMode = sceneMgr->getFogMode(); ColourValue oldFogColor = sceneMgr->getFogColour(); Real oldFogDensity = sceneMgr->getFogDensity(); Real oldFogStart = sceneMgr->getFogStart(); Real oldFogEnd = sceneMgr->getFogEnd(); sceneMgr->setFog(Ogre::FOG_EXP2, Ogre::ColourValue(0,0,0,0), 0.0f, 0.0f, 0.0f); //Ember change //We need to disable all lightning and render it full bright Ogre::ColourValue oldAmbientColour = sceneMgr->getAmbientLight(); sceneMgr->setAmbientLight(ColourValue::White); std::vector<Ogre::MovableObject*> lightStore; Ogre::SceneManager::MovableObjectIterator lightIterator = sceneMgr->getMovableObjectIterator(Ogre::LightFactory::FACTORY_TYPE_NAME); while (lightIterator.hasMoreElements()) { Ogre::MovableObject* light = lightIterator.getNext(); if (light) { if (light->getVisible()) { lightStore.push_back(light); light->setVisible(false); } } } // Get current status of the queue mode Ogre::SceneManager::SpecialCaseRenderQueueMode OldSpecialCaseRenderQueueMode = sceneMgr->getSpecialCaseRenderQueueMode(); //Only render the entity sceneMgr->setSpecialCaseRenderQueueMode(Ogre::SceneManager::SCRQM_INCLUDE); sceneMgr->addSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1); uint8 oldRenderQueueGroup = entity->getRenderQueueGroup(); entity->setRenderQueueGroup(group->geom->getRenderQueue() + 1); bool oldVisible = entity->getVisible(); entity->setVisible(true); float oldMaxDistance = entity->getRenderingDistance(); entity->setRenderingDistance(0); bool needsRegen = true; #ifdef IMPOSTOR_FILE_SAVE //Calculate the filename hash used to uniquely identity this render String strKey = entityKey; char key[32] = {0}; uint32 i = 0; for (String::const_iterator it = entityKey.begin(); it != entityKey.end(); ++it) { key[i] ^= *it; i = (i+1) % sizeof(key); } for (i = 0; i < sizeof(key); ++i) key[i] = (key[i] % 26) + 'A'; String tempdir = this->group->geom->getTempdir(); ResourceGroupManager::getSingleton().addResourceLocation(tempdir, "FileSystem", "BinFolder"); String fileNamePNG = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".png"; String fileNameDDS = "Impostor." + String(key, sizeof(key)) + '.' + StringConverter::toString(textureSize) + ".dds"; //Attempt to load the pre-render file if allowed needsRegen = force; if (!needsRegen){ try{ texture = TextureManager::getSingleton().load(fileNameDDS, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); } catch (...){ try{ texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); } catch (...){ needsRegen = true; } } } #endif if (needsRegen){ //If this has not been pre-rendered, do so now const float xDivFactor = 1.0f / IMPOSTOR_YAW_ANGLES; const float yDivFactor = 1.0f / IMPOSTOR_PITCH_ANGLES; for (int o = 0; o < IMPOSTOR_PITCH_ANGLES; ++o){ //4 pitch angle renders #ifdef IMPOSTOR_RENDER_ABOVE_ONLY Radian pitch = Degree((90.0f * o) * yDivFactor); //0, 22.5, 45, 67.5 #else Radian pitch = Degree((180.0f * o) * yDivFactor - 90.0f); #endif for (int i = 0; i < IMPOSTOR_YAW_ANGLES; ++i){ //8 yaw angle renders Radian yaw = Degree((360.0f * i) * xDivFactor); //0, 45, 90, 135, 180, 225, 270, 315 //Position camera camNode->setPosition(0, 0, 0); camNode->setOrientation(Quaternion(yaw, Vector3::UNIT_Y) * Quaternion(-pitch, Vector3::UNIT_X)); camNode->translate(Vector3(0, 0, objDist), Node::TS_LOCAL); //Render the impostor renderViewport->setDimensions((float)(i) * xDivFactor, (float)(o) * yDivFactor, xDivFactor, yDivFactor); renderTarget->update(); } } #ifdef IMPOSTOR_FILE_SAVE //Save RTT to file with respecting the temp dir renderTarget->writeContentsToFile(tempdir + fileNamePNG); //Load the render into the appropriate texture view texture = TextureManager::getSingleton().load(fileNamePNG, "BinFolder", TEX_TYPE_2D, MIP_UNLIMITED); #else texture = renderTexture; #endif } entity->setVisible(oldVisible); entity->setRenderQueueGroup(oldRenderQueueGroup); entity->setRenderingDistance(oldMaxDistance); sceneMgr->removeSpecialCaseRenderQueue(group->geom->getRenderQueue() + 1); // Restore original state sceneMgr->setSpecialCaseRenderQueueMode(OldSpecialCaseRenderQueueMode); //Re-enable mipmapping mm->setDefaultTextureFiltering(oldMinFilter, oldMagFilter, oldMipFilter); //Re-enable fog sceneMgr->setFog(oldFogMode, oldFogColor, oldFogDensity, oldFogStart, oldFogEnd); //Re-enable both scene lightning and disabled individual lights sceneMgr->setAmbientLight(oldAmbientColour); for (std::vector<Ogre::MovableObject*>::const_iterator I = lightStore.begin(); I != lightStore.end(); ++I) { (*I)->setVisible(true); } //Delete camera renderTarget->removeViewport(0); renderCamera->getSceneManager()->destroyCamera(renderCamera); //Delete scene node node->detachAllObjects(); if (oldSceneNode) { oldSceneNode->attachObject(entity); } #ifdef IMPOSTOR_FILE_SAVE //Delete RTT texture assert(!renderTexture.isNull()); String texName2(renderTexture->getName()); renderTexture.setNull(); if (TextureManager::getSingletonPtr()) TextureManager::getSingleton().remove(texName2); #endif }
/** * @brief Initializes the water. You must call this in order for the water to show up. * @return True if the water technique could be setup, else false. */ bool Water::initialize() { try { Ogre::Plane waterPlane(Ogre::Vector3::UNIT_Y, 0); // create a water plane/scene node /* waterPlane.normal = ; waterPlane.d = 0; */ Ogre::MeshManager::getSingleton().createPlane( "WaterPlane", "environment", waterPlane, 10000, 10000, 5, 5, true, 1, 1000, 1000, Ogre::Vector3::UNIT_Z ); mWaterNode = mSceneMgr.getRootSceneNode()->createChildSceneNode("water"); mRefractionListener = new RefractionTextureListener(); mReflectionListener = new ReflectionTextureListener(); Ogre::TexturePtr texture = TextureManager::getSingleton().createManual("Refraction", "General", TEX_TYPE_2D, 512, 512, 0, PF_A8R8G8B8, TU_RENDERTARGET); RenderTexture* rttTex = texture->getBuffer()->getRenderTarget(); /* RenderTexture* rttTex = EmberOgre::getSingleton().getOgreRoot()->getRenderSystem()->createRenderTexture( "Refraction", 512, 512 );*/ { Viewport *v = rttTex->addViewport( &mCamera ); Ogre::MaterialPtr mat = MaterialManager::getSingleton().getByName("Examples/FresnelReflectionRefraction"); if (!mat.isNull()) { mat->getTechnique(0)->getPass(0)->getTextureUnitState(2)->setTextureName("Refraction"); v->setOverlaysEnabled(false); rttTex->addListener(mRefractionListener); } } texture = TextureManager::getSingleton().createManual("Reflection", "General", TEX_TYPE_2D, 512, 512, 0, PF_A8R8G8B8, TU_RENDERTARGET); rttTex = texture->getBuffer()->getRenderTarget(); { Viewport *v = rttTex->addViewport( &mCamera ); Ogre::MaterialPtr mat = MaterialManager::getSingleton().getByName("Examples/FresnelReflectionRefraction"); if (!mat.isNull()) { mat->getTechnique(0)->getPass(0)->getTextureUnitState(1)->setTextureName("Reflection"); v->setOverlaysEnabled(false); rttTex->addListener(mReflectionListener); } } // Define a floor plane mesh /* reflectionPlane.normal = Vector3::UNIT_Y; reflectionPlane.d = 0;*/ /* MeshManager::getSingleton().createPlane("ReflectPlane",reflectionPlane, 1500,1500,10,10,true,1,5,5,Vector3::UNIT_Z);*/ mWaterEntity = mSceneMgr.createEntity( "plane", "WaterPlane" ); mWaterEntity->setMaterialName("Examples/FresnelReflectionRefraction"); mRefractionListener->setPlaneEntity(mWaterEntity); mReflectionListener->setPlaneEntity(mWaterEntity); mReflectionListener->setReflectionPlane(mReflectionPlane); mReflectionListener->setCamera(&mCamera); mWaterNode->attachObject(mWaterEntity); return true; } catch (const std::exception& ex) { S_LOG_FAILURE("Error when creating water." << ex); return false; } }