This lab is based on a variety of sources, including the Ogre Shaders Wiki.

Discussion thread for this lab is here: Lab 6 Discussion Thread

The goal of this lab is to understand how you can upload and execute simple shader programs on the GPU. Those programs will be associated with Ogre materials that you can assign to objects in a scene.

From previous labs you should already have a Models folder inside the folder where you keep your application executables. To continue to organize your resources properly, you should now create another folder to hold your custom materials. Call this folder Materials and put it next to your models folder. In order for your Ogre applications to find the contents of these two folders make sure the following lines are in your resources_d.cfg:

FileSystem=Models
FileSystem=Materials

From now on we assume that all your custom materials and shader programs are stored in the Materials folder.

Follow these steps to complete the lab project:

1. 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:

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

2. 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:

   float4 main_orange_fp(in float3 TexelPos : TEXCOORD0) : COLOR {
       float4 oColor;
    
       oColor.r = 1.0;
       oColor.g = 0.8;
       oColor.b = 0.0;
       oColor.a = 0.0;
    
       return oColor;
   }

   Now that the shader program is ready, you have to instantiate it inside a material before you can apply it to objects in Ogre. Create a new material file called myshaders.material in the same folder and place the following material script inside it:

   fragment_program shader/orangeFP cg {
       source diffuseshader.cg
       entry_point main_orange_fp
       profiles ps_1_1 arbfp1 
       
   }
   
   material shader/orange {
       technique {
           pass {           
               fragment_program_ref shader/orangeFP {
               }       
               texture_unit {       
               }             
           }
       }
   }

   Essentially the new material shader/orange calls the shader/orangeFP program definition, which in turn calls the main_orange_fp method inside diffuseshader.cg. Since this is a fragment program, it gets called for every fragment processed with this material. Finally, you simply assign this material to the entities in your Ogre application:

   _ogre->setMaterialName("shader/orange");
   _ground->setMaterialName("shader/orange"); 

   Verify that both your ground and your ogre model show up orange on the screen.

3. Parametric Diffuse Color Fragment ShaderYou can use the same shader program in many materials and simply let each material pass a parameter into the program to tell it how to paint a given surface. This makes more sense than writing a new shader program every time you want to paint an object in a different color for example. You can pass parameters into Cg shader programs through the so called uniform parameter. In the diffuseshader.cg file, add the following new shader program:

   float4 main_color_fp(in float3 TexelPos : TEXCOORD0, uniform float4 color) : COLOR {
       float4 oColor = color;
       return oColor;
   }

   This fragment shader expects a new parameter called color, and assigns that value to the color returned for this fragment. In the same material file as before, you now add the following shader program definition and material script:

   fragment_program shader/diffuseFP cg {
       source diffuseshader.cg
       entry_point main_color_fp
       profiles ps_1_1 arbfp1 
    
       default_params {
           param_named color float4 0.7 0.2 0.2 1.0
       }
   } 
    
   material shader/white {
       technique {
           pass {             
               fragment_program_ref shader/diffuseFP {
                   param_named color float4 0.8 0.8 0.8 1.0
               }    
               texture_unit {       
               }                      
           }
       }
   }

   Here you have created a new material shader/white that passes the color value <0.8,0.8,0.8,1.0> into the shader program called by the shader/diffuseFP program definition. Notice that if you skip specifying the color value in the material script, the program definition will pass its own default value into the shader program (in this case <0.7,0.2,0.2,1.0>). Now use this material for your ogre model:

   _ogre->setMaterialName("shader/white");

   You can of course create several new materials now, each with a different color!

4. Custom Diffuse Color Fragment Shader You may also want to control some parameter in a shader program from within the application code. To do this, you indicate that a shader program parameter should be a custom parameter. You do not have to change your diffuse fragment shader program to do this (it is already expecting an external color parameter), but you need to create a new shader program definition and a new material in the materials file to do this:

   fragment_program shader/customFP cg {
       source diffuseshader.cg
       entry_point main_color_fp
       profiles ps_1_1 arbfp1 
       
       default_params {
           param_named_auto color custom 1
       }
   }
   
   material shader/custom {
       technique {
           pass {             
               fragment_program_ref shader/diffuseFP {
                   param_named_auto color custom 1
               }          
               texture_unit {       
               }                     
           }
       }
   }

   You are with this essentially telling Ogre that if this material is associated with an object, it should look for a custom parameter in an object's custom parameter slot number 1 and pass that on to the fragment program. So, when you assign this material to entities in an Ogre application, you have to remember to add this custom parameter as well. This is how you do that (setCustomParameter takes the parameter slot number as the first argument):

   _ogre->getSubEntity(0)->setCustomParameter(1, Ogre::Vector4(0.0, 0.0, 1.0, 1.0));
   _ogre->setMaterialName("shader/custom");

   You should now have a blue ogre model.

5. Texture Vertex and Fragment Shaders
6. Animated Vertex Shader
7. Per Pixel Phong Shader

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.