ogre_material_generator.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <rve_render_server/ogre_material_generator.h>
#include <rve_render_server/material.h>
#include <rve_render_server/texture.h>
#include <rve_render_server/render_target.h>
#include <rve_render_server/render_texture.h>
#include <rve_render_server/renderer.h>
#include <rve_render_server/texture_resource.h>
#include <rve_msgs/Material.h>

#include <rve_common/parse_resource_uri.h>

#include <resource_retriever/retriever.h>
#include <boost/filesystem.hpp>

#include <sstream>

#include <OGRE/OgreMaterialManager.h>
#include <OGRE/OgreTextureManager.h>
#include <OGRE/OgreTexture.h>
#include <OGRE/OgreGpuProgramManager.h>
#include <OGRE/OgreHighLevelGpuProgramManager.h>
#include <OGRE/OgreTechnique.h>
#include <OGRE/OgrePass.h>

namespace fs = boost::filesystem;

namespace rve_render_server
{

void loadTexture(const std::string& resource_path)
{
  if (!Ogre::TextureManager::getSingleton().resourceExists(resource_path))
  {
    resource_retriever::Retriever retriever;
    resource_retriever::MemoryResource res;
    try
    {
      res = retriever.get(resource_path);
    }
    catch (resource_retriever::Exception& e)
    {
      ROS_ERROR("%s", e.what());
    }

    if (res.size != 0)
    {
      Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(res.data.get(), res.size));
      Ogre::Image image;
      std::string extension = fs::extension(fs::path(resource_path));

      if (extension[0] == '.')
      {
        extension = extension.substr(1, extension.size() - 1);
      }

      try
      {
        image.load(stream, extension);
        Ogre::TextureManager::getSingleton().loadImage(resource_path, ROS_PACKAGE_NAME, image);
      }
      catch (Ogre::Exception& e)
      {
        ROS_ERROR("Could not load texture [%s]: %s", resource_path.c_str(), e.what());
      }
    }
  }
}

void applyUniforms(const Ogre::HighLevelGpuProgramPtr& program, const V_ShaderUniform& uniforms)
{
  const Ogre::GpuProgramParametersSharedPtr& params = program->getDefaultParameters();
  V_ShaderUniform::const_iterator it = uniforms.begin();
  V_ShaderUniform::const_iterator end = uniforms.end();
  for (; it != end; ++it)
  {
    const ShaderUniform& uniform = *it;
    try
    {
      params->setNamedAutoConstant(uniform.name, (Ogre::GpuProgramParameters::AutoConstantType)uniform.auto_constant_type, uniform.extra);
    }
    catch (Ogre::Exception& e)
    {
      ROS_DEBUG("%s", e.what());
    }
  }

  try
  {
    params->setNamedAutoConstant("worldviewproj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
  }
  catch (Ogre::Exception&)
  {}

  try
  {
    params->setNamedAutoConstant("worldview", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX);
  }
  catch (Ogre::Exception&)
  {}
}

static void emitInputs(std::stringstream& ss, const V_ShaderParameter& inputs, bool& first_parameter, bool geom_shader)
{
  V_ShaderParameter::const_iterator it = inputs.begin();
  V_ShaderParameter::const_iterator end = inputs.end();
  for (; it != end; ++it)
  {
    const ShaderParameter& param = *it;
    if (!first_parameter)
    {
      ss << " ,";
    }

    first_parameter = false;
    if (geom_shader)
    {
      ss << " AttribArray<" << param.type << "> in_" << param.name << " : " << param.semantic << std::endl;
    }
    else
    {
      ss << " " << param.type << " in_" << param.name << " : " << param.semantic << std::endl;
    }
  }
}

static void emitOutputs(std::stringstream& ss, const V_ShaderParameter& outputs, bool& first_parameter)
{
  V_ShaderParameter::const_iterator it = outputs.begin();
  V_ShaderParameter::const_iterator end = outputs.end();
  for (; it != end; ++it)
  {
    const ShaderParameter& param = *it;

    if (!first_parameter)
    {
      ss << " ,";
    }

    first_parameter = false;

    ss << " out " << param.type << " out_" << param.name << " : " << param.semantic << std::endl;
  }
}

static void emitUniforms(std::stringstream& ss, const V_ShaderUniform& uniforms, bool& first_parameter)
{
  V_ShaderUniform::const_iterator it = uniforms.begin();
  V_ShaderUniform::const_iterator end = uniforms.end();
  for (; it != end; ++it)
  {
    const ShaderUniform& uniform = *it;

    if (!first_parameter)
    {
      ss << " ,";
    }

    first_parameter = false;

    ss << " uniform " << uniform.type << " " << uniform.name << std::endl;
  }
}

static void emitSamplers(std::stringstream& ss, const V_ShaderSampler& samplers, bool& first_parameter)
{
  V_ShaderSampler::const_iterator it = samplers.begin();
  V_ShaderSampler::const_iterator end = samplers.end();
  for (; it != end; ++it)
  {
    const ShaderSampler& samp = *it;

    if (!first_parameter)
    {
      ss << " ,";
    }

    first_parameter = false;

    ss << " uniform sampler sampler_" << samp.name << " : register(s" << samp.reg << ")" << std::endl;
  }
}

static void emitIncludes(std::stringstream& ss, const V_string& includes)
{
  V_string::const_iterator it = includes.begin();
  V_string::const_iterator end = includes.end();
  for (; it != end; ++it)
  {
    ss << "#include \"" << *it << "\"" << std::endl;
  }
}

Ogre::GpuProgramPtr generateVertexShader(const ShaderDefinition& def, const std::string& base_name)
{
  std::stringstream ss;

  emitIncludes(ss, def.includes);
  ss << std::endl;
  ss << "void vp(" << std::endl;
  bool first_parameter = true;
  emitInputs(ss, def.inputs, first_parameter, false);
  emitOutputs(ss, def.outputs, first_parameter);
  emitUniforms(ss, def.uniforms, first_parameter);
  emitSamplers(ss, def.samplers, first_parameter);

  ss << ")\n";
  ss << "{\n";

  ss << def.body;
  ss << "\n";

  ss << "}" << std::endl;

  std::string program_source = ss.str();
  std::string program_name = base_name + "_VP";

  ROS_DEBUG("%s", program_source.c_str());

  // Create shader object
  Ogre::HighLevelGpuProgramPtr program =
      Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(program_name, ROS_PACKAGE_NAME, "cg",
                                                                     Ogre::GPT_VERTEX_PROGRAM);
  program->setSource(program_source);
  program->setParameter("entry_point", "vp");
  program->setParameter("profiles", "vs_1_1 arbvp1");

  applyUniforms(program, def.uniforms);

  program->load();

  return Ogre::GpuProgramPtr(program);
}

Ogre::GpuProgramPtr generateFragmentShader(const ShaderDefinition& in_def, bool transparent, bool shaded, const std::string& base_name)
{
  ShaderDefinition def = in_def;
  std::stringstream ss;

  if (transparent)
  {
    def.include("camera_light.cg");
  }

  def.output("float4", "color0", "COLOR0");
  def.output("float4", "color1", "COLOR1");
  def.uniform("float", "far_distance", Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE);

  emitIncludes(ss, def.includes);
  ss << std::endl;
  ss << "void fp(" << std::endl;
  bool first_parameter = true;
  emitInputs(ss, def.inputs, first_parameter, false);
  emitOutputs(ss, def.outputs, first_parameter);
  emitUniforms(ss, def.uniforms, first_parameter);
  emitSamplers(ss, def.samplers, first_parameter);

  ss << " )\n";
  ss << "{\n";

  ss << def.body;
  ss << "\n";

  if (transparent)
  {
    if (shaded)
    {
      ss << "float3 gooch_color = camera_light(color.rgb, normal, float3(0.0, 0.0, 1.0));\n";
      ss << "out_color0 = float4(gooch_color * color.a, color.a);\n";
    }
    else
    {
      ss << "out_color0 = float4(color.rgb * color.a, color.a);";
    }

    ss << "out_color1 = float4(1.0, 0.0, 0.0, 0.0);\n";
  }
  else
  {
    ss << " out_color0 = float4(color.rgb, 1.0);\n";
    if (!shaded)
    {
      ss << " out_color0.a = 0.0;";
    }

    //ss << " out_color0 = float4(in_uv0, 0.0, 1.0);\n";
    ss << " out_color1.rgb = normal;\n";
    ss << " out_color1.a = length(in_view_pos) / far_distance;\n";
  }

  ss << "}" << std::endl;

  std::string program_source = ss.str();
  std::string program_name = base_name + "_FP";

  ROS_DEBUG("%s", program_source.c_str());

  // Create shader object
  Ogre::HighLevelGpuProgramPtr program =
      Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(program_name, ROS_PACKAGE_NAME, "cg",
                                                                     Ogre::GPT_FRAGMENT_PROGRAM);
  program->setSource(program_source);
  program->setParameter("entry_point", "fp");
  program->setParameter("profiles", "ps_2_0 arbfp1");

  applyUniforms(program, def.uniforms);

  program->load();

  return Ogre::GpuProgramPtr(program);
}

Ogre::GpuProgramPtr generatePickingFragmentShader(const ShaderDefinition& in_def, const std::string& base_name)
{
  ShaderDefinition def = in_def;
  std::stringstream ss;

  def.output("float4", "object_id", "COLOR0");
  def.output("float4", "object_extra", "COLOR1");

  emitIncludes(ss, def.includes);
  ss << std::endl;
  ss << "void fp(" << std::endl;
  bool first_parameter = true;
  emitInputs(ss, def.inputs, first_parameter, false);
  emitOutputs(ss, def.outputs, first_parameter);
  emitUniforms(ss, def.uniforms, first_parameter);
  emitSamplers(ss, def.samplers, first_parameter);

  ss << " )\n";
  ss << "{\n";

  if (!def.body.empty())
  {
    ss << def.body;
    ss << "\n";
  }
  else
  {
    ss << " float4 object_id = float4(0.0, 0.0, 0.0, 0.0);\n";
    ss << " float4 object_extra = float4(0.0, 0.0, 0.0, 0.0);\n";
  }

  ss << " out_object_id = object_id;\n";
  ss << " out_object_extra = object_extra;\n";

  ss << "}" << std::endl;

  std::string program_source = ss.str();
  std::string program_name = base_name + "_FP_Pick";

  ROS_DEBUG("%s", program_source.c_str());

  // Create shader object
  Ogre::HighLevelGpuProgramPtr program =
      Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(program_name, ROS_PACKAGE_NAME, "cg",
                                                                     Ogre::GPT_FRAGMENT_PROGRAM);
  program->setSource(program_source);
  program->setParameter("entry_point", "fp");
  program->setParameter("profiles", "ps_2_0 arbfp1");

  applyUniforms(program, def.uniforms);

  program->load();

  return Ogre::GpuProgramPtr(program);
}

Ogre::GpuProgramPtr generateGeometryShader(const ShaderDefinition& def, const std::string& base_name)
{
  std::stringstream ss;

  emitIncludes(ss, def.includes);
  ss << std::endl;
  ss << def.geom_input << " " << def.geom_output << " void gp(" << std::endl;
  bool first_parameter = true;
  emitInputs(ss, def.inputs, first_parameter, true);
  emitUniforms(ss, def.uniforms, first_parameter);
  emitSamplers(ss, def.samplers, first_parameter);

  ss << ")\n";
  ss << "{\n";

  ss << def.body;
  ss << "\n";

  ss << "}" << std::endl;

  std::string program_source = ss.str();
  std::string program_name = base_name + "_GP";

  ROS_DEBUG("%s", program_source.c_str());

  // Create shader object
  Ogre::HighLevelGpuProgramPtr program =
      Ogre::HighLevelGpuProgramManager::getSingleton().createProgram(program_name, ROS_PACKAGE_NAME, "cg",
                                                                     Ogre::GPT_GEOMETRY_PROGRAM);
  program->setSource(program_source);
  program->setParameter("entry_point", "gp");
  program->setParameter("profiles", "gpu_gp gp4_gp");

  applyUniforms(program, def.uniforms);

  program->load();

  return Ogre::GpuProgramPtr(program);
}

Ogre::MaterialPtr generateOgreMaterial(const MaterialDefinition& def)
{
  if (Ogre::MaterialManager::getSingleton().resourceExists(def.name))
  {
    return Ogre::MaterialManager::getSingleton().getByName(def.name);
  }

  Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(def.name, ROS_PACKAGE_NAME);

  if (def.transparent)
  {
    mat->getTechnique(0)->setSchemeName("WeightedAverageAlpha");
    mat->setSceneBlending(Ogre::SBT_ADD);
    mat->setDepthWriteEnabled(false);
  }
  else
  {
    mat->getTechnique(0)->setSchemeName("GBuffer");
  }

  Ogre::Pass* pass = mat->getTechnique(0)->getPass(0);
  pass->setLightingEnabled(false);

  V_string::const_iterator it = def.textures.begin();
  V_string::const_iterator end = def.textures.end();
  for (; it != end; ++it)
  {
    const std::string& tex_path = *it;
    Ogre::TextureUnitState* tu = pass->createTextureUnitState();

    std::string tex_name = tex_path;

    if (!lookupTextureResource(tex_path, tex_name))
    {
      loadTexture(tex_path);
    }

    tu->setTextureName(tex_name);
  }

  Ogre::GpuProgramPtr vertex_program = generateVertexShader(def.vertex_def, def.name);
  Ogre::GpuProgramPtr fragment_program = generateFragmentShader(def.fragment_def, def.transparent, !def.disable_shading, def.name);
  pass->setVertexProgram(vertex_program->getName());
  pass->setFragmentProgram(fragment_program->getName());

  Ogre::GpuProgramPtr geometry_program;
  if (def.has_geometry_shader)
  {
    geometry_program = generateGeometryShader(def.geometry_def, def.name);
    pass->setGeometryProgram(geometry_program->getName());
  }

  {
    // Generate the picking technique
    Ogre::GpuProgramPtr picking_fragment_program = generatePickingFragmentShader(def.picking_fragment_def, def.name);
    Ogre::Technique* tech = mat->createTechnique();
    tech->setSchemeName("Pick");
    Ogre::Pass* pass = tech->createPass();
    pass->setVertexProgram(vertex_program->getName());
    pass->setFragmentProgram(picking_fragment_program->getName());

    if (!geometry_program.isNull())
    {
      pass->setGeometryProgram(geometry_program->getName());
    }

    pass->setLightingEnabled(false);
  }

  Ogre::CullingMode cull_mode;
  switch (def.cull_mode)
  {
    case rve_msgs::Material::CULL_COUNTERCLOCKWISE:
      cull_mode = Ogre::CULL_ANTICLOCKWISE;
      break;
    case rve_msgs::Material::CULL_CLOCKWISE:
      cull_mode = Ogre::CULL_CLOCKWISE;
      break;
    default:
      cull_mode = Ogre::CULL_NONE;
  }
  mat->setCullingMode(cull_mode);

  return mat;
}

// rve_msgs::Material version

std::string materialToStringID(const rve_msgs::Material& input_mat)
{
  std::stringstream ss;
  ss << "Gen_";

  if (input_mat.has_color)
  {
    ss << "Color";
  }

  if (input_mat.has_texture)
  {
    ss << "Texture_" << input_mat.texture;
  }

  if (input_mat.has_normal_map)
  {
    ss << "NormalMap_" << input_mat.normal_map;
  }

  bool transparent = input_mat.opacity < 0.99;
  if (transparent)
  {
    ss << "Alpha";
  }

  return ss.str();
}

static std::string toString(uint32_t i)
{
  std::stringstream ss;
  ss << i;
  return ss.str();
}

void fillVertexShaderDefinition(const rve_msgs::Material& input_mat, ShaderDefinition& def)
{
  def.input("float4", "position", "POSITION");
  def.input("float3", "normal", "NORMAL");

  uint32_t num_tex_coords = input_mat.has_texture ? 1 : 0;
  uint32_t tex_coord_num = 2;
  for (uint32_t i = 0; i < num_tex_coords; i++)
  {
    def.input("float2", "uv" + toString(i), "TEXCOORD" + toString(i));
    def.output("float2", "uv" + toString(i), "TEXCOORD" + toString(tex_coord_num));
    ++tex_coord_num;
  }

  if (input_mat.has_normal_map)
  {
    def.input("float3", "tangent", "TANGENT0");
  }

  def.output("float4", "position", "POSITION");
  def.output("float3", "view_pos", "TEXCOORD0");
  def.output("float3", "normal", "TEXCOORD1");

  if (input_mat.has_normal_map)
  {
    def.output("float3", "tangent", "TEXCOORD" + toString(tex_coord_num++));
    def.output("float3", "binormal", "TEXCOORD" + toString(tex_coord_num++));
  }

  def.uniform("float4x4", "worldviewproj", Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX, 0);
  def.uniform("float4x4", "worldview", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX, 0);

  std::stringstream ss;
  ss << " out_position = mul(worldviewproj, in_position);" << std::endl;
  ss << " out_normal = mul(worldview, float4(in_normal,0)).xyz;" << std::endl;

  ss << " out_view_pos = mul(worldview, in_position).xyz;" << std::endl;

  if (input_mat.has_normal_map)
  {
    ss << " out_tangent = mul(worldview, float4(in_tangent, 0)).xyz;" << std::endl;
    ss << " out_binormal = cross(out_normal, out_tangent);" << std::endl;
  }

  for (uint32_t i = 0; i < num_tex_coords; i++)
  {
    ss << " out_uv" << i << " = in_uv" << i << ';' << std::endl;
  }

  def.body = ss.str();
}

void fillFragmentShaderDefinition(const rve_msgs::Material& input_mat, ShaderDefinition& def)
{
  if (input_mat.has_normal_map)
  {
    def.include("normal_mapping.cg");
  }

  def.input("float3", "view_pos", "TEXCOORD0");
  def.input("float3", "normal", "TEXCOORD1");

  uint32_t num_tex_coords = input_mat.has_texture ? 1 : 0;
  uint32_t tex_coord_num = 2;
  for (uint32_t i = 0; i < num_tex_coords; i++)
  {
    def.input("float2", "uv" + toString(i), "TEXCOORD" + toString(tex_coord_num));
    ++tex_coord_num;
  }

  if (input_mat.has_normal_map)
  {
    def.input("float3", "tangent", "TEXCOORD" + toString(tex_coord_num++));
    def.input("float3", "binormal", "TEXCOORD" + toString(tex_coord_num++));
  }

  uint32_t sampler_num = 0;
  if (input_mat.has_texture)
  {
    def.sampler("tex", sampler_num++);
  }

  if (input_mat.has_normal_map)
  {
    def.sampler("normal_map", sampler_num++);
  }

  def.uniform("float4", "color", Ogre::GpuProgramParameters::ACT_CUSTOM, Material::CustomParam_Color);
  def.uniform("float4x4", "worldview", Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX, 0);

  std::stringstream ss;
  if (input_mat.has_texture)
  {
#if 0
    if (input_mat.has_color)
    {
      ss << " color = color * tex2D(sampler_tex, in_uv0);\n";
    }
    else
#endif
    {
      ss << " float4 tmp = tex2D(sampler_tex, in_uv0);\n";
      ss << " color = float4(tmp.rgb, tmp.a * color.a);\n";
    }
  }

  if (input_mat.has_normal_map)
  {
    ss << " float3 normal = extractNormalFromMap(sampler_normal_map, in_uv0, in_normal, in_tangent, in_binormal);" << std::endl;
  }
  else
  {
    ss << " float3 normal = normalize(in_normal);" << std::endl;
  }

  def.body = ss.str();
}

void fillPickingFragmentShaderDefinition(const rve_msgs::Material& input_mat, ShaderDefinition& def)
{
  def.uniform("float4", "object_id", Ogre::GpuProgramParameters::ACT_CUSTOM, Material::CustomParam_ObjectID);

  std::stringstream ss;
  // object_id is taken care of by the uniform
  ss << " float4 object_extra = float4(0.0, 0.0, 0.0, 0.0);\n";
  def.body = ss.str();
}

Ogre::MaterialPtr generateOgreMaterial(const rve_msgs::Material& input_mat)
{
  MaterialDefinition def;
  def.name = materialToStringID(input_mat);
  def.transparent = input_mat.opacity < 0.99;
  def.disable_shading = input_mat.disable_shading;

  def.cull_mode = input_mat.cull_mode;

  if (input_mat.has_texture)
  {
    def.textures.push_back(input_mat.texture);
  }

  if (input_mat.has_normal_map)
  {
    def.textures.push_back(input_mat.normal_map);
  }

  fillVertexShaderDefinition(input_mat, def.vertex_def);
  fillFragmentShaderDefinition(input_mat, def.fragment_def);
  fillPickingFragmentShaderDefinition(input_mat, def.picking_fragment_def);
  return generateOgreMaterial(def);
}

} // namespace rve_render_server