SO3DeferredLightMaterialGenerator.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Renderer/DeferredShading/SO3DeferredLightMaterialGenerator.h"
 
namespace SO3
{
 
SDeferredLightMaterialGenerator::SDeferredLightMaterialGenerator(const Ogre::String& typeName) : SMaterialGenerator<SDeferredLightPermutation, Ogre::uint32>(Ogre::String("Lights/") + typeName)
{
  debugVertexProgram = GenerateDebugVertexShader();
  debugFragmentProgram = GenerateDebugFragmentShader();
}
 
SDeferredLightMaterialGenerator::SDeferredLightMaterialGenerator() : SMaterialGenerator<SDeferredLightPermutation, Ogre::uint32>("")
{
}
 
SDeferredLightMaterialGenerator::~SDeferredLightMaterialGenerator()
{
}
 
Ogre::MaterialPtr SDeferredLightMaterialGenerator::GenerateTemplateMaterial(SGBuffer* gbuffer, Ogre::uint32 permutationValue)
{
  Ogre::String matName = materialBaseName + Ogre::StringConverter::toString(permutationValue);
 
  // Create a new material
  Ogre::MaterialPtr matPtr = Ogre::MaterialManager::getSingleton().create(matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
  matPtr->getTechnique(0)->setName("DeferredTechnique");
  Ogre::Pass* pass = matPtr->getTechnique(0)->getPass(0);
  pass->setName("DeferredPass");
  pass->setLightingEnabled(false);
  pass->setDepthWriteEnabled(false);
  pass->setDepthCheckEnabled(true);
 
  unsigned int numberMrt = gbuffer->GetNumberMrt();
  for (unsigned int i=0; i<numberMrt; i++)
  {
    Ogre::TextureUnitState* tu = pass->createTextureUnitState();
    tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    tu->setTextureFiltering(Ogre::TFO_NONE);
    tu->setContentType(Ogre::TextureUnitState::CONTENT_COMPOSITOR);
    tu->setCompositorReference("SO3/Deferred/Compositor/GBuffer/"+ gbuffer->GetName() , "mrt_output", i);
  }
 
  // Shadows
  if(permutationValue & SDeferredLightPermutation::SO3_LP_CAST_SHADOWS)
  {
    Ogre::TextureUnitState* tu = pass->createTextureUnitState();
    tu->setName("ShadowMap");
    tu->setContentType(Ogre::TextureUnitState::CONTENT_SHADOW);
  }
 
  // Debug pass
  if(permutationValue & SDeferredLightPermutation::SO3_LP_DEBUG)
  {
    pass = matPtr->getTechnique(0)->createPass();
    pass->setName("DeferredDebugPass");
    pass->setPolygonMode(Ogre::PM_WIREFRAME);
    /*pass->setCullingMode(Ogre::CULL_NONE);
    pass->setManualCullingMode(Ogre::MANUAL_CULL_NONE);*/
 
    pass->setVertexProgram(debugVertexProgram->getName());
    pass->setFragmentProgram(debugFragmentProgram->getName());
  }
 
  return matPtr;
}
 
Ogre::GpuProgramPtr SDeferredLightMaterialGenerator::GenerateDebugVertexShader()
{
  Ogre::StringStream ss;
 
  ss << "float4 SO3_DeferredLightDebug_vs(float4 pos: POSITION," << std::endl;
  ss << "                                      uniform float4x4 wvp) : POSITION" << std::endl;
  ss << "{" << std::endl;
  ss << "       return mul(wvp, pos);" << std::endl;
  ss << "}" << std::endl;
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = materialBaseName +"Shaders/Vertex/Debug";
 
#if SO3_DEBUG
  // Show the generated vertex program in the log.
  //Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource, Ogre::LML_CRITICAL);
#endif
 
  // Create shader object
  // TODO in another group than Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME?
  Ogre::HighLevelGpuProgramPtr ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", Ogre::GPT_VERTEX_PROGRAM);
  ptrProgram->setSource(programSource);
  ptrProgram->setParameter("entry_point", "SO3_DeferredLightDebug_vs");
  ptrProgram->setParameter("profiles", "vs_1_1 arbvp1");
 
  // Bind our function parameters to Ogre's related values.
  const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
  if (params->_findNamedConstantDefinition("wvp"))
    params->setNamedAutoConstant("wvp", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
 
  // Return light vertex shader
  ptrProgram->load();
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
Ogre::GpuProgramPtr SDeferredLightMaterialGenerator::GenerateDebugFragmentShader()
{
  Ogre::StringStream ss;
 
  ss << "float4 SO3_DeferredLightDebug_ps(uniform float4 debugColor) : COLOR" << std::endl;
  ss << "{" << std::endl;
  ss << "       return float4(debugColor);" << std::endl;
  ss << "}" << std::endl;
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = materialBaseName +"Shaders/Pixel/Debug/";
 
#if SO3_DEBUG
  // Show the generated vertex program in the log.
  //Ogre::LogManager::getSingleton().getDefaultLog()->logMessage(programSource, Ogre::LML_CRITICAL);
#endif
 
  // Create shader object
  // TODO in another group than Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME?
  Ogre::HighLevelGpuProgramPtr ptrProgram = Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(programName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "cg", Ogre::GPT_FRAGMENT_PROGRAM);
  ptrProgram->setSource(programSource);
  ptrProgram->setParameter("entry_point", "SO3_DeferredLightDebug_ps");
  ptrProgram->setParameter("profiles", "ps_4_0 ps_2_x arbfp1");
 
  // Bind our function parameters to Ogre's related values.
  const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
  if (params->_findNamedConstantDefinition("debugColor"))
    params->setNamedConstant("debugColor", Ogre::ColourValue(1, 0, 0, 1));
 
  // Return compositor pixel shader
  ptrProgram->load();
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
}