SO3DeferredCompositorAA.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/SO3DeferredCompositorAA.h"
#include "SO3Utils/SO3Exception.h"
 
namespace SO3
{
 
SDeferredCompositorAA::SDeferredCompositorAA(std::string compositorName) : SDeferredCompositor(compositorName)
{
}
 
SDeferredCompositorAA::SDeferredCompositorAA() : SDeferredCompositor("")
{
  // Forbiden ctor
}
 
Ogre::CompositorPtr SDeferredCompositorAA::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();
 
  // Create a "scene" texture
  Ogre::CompositionTechnique::TextureDefinition* sceneTexture = compositionTechnique->createTextureDefinition("scene");
  sceneTexture->width = 0;
  sceneTexture->height = 0;
  Ogre::PixelFormatList pixelFormat;
  pixelFormat.push_back(Ogre::PF_R8G8B8A8);
  sceneTexture->formatList = pixelFormat;
 
  // Render scene to "scene" texture
  Ogre::CompositionTargetPass* sceneTargetPass = compositionTechnique->createTargetPass();
  sceneTargetPass->setInputMode(Ogre::CompositionTargetPass::IM_PREVIOUS);
  sceneTargetPass->setOutputName("scene");
 
  // 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 scene texture
  compositionPass->setInput(0, "scene");
 
  // Compositor is created!
  return compositor;
}
 
Ogre::MaterialPtr SDeferredCompositorAA::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
  Ogre::TextureUnitState* tu = pass->createTextureUnitState();
  tu->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
  tu->setTextureFiltering(Ogre::TFO_TRILINEAR);
  tu->setTextureCoordSet(0);
 
  return matPtr;
}
 
Ogre::GpuProgramPtr SDeferredCompositorAA::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 << "          uniform float flip)" << std::endl;
  ss << "{" << std::endl;
  
  // Clean up inaccuracies
  ss << "  Pos.xy = sign(Pos.xy);" << std::endl;
 
  // DirectX / OpenGL view transformation
  //uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
  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;
  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);
  ptrProgram->load();
 
  // Return compositor vertex shader
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
Ogre::GpuProgramPtr SDeferredCompositorAA::GenerateCompositorPixelShader(SGBuffer* gBuffer)
{
  Ogre::StringStream ss;
 
  // Structures defines
  ss << gBuffer->GenerateGBufferCompositorPixelInputStructure();
 
  // Compositors commons parameters
  ss << "float4 main(float2 texCoord: TEXCOORD0," << std::endl;
  ss << "            uniform float4 screenSize," << std::endl;
  // Input parameters (rendered scene)
  ss << "            sampler scene : register(s0)" << 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");
 
  // Bind our function parameters to Ogre's related values.
  const Ogre::GpuProgramParametersSharedPtr& params = ptrProgram->getDefaultParameters();
  if (params->_findNamedConstantDefinition("screenSize"))
    params->setNamedAutoConstant("screenSize", Ogre::GpuProgramParameters::ACT_INVERSE_TEXTURE_SIZE);
 
  ptrProgram->load();
 
  // Return compositor pixel shader
  return Ogre::GpuProgramPtr(ptrProgram);
}
 
}