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;
}
}
