Hola a todos,

Llevo tiempo leyendo por los Foros que la gente usa lenguajes de Scripts en sus videojuegos y no entiendo muy bien para que. Yo he usado Javascript en paginas web, incluso scripts de SQL pero no se me ocurre la utilidad en los videojuegos, supongo que no tendran nada que ver.
¿Podria alguien darme una pequeña explicacion o ejemplo de para que se usan?

Gracias y un saludo.

Ok, muchas gracias Blau, esta tarde cuando salga de trabajar lo probaré.

Saludos.

Hola otra vez a todos,

Yo sigo con mi batalla jeje... buscando por todos sitios he vuelto a encontrar otro Shader diferente pero ahora me surge otro problema, no se como pasarle la textura del modelo para que combinada con la textura del shader (escala de grises de una dimension) me ponga el color del pixel adecuado, pongo la imagen:



El .fx que estoy utilizando:

Código (c) [Seleccionar] Expand



extern matrix xViewMatrix; // Viewport View Matrix
extern matrix xProjMatrix; // Viewport Projection Matrix
extern matrix xWorldMatrix; // Object position in 3D space
extern matrix xWorldMatrixInverse; // Transpose Matrix 3D space

extern float4 xLightDir; // = float4(0,0,1,0); //our light position

texture xModelTex;


sampler2D texSampler0 : TEXUNIT0 = sampler_state
{
Texture  = (xModelTex);
   MIPFILTER = LINEAR;
   MAGFILTER = LINEAR;
   MINFILTER = LINEAR;
};


//application to vertex structure
struct vin
{
   float4 position   : POSITION0;
   float3 normal  : NORMAL;
   float2 tex0       : TEXCOORD0;
};

//vertex to pixel shader structure
struct vout
{
   float4 position   : POSITION0;
   float2 tex0        : TEXCOORD0;
};


//VERTEX SHADER
void vs( in vin IN, out vout OUT )
{
   //getting to position to object space
   OUT.position = mul(IN.position,mul( mul(xWorldMatrix,xViewMatrix),xProjMatrix));

   //getting the position of the vertex in the world
   float4 posWorld = mul(IN.position, xWorldMatrix);

//transform our normal vector so its facing the right way!
float3 normal   = mul( xWorldMatrixInverse, IN.normal );

//use the light direction & normal to determine the intensity
float diffuse = max(0,dot(-xLightDir,normal));

//use diffuse colour as an offset into our x texture colour
OUT.tex0.x = diffuse;
OUT.tex0.y = 0.0f;
}


//PIXEL SHADER
float4 ps( in vout IN ) : COLOR
{
   //get our colour
   float4 finalcolor = tex2D(texSampler0, IN.tex0);

   //return final pixel colour
return finalcolor;
}


technique CelShading
{
   pass p0
   {
       vertexshader = compile vs_1_1 vs();
       pixelshader  = compile ps_1_4 ps();
   }
}


Aunque creo que este .fx tampoco me soluciona el tema del Outline, que tendria que ver como hacerlo a posteriori, pero por lo menos este Shader parece mas facil de entender.

Un saludo.

Hola XÑA ,
He puesto el Render como me has dicho pero sigue ocurriendo lo mismo:
Estos son todos los parametros del Render que pongo:

Código (csharp) [Seleccionar] Expand


            if (bCartoon)
                m_pD3DDevice.RenderState.Lighting = false; 
            else
                m_pD3DDevice.RenderState.Lighting = m_bRSLigths; 

            m_pD3DDevice.RenderState.ZBufferFunction = Compare.Less;
            m_pD3DDevice.RenderState.VertexBlend = VertexBlend.Disable;
            m_pD3DDevice.RenderState.CullMode = Cull.CounterClockwise;
            m_pD3DDevice.RenderState.ZBufferEnable = true;
            m_pD3DDevice.RenderState.Clipping = true;
            m_pD3DDevice.RenderState.SpecularEnable = true;
            m_pD3DDevice.RenderState.MultiSampleAntiAlias = m_bRSAntialiasing3D;


Tengo algunas variables para cambiar en tiempo de ejecucion una propiedad u otra, no se si veras algo raro.
Un saludo y gracias.

Ese metodo fue el que primero probe, pero creo que no me cogia las texturas de los modelos y como soy muy paquete en el tema de los Shaders  :D, busque otra solución.

La verdad que la solucion que propones parece mas sencilla y entendible para los que estamos un poco peces, si pudieras conseguir algo mas de informacion sobre ello te lo agradeceria, siempre desde la premisa, de que mi nivel de Shaders es bastante bajo.

Todavia me cuesta entender un poco esto de los Shaders  ^_^'

Perdona pero soy un poco novato en el tema no entiendo muy bien lo del ZFUNC.
Se supone que ese ZFUNC es un parametro del Device de DirectX o algo asi? lo digo porque en el Shader no lo veo por ningun lado.
He visto que existe esta llamada para el Device (Estoy usando C# para mi motor):

Código (csharp) [Seleccionar] Expand


D3DDevice.RenderState.ZBufferFunction = Compare.Less;

Te refieres a esto ¿no? Actualmente no estoy informando ese valor, asi que supongo que por defecto sera LESS_EQUAL.

En cuanto al xStrokeThinckness no hay problema, le he puesto unas teclas en el interface para hacer crecer o decrecer el valor en tiempo real y asi poder buscar un valor coherente mientras se ejecuta el motor.

Gracias XÑA esta tarde cuando vuelva del trabajo lo pruebo y te comento, un saludo.

Hola a todos, llevo algun tiempo leyendo el foro pero esta es la primera vez que participo activamente jeje..

El caso es que estoy intentando implementar en mi pequeño motor con DirectX 9, el efecto Cartoon mediante HLSL pero no consigo el efecto deseado. Despues de usar un Effect que encontre por ahi creo que consegui el efecto del sombreado Cartoon pero no consigo el Outline.

Pongo el codigo del fichero .fx:

Código (c) [Seleccionar] Expand


//CONSTANTES
int n = 32;

//VARIABLES

// Light intensity
float4 xIntensityAmbient;
float4 xIntensityDiffuse;
float4 xIntensitySpecular;

// Material reflectivity
float4 xReflecAmbient;
float4 xReflecDiffuse;
float4 xReflecSpecular;

// stroke thickness
float xStrokeThinckness;

// light direction (view space)
float3 xLightDir; //  = {0.577, -0.577, 0.577};

// texture
extern texture g_ShadeTex;
extern texture g_ModelTex;

sampler ToonSamp = sampler_state
{
    Texture   = (g_ShadeTex);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    AddressU  = CLAMP;       
    AddressV  = CLAMP;
    AddressW  = CLAMP;
};

sampler MainSamp = sampler_state
{
    Texture   = (g_ModelTex);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
};


// transformations
float4x4 xWorldMatrix      : WORLD;
float4x4 xViewMatrix       : VIEW;
float4x4 xProjMatrix : PROJECTION;

struct VS_OUTPUT
{
    float4 Pos  : POSITION;
    float4 Diff : COLOR0;
    float4 Spec : COLOR1;
    float2 Tex  : TEXCOORD0;
    float2  TexB : TEXCOORD1;
};

VS_OUTPUT VS(
    float3 Pos  : POSITION,
    float3 Norm : NORMAL,
    float2 Tex  : TEXCOORD0)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;
    float3 L = -xLightDir;
    float4x4 WorldView = mul(xWorldMatrix, xViewMatrix);
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView);  // position (view space)
    float3 N = normalize(mul(Norm, (float3x3)xWorldMatrix)); // normal (view space)
    float3 R = normalize(2 * dot(N, L) * N - L);          // reflection vector (view space)
    float3 V = -normalize(P);                             // view direction (view space)
    Out.Pos  = mul(float4(P, 1), xProjMatrix);             // position (projected)
    Out.Diff = xIntensityAmbient * xReflecAmbient + xIntensityDiffuse * xReflecDiffuse * max(0, dot(N, L)); // diffuse + ambient
    Out.Spec = xIntensitySpecular * xReflecSpecular * pow(max(0, dot(R, V)), n/4);   // specular
    Out.Tex  = Tex;
    Out.TexB = Out.Diff.r;                                       
    return Out;
}

VS_OUTPUT OUTLINEVS(
    float3 Pos  : POSITION,
    float3 Norm : NORMAL,
    float2 Tex  : TEXCOORD0)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;
    float3 L = -xLightDir;
    float4x4 WorldView = mul(xWorldMatrix, xViewMatrix);
    float3 N = normalize(mul(Norm, (float3x3)WorldView)); // normal (view space)
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView) + xStrokeThinckness * N;
    float3 R = normalize(2 * dot(N, L) * N - L);          // reflection vector (view space)
    float3 V = -normalize(P);                             // view direction (view space)
    Out.Pos  = mul(float4(P, 1), xProjMatrix);             // position (projected)
    Out.Diff = (0.01,0.01,0.01,1);                                 // diffuse + ambient
    Out.Spec = xIntensitySpecular * xReflecSpecular * pow(max(0, dot(R, V)), n/4);   // specular
    Out.Tex  = Tex;                                       
    return Out;
}

float4 PS(
    float4 Diff : COLOR0,
    float4 Spec : COLOR1,
    float2 Tex  : TEXCOORD0,
    float2 TexB : TEXCOORD1) : COLOR
{
    float2 TexC = (TexB.x,0);
    return tex2D(MainSamp, Tex)* tex2D(ToonSamp,TexB);
}

float4 OUTLINEPS() : COLOR
{
    float4 ReturnThis = (0.1f,0.1f,0.1f,0.1f);
    return ReturnThis;
}

technique CelShading
{
    pass P0
    {
        // shaders
        VertexShader = compile vs_1_1 VS();
        PixelShader  = compile ps_1_1 PS();
    }
   
    pass P1
    {
        VertexShader = compile vs_1_1 OUTLINEVS();
        PixelShader  = compile ps_1_1 OUTLINEPS();
       
        ZEnable = true;
        ZWriteEnable = true;
        CullMode = cw;
AlphaBlendEnable = false;     
    }
}


Sin aplicar el segundo pase obtengo el resultado de Cartoon sin Outline y haciendo la segunda pasada consigo Cartoon con Outline pero no con el efecto deseado. Es como si las caras de los objetos salieran hacia fuera pero en negro y detras se quedara el objeto. Si necesitais mas pistas os puedo mandar unas imagenes.

Muchas gracias de antemano a todos y espero vuestra ayuda.

P.D: Pongo las imagenes para que os hagais un idea mejor.
Esta es sin Outline:


Y esta tiene el Outline 'raro':