Problemas usando Ogre y su Cell-Shading

[IFMaster]

Hola a todos, tengo un problema usando Ogre y Cell-Shading, tengo un pequeño proyecto con Ogre implementado y viendo la demo del Cell-shading que se encuentra en la paguina de Ogre, me encuentro que de ese modo solo se pueden pintar mallas con colores planos, es decir, no se les puede aplicar una textura (o por lo menos yo no se como :S).

Me gustaria poder pintar mallas con textura y que Ogre les de la iluminación de cell-shading y me pinte las lineas de contorneado de malla.

Si alguien sabe si eso es posible hacerlo modificando el shader que tiene Ogre o hay alguna otra forma, pues lo agradeceria mucho.

Un saludo y gracias de antemano.

[Lex]

...

[Prompt]

Si pegais el código :) todos os podremos ayudar mejor.

En principio es como dice Lex, quizás esté usando el vertexColor y solamente hay que pillar la textura indicada, el cambio es una chorrada. Y yo como el viva GLSL :P

[IFMaster]

Muchas gracias por vuestra ayuda, yo tambien creo que se pueda indicar textura enmes de color en el shader, pero no tengo ni idea de como hacerlo, aki pongo el codigo por si hay alguien que haya tratado con estas cosas :P:

En c++:

//Creamos la malla y le aplicamos valores RGBA para el shader de Cell-shading

ogreHead = mSceneMgr->createEntity("Head", "Hagen.mesh");

// Set common material, but define custom parameters to change colours
// See Example-Advanced.material for how these are finally bound to GPU parameters
SubEntity *sub;
//eyes
sub = ogreHead->getSubEntity(0);
sub->setMaterialName("Examples/CelShading");

sub->setCustomParameter(1, Vector4(35.0f, 0.0f, 0.0f, 0.0f));
sub->setCustomParameter(2, Vector4(1.0f, 0.3f, 0.3f, 1.0f));
sub->setCustomParameter(3, Vector4(1.0f, 0.6f, 0.6f, 1.0f));

//1 -> shininess | 2 -> diffuse | 3 -> specular

El .material: (supongo k esta parte le indica k shader debe de cargar (example_celshading.cg) y macros de parametros
// -------------------------------
// Cel Shading Section
// -------------------------------
vertex_program Ogre/CelShadingVP cg
{
   source Example_CelShading.cg
   entry_point main_vp
   profiles vs_1_1 arbvp1

   default_params
   {
      param_named_auto lightPosition light_position_object_space 0
      param_named_auto eyePosition camera_position_object_space
      param_named_auto worldViewProj worldviewproj_matrix
      param_named shininess float 10
   }
}

fragment_program Ogre/CelShadingFP cg
{
   source Example_CelShading.cg
   entry_point main_fp
   profiles ps_1_1 arbfp1 fp20
}


material Examples/CelShading
{
   technique
   {
      pass
      {
         vertex_program_ref Ogre/CelShadingVP
         {
            // map shininess from custom renderable param 1
            param_named_auto shininess custom 1
         }
         fragment_program_ref Ogre/CelShadingFP
         {
            // map diffuse from custom renderable param 2
            param_named_auto diffuse custom 2
            // map specular from custom renderable param 2
            param_named_auto specular custom 3
         }
         texture_unit
         {
            texture cel_shading_diffuse.png 1d
            tex_address_mode clamp
            filtering none
         }
         texture_unit
         {
            texture cel_shading_specular.png 1d
            tex_address_mode clamp
            filtering none
            tex_coord_set 1
         }
         texture_unit
         {
            texture cel_shading_edge.png 1d
            tex_address_mode clamp
            filtering none
            tex_coord_set 2
         }
      }
   }
   
}

El .cg (y supongo la parte k hay k modificar):
/* Cel shading vertex program for single-pass rendering
  In this program, we want to calculate the diffuse and specular
  ramp components, and the edge factor (for doing simple outlining)
  For the outlining to look good, we need a pretty well curved model.
*/
void main_vp(float4 position   : POSITION,
          float3 normal      : NORMAL,
          // outputs
          out float4 oPosition : POSITION,
          out float  diffuse       : TEXCOORD0,
          out float  specular    : TEXCOORD1,
          out float  edge       : TEXCOORD2,
          // parameters
          uniform float3 lightPosition, // object space
          uniform float3 eyePosition,   // object space
          uniform float4  shininess,
          uniform float4x4 worldViewProj)
{
   // calculate output position
   oPosition = mul(worldViewProj, position);

   // calculate light vector
   float3 N = normalize(normal);
   float3 L = normalize(lightPosition - position.xyz);
   
   // Calculate diffuse component
   diffuse = max(dot(N, L) , 0);

   // Calculate specular component
   float3 E = normalize(eyePosition - position.xyz);
   float3 H = normalize(L + E);
   specular = pow(max(dot(N, H), 0), shininess);
   // Mask off specular if diffuse is 0
   if (diffuse == 0) specular = 0;

   // Edge detection, dot eye and normal vectors
   edge = max(dot(N, E), 0);
}

void main_fp(float diffuseIn    : TEXCOORD0,
          float specularIn   : TEXCOORD1,
          float edge      : TEXCOORD2,
         
          out float4 colour   : COLOR,
         
          uniform float4 diffuse,
          uniform float4 specular,
         
          uniform sampler1D diffuseRamp,
          uniform sampler1D specularRamp,
          uniform sampler1D edgeRamp)
{
   // Step functions from textures
   diffuseIn = tex1D(diffuseRamp, diffuseIn).x;
   specularIn = tex1D(specularRamp, specularIn).x;
   edge = tex1D(edgeRamp, edge).x;

   colour = edge * ((diffuse * diffuseIn) +
               (specular * specularIn));
}

-----------------

En el .material tambien se le indican las texturas de 1D k debe coger para hacerle las sombras.

Bueno pues creo que no me dejo nada, nuevamente gracias por adelantado.