Пример #1
0
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");
}
Пример #2
0
void DeferredShadingSystem::setMode(DSMode mode)
{
	assert( 0 <= mode && mode < DSM_COUNT);

	// prevent duplicate setups
	if (mCurrentMode == mode && mInstance[mode]->getEnabled()==mActive)
		return;

	// if the mode is getting disabled 
	// -> we need to remove self as listener only if it was enabled to begin with
	// This should happen before the setEnabled(false) is called
	if (  mCurrentMode == DSM_SHOWLIT
	   && mInstance[mCurrentMode]->getEnabled())
	{
		RenderTarget* renderTarget = mInstance[mCurrentMode]->getRenderTarget("mrt_output");
		assert(renderTarget);

		LogManager::getSingleton().logMessage("Removing Listener from:");
		LogManager::getSingleton().logMessage(renderTarget->getName());

		// remove the listener prior to the texture getting possibly reclaimed
		renderTarget->removeListener(this);
	}

	for(int i=0; i<DSM_COUNT; ++i)
	{
		if(i == mode)
		{
			mInstance[i]->setEnabled(mActive);
		}
		else
		{
			mInstance[i]->setEnabled(false);
		}
	}
	mCurrentMode = mode;

	// if some mode got enabled,
	// set self as listener so that the light materials can be set up if dirty. This should happen after the setEnabled(true)
	// is called
	if (  mCurrentMode == DSM_SHOWLIT
	   && mInstance[mCurrentMode]->getEnabled())
	{
		RenderTarget* renderTarget = mInstance[mCurrentMode]->getRenderTarget("mrt_output");
		assert(renderTarget);

		LogManager::getSingleton().logMessage("Adding Listener to:");
		LogManager::getSingleton().logMessage(renderTarget->getName());
		renderTarget->addListener(this);

		// Additionally, mark the light materials as always dirty
		mLightMaterialsDirty = true;
		mDirtyLightList.clear();
		mDirtyLightList = mLights;

		// set up the ambient light here
		setUpAmbientLightMaterial();
	}
}
Пример #3
0
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 );
}
Пример #4
0
//-------------------------------------------------------------------------------------
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);
	}
}
Пример #5
0
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();


}