SO3DeferredCompositorDebug.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/SO3DeferredCompositorDebug.h"
#include "SO3Utils/SO3Exception.h"
 
namespace SO3
{
 
SDeferredCompositorDebug::SDeferredCompositorDebug(std::string compositorName) : SDeferredCompositor(compositorName)
{
}
 
SDeferredCompositorDebug::SDeferredCompositorDebug() : SDeferredCompositor("")
{
  // Forbiden ctor
}
 
Ogre::CompositorPtr SDeferredCompositorDebug::GenerateCompositor(SGBuffer* gBuffer)
{
  Ogre::String compoName = "SO3/Deferred/Compositor/"+ name +"/"+ gBuffer->GetName();
 
  // Create compo
  Ogre::CompositorPtr compositor = Ogre::CompositorManager::getSingleton().create(compoName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
  // Create the technique
  Ogre::CompositionTechnique* compositionTechnique = compositor->createTechnique();
 
  // Reference to gbuffer texture
  Ogre::CompositionTechnique::TextureDefinition* gBufferTexture = compositionTechnique->createTextureDefinition("mrt_output");
  gBufferTexture->refCompName = "SO3/Deferred/Compositor/GBuffer/" + gBuffer->GetName();
  gBufferTexture->refTexName = "mrt_output";
 
  // Get the output target
  Ogre::CompositionTargetPass* compositionTargetPass = compositionTechnique->getOutputTargetPass();
  compositionTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_NONE);
 
  // Create a pass on the target
  Ogre::CompositionPass* compositionPass = compositionTargetPass->createPass();
  compositionPass->setType(Ogre::CompositionPass::PT_RENDERQUAD);
 
  // Set the material to use, ie, the effect to apply
  compositionPass->setMaterial(GenerateCompositorMaterial(gBuffer));
 
  // Set the input render targets
  unsigned int numberMrt = gBuffer->GetNumberMrt();
  for(unsigned int i = 0; i<numberMrt; i++)
    compositionPass->setInput(i, "mrt_output", i);
 
  // Compositor is created!
  return compositor;
}
 
Ogre::MaterialPtr SDeferredCompositorDebug::GenerateCompositorMaterial(SGBuffer* gBuffer)
{
  Ogre::String matName = "SO3/Deferred/Compositor/Material/"+ name +"/"+ gBuffer->GetName();
 
  // Material
  Ogre::MaterialPtr matPtr = Ogre::MaterialManager::getSingleton().create(matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
  Ogre::Pass* pass = matPtr->getTechnique(0)->getPass(0);
  pass->setCullingMode(Ogre::CULL_NONE);
  pass->setManualCullingMode(Ogre::MANUAL_CULL_NONE);
  pass->setDepthFunction(Ogre::CMPF_ALWAYS_PASS);
 
  // Shaders
  pass->setVertexProgram(GenerateCompositorVertexShader(gBuffer)->getName());
  pass->setFragmentProgram(GenerateCompositorPixelShader(gBuffer)->getName());
 
  // TU
  unsigned int numberOfMrt = gBuffer->GetNumberMrt();
  for (Ogre::uint32 i=0; i<numberOfMrt; i++)
  {
    Ogre::TextureUnitState* tu = pass->createTextureUnitState();
    tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
    tu->setTextureFiltering(Ogre::TFO_NONE);
    tu->setTextureCoordSet(i);
  }
 
  return matPtr;
}
 
Ogre::GpuProgramPtr SDeferredCompositorDebug::GenerateCompositorVertexShader(SGBuffer* gBuffer)
{
  Ogre::StringStream ss;
 
  // Post shader: Generic fullscreen quad
  ss << "void main(float4 Pos: POSITION," << std::endl;
  ss << "          out float4 oPos: POSITION," << std::endl;
  ss << "          out float2 oTexCoord: TEXCOORD0," << std::endl;
  ss << "          out float3 oRay : TEXCOORD1," << std::endl;
  ss << "          uniform float3 farCorner," << std::endl;
  ss << "          uniform float flip)" << std::endl;
  ss << "{" << std::endl;
  
  // Clean up inaccuracies
  ss << "  Pos.xy = sign(Pos.xy);" << std::endl;
 
  // DirectX / OpenGL view transformation
  ss << "  oPos = float4(Pos.xy, 0, 1);" << std::endl;
  ss << "  oPos.y *= flip;" << std::endl;
 
  // Image-space
  ss << "  oTexCoord.x = 0.5 * (1 + Pos.x); // bound [0:1]" << std::endl;
  ss << "  oTexCoord.y = 0.5 * (1 - Pos.y); // bound [1:0]" << std::endl;
 
  // This ray will be interpolated and will be the ray from the camera to the far clip plane, per pixel
  ss << "  oRay = farCorner * float3(Pos.xy, 1);" << std::endl;
  ss << "}" << std::endl;
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = "SO3/Deferred/Compositor/shader/"+ name +"/"+ gBuffer->GetName() +"_vs";
 
#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", "main");
  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("flip"))
    params->setNamedAutoConstant("flip", Ogre::GpuProgramParameters::ACT_RENDER_TARGET_FLIPPING);
 
  if (params->_findNamedConstantDefinition("farCorner"))
    params->setNamedConstant("farCorner", Ogre::Vector3::UNIT_SCALE);
 
  ptrProgram->load();
 
  // Return compositor vertex shader
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
Ogre::GpuProgramPtr SDeferredCompositorDebug::GenerateCompositorPixelShader(SGBuffer* gBuffer)
{
  Ogre::StringStream ss;
 
  // Structures defines
  ss << gBuffer->GenerateGBufferCompositorPixelInputStructure();
 
  // Compositors commons parameters
  ss << "float4 main(float2 texCoord: TEXCOORD0," << std::endl;
        ss << "            float2 projCoord: TEXCOORD1," << std::endl;
 
  // Input parameters (list of mrts)
  ss << "            " << gBuffer->GetGBufferCompositorPixelInputStructureTypeName() << " gBuffer" << std::endl;
  ss << "            ) : COLOR" << std::endl;
 
  // Shader implementation
  ss << "{" << std::endl;
  ss << GenerateCompositorPixelShaderImpl();
  ss << "}" << std::endl;
 
  // Prepare shader generation
  Ogre::String programSource = ss.str();
  Ogre::String programName = "SO3/Deferred/Compositor/shader/"+ name +"/"+ gBuffer->GetName() +"_ps";
 
#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", "main");
  ptrProgram->setParameter("profiles", "ps_2_0 arbfp1");
  ptrProgram->load();
 
  // Return compositor pixel shader
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
}