Differences

This shows you the differences between two versions of the page.

--- public:t-gede-14-1:lab7 [2014/02/27 19:46] – created marino
+++ public:t-gede-14-1:lab7 [2024/04/29 13:33] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
-====== LAB6: Programmable Shaders ======
+====== LAB7: Programmable Shaders ======
-This lab is based on a variety of sources, including the [[http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Shaders&structure=Cookbook|Ogre Shaders Wiki]].
+This lab is based on a variety of sources, including the [[http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Shaders&structure=Cookbook|Ogre Shaders Wiki]].
 ===== Discussion =====
-Discussion thread for this lab is here: [[http://ruclasses.proboards.com/index.cgi?action=display&board=gedespring2013&thread=123|Lab 6 Discussion Thread]]
+Discussion thread for this lab is here: [[https://piazza.com/class/i4l9of1fw8j3ew?cid=54|Lab 7 Discussion Thread]]
 ===== Goal ======
@@ Line 22: / Line 22: @@
 Follow these steps to complete the lab project:
-  - **Create a New Project** Create a new empty project called "Lab6" in the same way you have created new projects for other lab projects. Create the Lab6Main.cpp file that contains a minimal Ogre application that displays at least one ground plane and an Ogre model. You can use your own application, or you can use the following code: <code cpp>
+  - **Create a New Project** Create a new empty project called "Lab7" in the same way you have created new projects for other lab projects. You can use your own application, or you can use the following {{:public:t-gede-14-1:lab6_handout.7z|code}}:
-#include "OGRE/Ogre.h";
-class MyApplication {
-private:
-	Ogre::SceneManager*     _sceneManager;
-	Ogre::Root*	        _root;
-	Ogre::Entity*		_ogre;
-	Ogre::Entity*		_ground;
-	Ogre::Camera*		_camera;
-public:
-	MyApplication() {
-		_sceneManager = NULL;
-		_root = NULL;
-		_ogre = NULL;
-		_ground = NULL;
-	}
-	~MyApplication() {
-		delete _root;
-	}
-	void loadResources() {
-		Ogre::ConfigFile cf;
-		cf.load("resources_d.cfg");
-		Ogre::ConfigFile::SectionIterator sectionIter = cf.getSectionIterator();
-		Ogre::String sectionName, typeName, dataName;
-		while(sectionIter.hasMoreElements()) {
-			sectionName=sectionIter.peekNextKey();
-			Ogre::ConfigFile::SettingsMultiMap *settings =sectionIter.getNext();
-			Ogre::ConfigFile::SettingsMultiMap::iterator i;
-			for(i=settings->begin(); i!=settings->end(); ++i) {
-				typeName=i->first;
-				dataName=i->second;
-				Ogre::ResourceGroupManager::getSingleton().addResourceLocation(dataName, typeName, sectionName);
-			}
-		}
-		Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-	}
-	void createScene() {
-		_ogre =_sceneManager->createEntity("Sinbad.mesh");
-		_sceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(_ogre);
-		Ogre::Plane plane(Ogre::Vector3::UNIT_Y,-5);
-		Ogre::MeshManager::getSingleton().createPlane("plane",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,plane,1500,1500,200,200,true,1,5,5,Ogre::Vector3::UNIT_Z);
-		Ogre::Entity* _ground=_sceneManager->createEntity("LightPlaneEntity","plane");
-		_sceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(_ground);
-                // HERE YOU SET THE MATERIALS FOR EACH OBJECT
-                // e.g. _ogre->setMaterialName(<put name here>);
-                // e.g. _ground->setMaterialName(<put name here>);
-		Ogre::Light* light = _sceneManager->createLight("Light1");
-		light->setType(Ogre::Light::LT_POINT);
-		light->setPosition(Ogre::Vector3(-10.0, 10.0, 5.0));
-	}
-	int startup() {
-		_root=new Ogre::Root("Plugins_d.cfg");
-		if(!_root->showConfigDialog()) {
-			return -1;
-		}
-		Ogre::RenderWindow* window=_root->initialise(true,"Ogre3D Lab6");
-		_sceneManager=_root->createSceneManager(Ogre::ST_GENERIC);
-		_camera=_sceneManager->createCamera("Camera");
-		_camera->setPosition(Ogre::Vector3(0,0,50));
-		_camera->lookAt(Ogre::Vector3(0,0,0));
-		_camera->setNearClipDistance(5);
-		Ogre::Viewport* viewport=window->addViewport(_camera);
-		viewport->setBackgroundColour(Ogre::ColourValue(0.0,0.0,0.5));
-		_camera->setAspectRatio(Ogre::Real(viewport->getActualWidth())/Ogre::Real(viewport->getActualHeight()));
-		loadResources();
-		createScene();
-		_root->startRendering();
-		return 0;
-	}
-};
-int main(void) {
-	MyApplication app;
-	app.startup();
-	return 0;
-}
-</code>
   - **Fixed Diffuse Color Fragment Shader** The first shader program we create is a fragment shader that simply returns a fixed color for each fragment that gets processed. In Ogre you can write shader programs in any of the major high-level shading languages, but we will be using **Cg**. Create a new shader program file called ''diffuseshader.cg'' in your ''Materials'' folder and place the following code inside it:<code c>
 float4 main_orange_fp(in float3 TexelPos : TEXCOORD0) : COLOR {
@@ Line 382: / Line 289: @@
 }
 </code>Now create a new material that uses these two shader program definitions and assign the material to the ogre model. You should see a properly shaded (albeit single colored) model!
+===== Bonus =====
+<box green 100%>
+  - **Create a render texture** For many post processing and special effects shaders, we will need to capture the current scene from some angle and draw that into a texture. This is done by telling a certain camera to draw the scene from its point of view into a texture called a RenderTexture.
+      - **Create a variable in MyApplication.h:** to hold the renderTexture <code cpp>Ogre::RenderTexture*	_renderTexture;</code>
+      - **Create a member function** that assigns a camera to the render texture and initializes it. This function must accept a ''Ogre::Camera*'' to indicate what camera to draw and ''Ogre::RenderWindow*'' to get the window size. Notice the name "RttTex", this is the name we will use to address the texture in the material script. Call this function in the startup function after you create the camera. <code cpp>void MyApplication::createRenderTarget(Ogre::Camera* camera, Ogre::RenderWindow* window) {
+	Ogre::TexturePtr rtt_texture = Ogre::TextureManager::getSingleton().createManual("RttTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, window->getWidth(), window->getHeight(), 0, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET);
+	_renderTexture = rtt_texture->getBuffer()->getRenderTarget();
+	_renderTexture->addViewport(camera);
+	_renderTexture->getViewport(0)->setClearEveryFrame(true);
+	_renderTexture->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black);
+	_renderTexture->setAutoUpdated(true);
+} </code>
+      - **Now we must create a plane** So that we will be able to see the rendered texture. Add the member variable ''Ogre::Entity* _board'' and the following member function <code cpp> void MyApplication::createPlane() {
+	Ogre::ManualObject* manual = _sceneManager->createManualObject("Board");
+	manual->begin("custom/BoardRtt", Ogre::RenderOperation::OT_TRIANGLE_LIST);
+	manual->position(-6, -5, 0);
+	manual->textureCoord(0, 1);
+	manual->position(6, -5, 0);
+	manual->textureCoord(1, 1);
+	manual->position(6, 5, 0.0);
+	manual->textureCoord(1, 0);
+	manual->position(-6, 5, 0);
+	manual->textureCoord(0, 0);
+	manual->index(0);
+	manual->index(1);
+	manual->index(3);
+	manual->index(1);
+	manual->index(2);
+	manual->index(3);
+	manual->end();
+	Ogre::SceneNode* boardNode = _sceneManager->getRootSceneNode()->createChildSceneNode("Board");
+	boardNode->setPosition(3, 3, -10);
+	boardNode->attachObject(manual);
+}</code>
+      - ** Now we must create the custom/BoardRtt material script :)** We will make that a very simple material that uses fixed function vertex and fragment programs that accepts one texture. Or you can use the texture material previously made but only changing the input texture to ''texture RttTex''   <code>material custom/BoardRtt
+{
+	technique
+	{
+		pass
+		{
+                        // Leaving the vertex and fragment ref's blank,
+                        // will make Ogre use fixed function vertex and fragment programs.
+			texture_unit {
+                                // Notice: This is the name we gave in the createRenderTarget method.
+				texture RttTex
+			}
+		}
+	}
+} </code> Now build and observe.
+  - **Lets make something practical with the renderTarget. **
+      - Lets add a top down view to the scene, that will be displayed on our Board. To do that we will create another camera that we will position above and make it look down:  <code cpp>Ogre::Camera* camera2 = _sceneManager->createCamera("Camera2");
+camera2->setPosition(Ogre::Vector3(0, 100, 0));
+camera2->lookAt(Ogre::Vector3(0, 0, 5));
+camera2->setNearClipDistance(5); </code>
+      - Now make sure to send the new camera into the function that creates the rendertarget. <code cpp>createRenderTarget(camera2, window);</code> now Build and behold :)
+  - **Finally lets create some water effects** This is not an exhaustive method, but it points you in the general direction of distorting what is under water :)
+      - **Lets start by creating a plane for our water surface**, make it a bit smaller than the floor, and a few units higher. <code cpp> // Add the water surface
+Ogre::Plane waterSurface(Ogre::Vector3::UNIT_Y, -5);
+Ogre::MeshManager::getSingleton().createPlane("WaterSurface", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, waterSurface,
+, 200, 1, 1, true, 1, 5, 5, Ogre::Vector3::UNIT_Z);
+_water = _sceneManager->createEntity("WaterPlane", "WaterSurface");
+_sceneManager->getRootSceneNode()->createChildSceneNode("_water")->attachObject(_water);
+_water->getParentSceneNode()->translate(Ogre::Vector3::UNIT_Y*3);</code> Dont forget to add the member <code cpp> Ogre::Entity* _water;</code>
+      - **Water surface** If you think about a water surface, you can imagine it has no actual colour, it has generally 3 elements when looking at it with our simple goggles; reflection, some colouring of different light scattering about the water volume, and a distorted image of the bottom of the water since its mostly transparent.
+      - **For this exercise we will skip the reflection :)** lets focus on the bottom. The bottom is really just what is behind the water surface in the general view direction, but slightly distorted. So what we want to do is draw what the camera sees but exclude the water surface, and save it in a RenderTarget. To do that we send our normal camera to the createRenderTarget function, but we will need to add the following line to the function: <code cpp>_renderTexture->getViewport(0)->setVisibilityMask(0xFFFFFFF0); </code> The default visibility mask for objects is 0xFFFFFFFF... depending on the version of Ogre, you dont have to worry about that now. Now the render texture will exclude everything that has the mask 0xF or lower. So that is where we will want to place our water surface.
+      - **Exclude the water from the RenderTarget** Now we have to specify the visibility mask of our water surface: <code cpp>_water->setVisibilityFlags(0xF); </code>
+      - **Now we will have to create our own distortion shader "custom/MyWater" **:
+      - Create Two files, ''MyWater.material'' and ''distortShader.cg''
+      - In the file ''distortShader.cg'' add the following code: <code cpp>uniform sampler2D RttTex : TEXUNIT0;
+uniform sampler2D offsetMap : TEXUNIT1;
+uniform float4x4  mat_modelproj;
+uniform float myTime;
+// Vertex program input
+struct VP_input {
+    float4 pos  : POSITION;
+    float4 uv   : TEXCOORD0;
+};
+// Vertex program output / fragment program input.
+struct VP_output {
+    float4 pos      : POSITION;
+    float4 uv       : TEXCOORD0;
+    float4 uvPos    : TEXCOORD1;
+};
+VP_output main_distort_vp( VP_input p_in ) {
+    VP_output output;
+    // Transform the current vertex into projection space.
+    output.pos = mul(mat_modelproj, p_in.pos  );
+    output.uv = p_in.uv;
+    // Since the fragment shader will not be able to read the position Semantic,
+    // we must pass down the position to the fragment shader via texture coordinate.
+    // Note: In DirectX 10+ fragment shader have access to the current pixels position :)
+    output.uvPos = output.pos;
+    return output;
+}
+float4 main_distort_fp( VP_output p_in ) : COLOR {
+    // Create a variable to hold the screen space uv coordinates
+    float2 screenUV;
+    // Since  the vertex shader does the divide by w automatically,
+    // we have to do so explicitly here our selves to get the viewport coordinates.
+    screenUV = float2(p_in.uvPos.x, -p_in.uvPos.y) / p_in.uvPos.w;
+    // Viewport coordinates range from -1 to 1, so we must map them to the range 0..1 to be valid UV coordinates.
+    screenUV = ( screenUV + 1.0f ) * 0.5f;
+    // Read the current offset from the offset map.
+    float2 offset = tex2D( offsetMap, p_in.uv.xy + myTime*.01).xy ;
+    // Texture can not store negative values, so we must take our offset vectors, and map them to the correct range from (0..1) to (-1..1)
+    offset = (offset - 0.5f) * 2.0 ;
+    float4 oColor = tex2D( RttTex, screenUV.xy + offset * 0.07 ) * 0.5 ;
+    return oColor;
+} </code>
+      - And into the Material script create a material that uses these two programs: <code>vertex_program shader/waterVP cg {
+	source distortShader.cg
+	entry_point main_distort_vp
+	profiles vs_1_1 arbvp1
+	default_params {
+		param_named_auto mat_modelproj worldviewproj_matrix
+	}
+}
+fragment_program shader/waterFP cg {
+	source distortShader.cg
+	entry_point main_distort_fp
+	profiles ps_2_0 arbfp1
+	default_params {
+		param_named_auto myTime time 1
+	}
+}
+material custom/MyWater {
+	technique {
+		pass {
+			vertex_program_ref shader/waterVP {
+			}
+			fragment_program_ref shader/waterFP {
+			}
+			texture_unit 0 {
+				tex_address_mode mirror
+				texture RttTex
+			}
+			texture_unit 1 {
+				tex_address_mode mirror
+				texture offsetMap.png
+			}
+		}
+	}
+} </code>
+      - **Then finally we will need to put that material on the water surface** and download the {{:public:t-gede-14-1:offsetmap.png?linkonly|offsetTexture}} <code cpp>_water->setMaterialName("custom/MyWater");
+ </code>
+</box>
 ===== When You Are Finished =====
-Upload your **commented source files** into Lab6 in MySchool (zip them up if more than one). The lab projects will not be graded, but their completion counts towards your participation grade.
+Upload your **commented source files** into Lab7 in MySchool along with your Material and shader programs. (zip them up if more than one). The lab projects will not be graded, but their completion counts towards your participation grade.