The Ultimate Shader Thread. - GameCreators Forum

Author

Message

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 11th Jun 2004 18:59 Edited at: 11th Jun 2004 18:59

Link

Well, one of the hardest things I've found about creating vertex and pixel shaders is figuring out exactly how to make an effect work. I got a lot of help from the RacorX tutorial (http://www.shaderx.com/direct3d.net/tutorials/shader/shader1.html is one place it's hosted) which explains what each line of shader code does as well as describe some of the ideas behind different lighting models. Of course, it's all in ASM, so it's not for everyone. I personally prefer ASM to HLSL, so I loved it!

Anyway, I was just wondering, let's say I want to create a Halo/Predator cloaking effect that gives a glass-like visual distortion of the area, and I want to apply the effect to Walter. Would I be right in saying that you should first render the scene without Walter in it, then apply this texture to Walter in a second pass? Or, would there be a way of doing this in a single pass? Or is this just completely wrong?

Also, thanks for the tutorials Neophyte! My shaders would still be stuck in FX Composer and RenderMonkey if it wasn't for your help!

Back to top

Profile PM Email

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 12th Jun 2004 03:06

Link

Hi all,

Just like to know if a Glow Shader has been made for Db.

Thx

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 12th Jun 2004 21:13

Link

@Ninja Matt

"Anyway, I was just wondering, let's say I want to create a Halo/Predator cloaking effect that gives a glass-like visual distortion of the area, and I want to apply the effect to Walter. Would I be right in saying that you should first render the scene without Walter in it, then apply this texture to Walter in a second pass? Or, would there be a way of doing this in a single pass? Or is this just completely wrong?"

I think you'll need only 1 pass but I'm not sure. You could probably do it by modifiying the "Mr Wiggle" shader that comes with FX Composer to fade out model by slowly modifying the Alpha value through a constant. In that case, I'm pretty sure that you would only need one pass.

However, if you want to have a shimmering edge effect like the Predator has you might need two passes. I don't know though. I've never tried it before. You could probably just get away with one by making the model slightly less transparent at the edges.

Probably could achieve that through some kind of edge detection algorithm like cartoon shaders use. You could probably detect the edge and mod the alpha based on that. Afterwards, you could display the model in a "Mr Wiggle" style so the alpha fade isn't entirely even; giving it that blurred kind of look.

If that method doesn't give decent results there is always a combo of cubemaps and a reflection/refraction shader. I'm sure you could mod one of those shaders to warp the results near the edges.

The only serious drawback to that is that you will need a cubemap of your enviroment to pull it off. Those can get pretty big when you start to accumlate them. Fortunately, you could probably just pre-compute the cube-maps for your levels and reuse some cubemaps as long as you are in the general vicinity.

Given the nature of the Predator cloaking effect I think you could get away with it. It is suppose to be hard to see after all so minor graphical glitches can be overlooked.

Failing even that, all I can think of that is even close to that is a combo of a depth of field shader and the alpha cranked all the way up. For that you would probably need two passes though. I'm not sure though since Depth of Field shaders can't be run on my hardware. My poor Geforce 4 ti 4200 is a little overwhelmed.

"Also, thanks for the tutorials Neophyte!"

Your welcome.

@KajiSan

"Just like to know if a Glow Shader has been made for Db."

There hasn't been any that have been made specifically for DBPro but there are Glow shaders that you can get to work.

This one right here came with the DX 9 sdk and will run on any shader capable hardware. You'll have to set the constants for it though, but that shouldn't be a problem thanks to my tuts.

//
// Glow Effect
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// Note: This effect file works with EffectEdit.
//

string XFile = "tiger.x";   // model
string BIMG  = "lake.bmp";  // Background image
int    BCLR  = 0xff202080;  // background

// texture
texture Tex0 < string name = "tiger.bmp"; >;

// transforms
float4x3 WorldView  : WORLDVIEW; 
float4x4 Projection : PROJECTION;

// light direction (view space)
float3 LightDir < string UIDirectional = "Light Direction"; > = normalize(float3(0.0f, 0.0f, 1.0f));

// glow parameters
float4 GlowColor     = float4(0.5f, 0.2f, 0.2f, 1.0f);
float4 GlowAmbient   = float4(0.2f, 0.2f, 0.0f, 0.0f);
float  GlowThickness = 0.015f;

struct VSTEXTURE_OUTPUT
{
    float4 Position : POSITION;
    float4 Diffuse  : COLOR;
    float2 TexCoord : TEXCOORD0;
};

// draws unskinned object with one texture and one directional light.
VSTEXTURE_OUTPUT VSTexture
    (
    float4 Position : POSITION, 
    float3 Normal   : NORMAL,
    float2 TexCoord : TEXCOORD0
    )
{
    VSTEXTURE_OUTPUT Out = (VSTEXTURE_OUTPUT)0;
  
    float3 L = -LightDir;                                   // light direction (view space)
    float3 P = mul(Position, WorldView);                    // position (view space)
    float3 N = normalize(mul(Normal, (float3x3)WorldView)); // normal (view space)
   
    Out.Position = mul(float4(P, 1), Projection);   // projected position
    Out.Diffuse  = max(0, dot(N, L));               // diffuse 
    Out.TexCoord = TexCoord;                        // texture coordinates
    
    return Out;    
}

struct VSGLOW_OUTPUT
{
    float4 Position : POSITION;
    float4 Diffuse  : COLOR;
};

// draws a transparent hull of the unskinned object.
VSGLOW_OUTPUT VSGlow
    (
    float4 Position : POSITION, 
    float3 Normal   : NORMAL
    )
{
    VSGLOW_OUTPUT Out = (VSGLOW_OUTPUT)0;

float3 N = normalize(mul(Normal, (float3x3)WorldView));     // normal (view space)
    float3 P = mul(Position, WorldView) + GlowThickness * N;    // displaced position (view space)
    float3 A = float3(0, 0, 1);                                 // glow axis

float Power;

Power  = dot(N, A);
    Power *= Power;
    Power -= 1;
    Power *= Power;     // Power = (1 - (N.A)^2)^2 [ = ((N.A)^2 - 1)^2 ]
    
    Out.Position = mul(float4(P, 1), Projection);   // projected position
    Out.Diffuse  = GlowColor * Power + GlowAmbient; // modulated glow color + glow ambient
    
    return Out;    
}

technique TGlowAndTexture
{
    pass PTexture
    {   
        // single texture/one directional light shader
        VertexShader = compile vs_1_1 VSTexture();
        PixelShader  = NULL;
        
        // texture
        Texture[0] = (Tex0);

// sampler states
        MinFilter[0] = LINEAR;
        MagFilter[0] = LINEAR;
        MipFilter[0] = POINT;

// set up texture stage states for single texture modulated by diffuse 
        ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
        ColorArg2[0] = CURRENT;
        AlphaOp[0]   = DISABLE;

ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
        
    }

pass PGlow
    {   
        // glow shader
        VertexShader = compile vs_1_1 VSGlow();
        PixelShader  = NULL;
        
        // no texture
        Texture[0] = NULL;

// enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = ONE;
        DestBlend        = ONE;

// set up texture stage states to use the diffuse color
        ColorOp[0]   = SELECTARG2;
        ColorArg2[0] = DIFFUSE;
        AlphaOp[0]   = SELECTARG2;
        AlphaArg2[0] = DIFFUSE;

ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
    }
}

technique TGlowOnly
{
    pass PGlow
    {   
        // glow shader
        VertexShader = compile vs_1_1 VSGlow();
        PixelShader  = NULL;
        
        // no texture
        Texture[0] = NULL;

// enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = ONE;
        DestBlend        = ONE;

// set up texture stage states to use the diffuse color
        ColorOp[0]   = SELECTARG2;
        ColorArg2[0] = DIFFUSE;
        AlphaOp[0]   = SELECTARG2;
        AlphaArg2[0] = DIFFUSE;

ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
   }
}

+ Code Snippet

//
// Glow Effect
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// Note: This effect file works with EffectEdit.
//

string XFile = "tiger.x";   // model
string BIMG  = "lake.bmp";  // Background image
int    BCLR  = 0xff202080;  // background

// texture
texture Tex0 < string name = "tiger.bmp"; >;

// transforms
float4x3 WorldView  : WORLDVIEW; 
float4x4 Projection : PROJECTION;

// light direction (view space)
float3 LightDir < string UIDirectional = "Light Direction"; > = normalize(float3(0.0f, 0.0f, 1.0f));

// glow parameters
float4 GlowColor     = float4(0.5f, 0.2f, 0.2f, 1.0f);
float4 GlowAmbient   = float4(0.2f, 0.2f, 0.0f, 0.0f);
float  GlowThickness = 0.015f;

struct VSTEXTURE_OUTPUT
{
    float4 Position : POSITION;
    float4 Diffuse  : COLOR;
    float2 TexCoord : TEXCOORD0;
};

// draws unskinned object with one texture and one directional light.
VSTEXTURE_OUTPUT VSTexture
    (
    float4 Position : POSITION, 
    float3 Normal   : NORMAL,
    float2 TexCoord : TEXCOORD0
    )
{
    VSTEXTURE_OUTPUT Out = (VSTEXTURE_OUTPUT)0;
  
    float3 L = -LightDir;                                   // light direction (view space)
    float3 P = mul(Position, WorldView);                    // position (view space)
    float3 N = normalize(mul(Normal, (float3x3)WorldView)); // normal (view space)
   
    Out.Position = mul(float4(P, 1), Projection);   // projected position
    Out.Diffuse  = max(0, dot(N, L));               // diffuse 
    Out.TexCoord = TexCoord;                        // texture coordinates
    
    return Out;    
}

struct VSGLOW_OUTPUT
{
    float4 Position : POSITION;
    float4 Diffuse  : COLOR;
};

// draws a transparent hull of the unskinned object.
VSGLOW_OUTPUT VSGlow
    (
    float4 Position : POSITION, 
    float3 Normal   : NORMAL
    )
{
    VSGLOW_OUTPUT Out = (VSGLOW_OUTPUT)0;

    float3 N = normalize(mul(Normal, (float3x3)WorldView));     // normal (view space)
    float3 P = mul(Position, WorldView) + GlowThickness * N;    // displaced position (view space)
    float3 A = float3(0, 0, 1);                                 // glow axis

    float Power;

    Power  = dot(N, A);
    Power *= Power;
    Power -= 1;
    Power *= Power;     // Power = (1 - (N.A)^2)^2 [ = ((N.A)^2 - 1)^2 ]
    
    Out.Position = mul(float4(P, 1), Projection);   // projected position
    Out.Diffuse  = GlowColor * Power + GlowAmbient; // modulated glow color + glow ambient
    
    return Out;    
}



technique TGlowAndTexture
{
    pass PTexture
    {   
        // single texture/one directional light shader
        VertexShader = compile vs_1_1 VSTexture();
        PixelShader  = NULL;
        
        // texture
        Texture[0] = (Tex0);

        // sampler states
        MinFilter[0] = LINEAR;
        MagFilter[0] = LINEAR;
        MipFilter[0] = POINT;

        // set up texture stage states for single texture modulated by diffuse 
        ColorOp[0]   = MODULATE;
        ColorArg1[0] = TEXTURE;
        ColorArg2[0] = CURRENT;
        AlphaOp[0]   = DISABLE;

        ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
        
    }

    pass PGlow
    {   
        // glow shader
        VertexShader = compile vs_1_1 VSGlow();
        PixelShader  = NULL;
        
        // no texture
        Texture[0] = NULL;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = ONE;
        DestBlend        = ONE;

        // set up texture stage states to use the diffuse color
        ColorOp[0]   = SELECTARG2;
        ColorArg2[0] = DIFFUSE;
        AlphaOp[0]   = SELECTARG2;
        AlphaArg2[0] = DIFFUSE;

        ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
    }
}

technique TGlowOnly
{
    pass PGlow
    {   
        // glow shader
        VertexShader = compile vs_1_1 VSGlow();
        PixelShader  = NULL;
        
        // no texture
        Texture[0] = NULL;

        // enable alpha blending
        AlphaBlendEnable = TRUE;
        SrcBlend         = ONE;
        DestBlend        = ONE;

        // set up texture stage states to use the diffuse color
        ColorOp[0]   = SELECTARG2;
        ColorArg2[0] = DIFFUSE;
        AlphaOp[0]   = SELECTARG2;
        AlphaArg2[0] = DIFFUSE;

        ColorOp[1]   = DISABLE;
        AlphaOp[1]   = DISABLE;
   }
}

Back to top

Profile PM

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 13th Jun 2004 00:16

Link

Yes Thanks for your tuts, you're a god man

Back to top

Profile PM

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 16th Jun 2004 14:05

Link

Hi,

It's me

. Is it possible to implement the HDRL lighting fx, i like this bloom effect. I have try to change all the constants...still don't work. I know i must do something with pass, but I haven't any knowledges about that.

Thx

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 17th Jun 2004 06:35

Link

@KajiSan

Could you post the code for the shader you are using?

Back to top

Profile PM

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 17th Jun 2004 10:16 Edited at: 17th Jun 2004 10:39

Link

Worked velvety shader.

/************* UN-TWEAKABLES **************/

float4x4 WorldIT : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WorldViewProj : WorldViewProjection < string UIWidget="None"; >;
float4x4 World : World < string UIWidget="None"; >;
float4x4 ViewI : ViewInverse < string UIWidget="None"; >;

/************* TWEAKABLES **************/

float3 LightPos : Position <
	string Object = "PointLight";
	string Space = "World";
> = {100.0f, 100.0f, 100.0f};

float3 DiffColor : DIFFUSE <
	string UIWidget = "Primary Color";
> = {0.5f, 0.5f, 0.5f};

float3 SpecColor : Specular <
	string UIWidget = "Color";
	string UIName = "Fuzz Color";
> = {0.7f, 0.7f, 0.75f};

float3 SubColor <
	string UIWidget = "Color";
	string UIName = "Under-Color";
> = {0.2f, 0.2f, 1.0f};

float RollOff <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.05;
	string UIName = "Edge Rolloff";
> = 0.3;

/*
float NormalSign <
    string UIWidget = "slider";
    float UIMin = -1.0;
    float UIMax = 1.0;
    float UIStep = 2.0;
    string UIName = "Normals Direction";
> = 1.0;
*/

///

texture ColorTexture : DIFFUSE
<
    string ResourceName = "seafloor.dds";
    string TextureType = "2D";
>;

sampler2D ColorSampler = sampler_state
{
    Texture = <ColorTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = None;
};

/************* DATA STRUCTS **************/

/* data from application vertex buffer */
struct appdata {
    float3 Position	: POSITION;
    float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord0	: TEXCOORD0;
    float4 diffCol	: COLOR0;
    float4 specCol	: COLOR1;
};

/*********** vertex shader ******/

vertexOutput velvetVS(appdata IN)
{
    vertexOutput OUT;
    float3 Nn = normalize(mul(IN.Normal, WorldIT).xyz);
    // Nn.x = normalSign * Nn.x;
    // Nn.y = normalSign * Nn.y;
    // Nn.z = normalSign * Nn.z;
    float4 Po = float4(IN.Position.xyz,1);
    OUT.HPosition = mul(Po, WorldViewProj);
    float3 Pw = mul(Po, World).xyz;
    float3 Ln = normalize(LightPos - Pw);
    float ldn = dot(Ln,Nn);
    float diffComp = max(0,ldn);
    float3 diffContrib = diffComp * DiffColor;
    float subLamb = smoothstep(-RollOff,1.0,ldn) - smoothstep(0.0,1.0,ldn);
    subLamb = max(0.0,subLamb);
    float3 subContrib = subLamb * SubColor;
    OUT.TexCoord0 = IN.UV;
    float3 Vn = normalize(ViewI[3].xyz - Pw);
    float vdn = 1.0-dot(Vn,Nn);
    float3 vecColor = float4(vdn.xxx,1.0);
    OUT.diffCol = float4((subContrib+diffContrib).xyz,1);
    OUT.specCol = float4((vecColor*SpecColor).xyz,1);
    return OUT;
}

/********* pixel shader ********/

float4 velvetPS_t(vertexOutput IN) : COLOR
{
	return (IN.diffCol*tex2D(ColorSampler,IN.TexCoord0) + IN.specCol);
}

/*************/

technique Velvet {
    pass p0 {		
		VertexShader = compile vs_1_1 velvetVS();
		//ZEnable = true;
		//ZWriteEnable = true;
		//CullMode = None;
		PixelShader = compile ps_1_1 velvetPS_t();
    }
}

/***************************** eof ***/

+ Code Snippet

/************* UN-TWEAKABLES **************/

float4x4 WorldIT : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WorldViewProj : WorldViewProjection < string UIWidget="None"; >;
float4x4 World : World < string UIWidget="None"; >;
float4x4 ViewI : ViewInverse < string UIWidget="None"; >;

/************* TWEAKABLES **************/

float3 LightPos : Position <
	string Object = "PointLight";
	string Space = "World";
> = {100.0f, 100.0f, 100.0f};

float3 DiffColor : DIFFUSE <
	string UIWidget = "Primary Color";
> = {0.5f, 0.5f, 0.5f};

float3 SpecColor : Specular <
	string UIWidget = "Color";
	string UIName = "Fuzz Color";
> = {0.7f, 0.7f, 0.75f};

float3 SubColor <
	string UIWidget = "Color";
	string UIName = "Under-Color";
> = {0.2f, 0.2f, 1.0f};

float RollOff <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.05;
	string UIName = "Edge Rolloff";
> = 0.3;

/*
float NormalSign <
    string UIWidget = "slider";
    float UIMin = -1.0;
    float UIMax = 1.0;
    float UIStep = 2.0;
    string UIName = "Normals Direction";
> = 1.0;
*/

///

texture ColorTexture : DIFFUSE
<
    string ResourceName = "seafloor.dds";
    string TextureType = "2D";
>;

sampler2D ColorSampler = sampler_state
{
    Texture = <ColorTexture>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = None;
};

/************* DATA STRUCTS **************/

/* data from application vertex buffer */
struct appdata {
    float3 Position	: POSITION;
    float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord0	: TEXCOORD0;
    float4 diffCol	: COLOR0;
    float4 specCol	: COLOR1;
};

/*********** vertex shader ******/

vertexOutput velvetVS(appdata IN)
{
    vertexOutput OUT;
    float3 Nn = normalize(mul(IN.Normal, WorldIT).xyz);
    // Nn.x = normalSign * Nn.x;
    // Nn.y = normalSign * Nn.y;
    // Nn.z = normalSign * Nn.z;
    float4 Po = float4(IN.Position.xyz,1);
    OUT.HPosition = mul(Po, WorldViewProj);
    float3 Pw = mul(Po, World).xyz;
    float3 Ln = normalize(LightPos - Pw);
    float ldn = dot(Ln,Nn);
    float diffComp = max(0,ldn);
    float3 diffContrib = diffComp * DiffColor;
    float subLamb = smoothstep(-RollOff,1.0,ldn) - smoothstep(0.0,1.0,ldn);
    subLamb = max(0.0,subLamb);
    float3 subContrib = subLamb * SubColor;
    OUT.TexCoord0 = IN.UV;
    float3 Vn = normalize(ViewI[3].xyz - Pw);
    float vdn = 1.0-dot(Vn,Nn);
    float3 vecColor = float4(vdn.xxx,1.0);
    OUT.diffCol = float4((subContrib+diffContrib).xyz,1);
    OUT.specCol = float4((vecColor*SpecColor).xyz,1);
    return OUT;
}

/********* pixel shader ********/

float4 velvetPS_t(vertexOutput IN) : COLOR
{
	return (IN.diffCol*tex2D(ColorSampler,IN.TexCoord0) + IN.specCol);
}

/*************/

technique Velvet {
    pass p0 {		
		VertexShader = compile vs_1_1 velvetVS();
		//ZEnable = true;
		//ZWriteEnable = true;
		//CullMode = None;
		PixelShader = compile ps_1_1 velvetPS_t();
    }
}

/***************************** eof ***/

all is fine!

Back to top

Profile PM Website

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 17th Jun 2004 10:17 Edited at: 17th Jun 2004 10:38

Link

Worked hemisphere shader.

// light directions (view space)
float3 lightDir : Direction <  string UIName = "Light Direction"; string Object = "TargetLight";>  = {0.577, -0.577, 0.577};

// direction of light from sky (view space)
float3 DirFromSky < string UIDirectional = "Direction from Sky"; > = { 0.0f, -1.0f, 0.0f };

// light intensity
float4 I_a = { 0.5f, 0.5f, 0.5f, 1.0f };    // ambient
float4 I_b = { 0.1f, 0.0f, 0.0f, 1.0f };    // ground
float4 I_c = { 0.9f, 0.9f, 1.0f, 1.0f };    // sky
float4 I_d = { 1.0f, 0.9f, 0.8f, 1.0f };    // diffuse
float4 I_s = { 1.0f, 1.0f, 1.0f, 1.0f };    // specular

// material reflectivity
float4 k_a = { 0.8f, 0.8f, 0.8f, 1.0f };    // ambient
float4 k_d = { 0.4f, 0.4f, 0.4f, 1.0f };    // diffuse
float4 k_s = { 0.1f, 0.1f, 0.1f, 1.0f };    // specular
int    n   = 32;                            // power

// transformations
float4x3 WorldView  : WORLDVIEW;
float4x4 Projection : PROJECTION;

struct VS_OUTPUT
{
    float4 Pos  : POSITION;
    float4 Diff : COLOR0;
    float4 Spec : COLOR1;
};

VS_OUTPUT VS(
    float3 Pos  : POSITION, 
    float3 Norm : NORMAL, 
    float  Occ  : TEXCOORD0,
    uniform bool bHemi, 
    uniform bool bDiff,
    uniform bool bSpec)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;

float3 L = -lightDir    ;                               // diffuse direction
    float3 Y = -DirFromSky;                                 // hemisphere up axis
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView);    // position (view space)
    float3 N = normalize(mul(Norm, (float3x3)WorldView));   // normal (view space)
    float3 R = normalize(2 * dot(N, L) * N - L);            // reflection vector (view space)
    float3 V = -normalize(P);                               // view direction (view space)

float4 Amb  = k_a * I_a;
    float4 Hemi = k_a * lerp(I_b, I_c, (dot(N, Y) + 1) / 2) * (1 - Occ);
    float  temp = 1 - max(0, dot(N, L));
    float4 Diff = k_d * I_d * (1 - temp * temp);
    float4 Spec = k_s * I_s * pow(max(0, dot(R, V)), n/4);
    float4 Zero = 0;

Out.Pos  = mul(float4(P, 1), Projection);               // position (projected)
    Out.Diff = (bDiff ? Diff : 0)
             + (bHemi ? Hemi : Amb);                        // diffuse + ambient/hemisphere
    Out.Spec = (bSpec ? Spec : 0);                          // specular

return Out;
}

technique THemisphere
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, false, false);
    }
}

technique THemisphereDiffuse
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, true, false);
    }
}

technique THemisphereDiffuseSpecular
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, true, true);

SpecularEnable = TRUE;
    }
}

technique TAmbient
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, false, false);
    }
}

technique TAmbientDiffuse
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, true, false);
    }
}

technique TAmbientDiffuseSpecular
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, true, true);

SpecularEnable = TRUE;
    }
}

+ Code Snippet

// light directions (view space)
float3 lightDir : Direction <  string UIName = "Light Direction"; string Object = "TargetLight";>  = {0.577, -0.577, 0.577};

// direction of light from sky (view space)
float3 DirFromSky < string UIDirectional = "Direction from Sky"; > = { 0.0f, -1.0f, 0.0f };            

// light intensity
float4 I_a = { 0.5f, 0.5f, 0.5f, 1.0f };    // ambient
float4 I_b = { 0.1f, 0.0f, 0.0f, 1.0f };    // ground
float4 I_c = { 0.9f, 0.9f, 1.0f, 1.0f };    // sky
float4 I_d = { 1.0f, 0.9f, 0.8f, 1.0f };    // diffuse
float4 I_s = { 1.0f, 1.0f, 1.0f, 1.0f };    // specular

// material reflectivity
float4 k_a = { 0.8f, 0.8f, 0.8f, 1.0f };    // ambient
float4 k_d = { 0.4f, 0.4f, 0.4f, 1.0f };    // diffuse
float4 k_s = { 0.1f, 0.1f, 0.1f, 1.0f };    // specular
int    n   = 32;                            // power


// transformations
float4x3 WorldView  : WORLDVIEW;
float4x4 Projection : PROJECTION;

struct VS_OUTPUT
{
    float4 Pos  : POSITION;
    float4 Diff : COLOR0;
    float4 Spec : COLOR1;
};

VS_OUTPUT VS(
    float3 Pos  : POSITION, 
    float3 Norm : NORMAL, 
    float  Occ  : TEXCOORD0,
    uniform bool bHemi, 
    uniform bool bDiff,
    uniform bool bSpec)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;

    float3 L = -lightDir    ;                               // diffuse direction
    float3 Y = -DirFromSky;                                 // hemisphere up axis
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView);    // position (view space)
    float3 N = normalize(mul(Norm, (float3x3)WorldView));   // normal (view space)
    float3 R = normalize(2 * dot(N, L) * N - L);            // reflection vector (view space)
    float3 V = -normalize(P);                               // view direction (view space)

    float4 Amb  = k_a * I_a;
    float4 Hemi = k_a * lerp(I_b, I_c, (dot(N, Y) + 1) / 2) * (1 - Occ);
    float  temp = 1 - max(0, dot(N, L));
    float4 Diff = k_d * I_d * (1 - temp * temp);
    float4 Spec = k_s * I_s * pow(max(0, dot(R, V)), n/4);
    float4 Zero = 0;

    Out.Pos  = mul(float4(P, 1), Projection);               // position (projected)
    Out.Diff = (bDiff ? Diff : 0)
             + (bHemi ? Hemi : Amb);                        // diffuse + ambient/hemisphere
    Out.Spec = (bSpec ? Spec : 0);                          // specular

    return Out;
}


technique THemisphere
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, false, false);
    }
}

technique THemisphereDiffuse
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, true, false);
    }
}

technique THemisphereDiffuseSpecular
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(true, true, true);

        SpecularEnable = TRUE;
    }
}

technique TAmbient
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, false, false);
    }
}

technique TAmbientDiffuse
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, true, false);
    }
}

technique TAmbientDiffuseSpecular
{
    pass P0
    {
        VertexShader = compile vs_1_1 VS(false, true, true);

        SpecularEnable = TRUE;
    }
}

all is fine!

Back to top

Profile PM Website

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 17th Jun 2004 16:12

Link

@Neophyte

Well, I need a code

The technique used is "Bloom"....

I have made 2 matrix4 (one for the Projection and an other for the view), 2 vector4 (for the light position and light intensity), and a float for the bloom scale effect.

My model goes Black

Thx for answers..

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 18th Jun 2004 02:07

Link

@KajiSan

I'm sorry if this has been asked before, but what graphics card do you have?

Back to top

Profile PM

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 18th Jun 2004 02:34

Link

@Neophyte

Ati Radeon 9700 Pro.....

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 18th Jun 2004 02:53

Link

@KajiSan

DBPro is not currently capable of creating the bloom effect that comes with FX Composer. There are some things you need to create and access that we just can't do with DBPro currently.

Hopefully, when the shader commands are extended we'll get access to the needed commands.

Back to top

Profile PM

KajiSan

20

Years of Service

User Offline

Joined: 5th Aug 2003

Location:

Posted: 18th Jun 2004 02:59

Link

@Neophyte

Ok

Thx a lot for your answers.

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 23rd Jun 2004 12:54

Link

Update:

Well I've just recently re-emailed Microsoft about my earlier email I sent regarding some clarifications I needed for my tutorial.

This is the reply I got:

Quote: "Hello again and we apologize for any inconvenience this issue may have caused you.

We have followed-up your issue to the appropriate group and a response from them is likely forthcoming. We will get back to you as soon as we receive any updates from them.

Thanks for your patience and continued support."

So that makes about 1 and half months since I orignally emailed them some questions(I emailed them May 12). So it looks like my next tutorial will be delayed yet again until I can get a straight answer out of them.

Out of curiousity, has any one here emailed Microsoft's support team before? Is it usual for them to take this long responding? I've never emailed them before so I don't really know what to expect.

In all fairness though, they are usually remarkable prompt at returning a response to my emails(I got the above quote from a response that they sent in under an hour). They just haven't answered my questions that's all. I suppose I must have asked some pretty tough questions.

Back to top

Profile PM

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 23rd Jun 2004 14:21

Link

Quote: "Out of curiousity, has any one here emailed Microsoft's support team before? Is it usual for them to take this long responding? I've never emailed them before so I don't really know what to expect. "

haha... yeah good luck with that, basically with microsoft unless they want to help you'll get the run around from thier support dept. who know bugger all.
If you were going to get a reasonable answer it would've come by now.

Back to top

Profile PM Email Website

empty

21

Years of Service

User Offline

Joined: 26th Aug 2002

Location: 3 boats down from the candy

Posted: 23rd Jun 2004 14:54 Edited at: 23rd Jun 2004 14:54

Link

Quote: "Out of curiousity, has any one here emailed Microsoft's support team before? Is it usual for them to take this long responding? I've never emailed them before so I don't really know what to expect."

They take their time

. Although 6 weeks is quite a long time. Usually it took 3-4 weeks when I had "not so common" questions. Sometimes you get a reply within a week. Apple's dev support wasn't much faster, however, their replies were longer.

Play Nice! Play Basic!

Back to top

Profile PM

ALPHA ZERO PRODUCTIONS

20

Years of Service

User Offline

Joined: 28th Sep 2003

Location: Mom ! I forgot where we live !

Posted: 23rd Jun 2004 18:48 Edited at: 23rd Jun 2004 18:53

Link

hey Neophyte can u make the msglow.fx in fx composer work in dbp please ???
because i tried everything and it still did not work

Back to top

Profile PM Email Website

Zeal

21

Years of Service

User Offline

Joined: 10th Oct 2002

Location: Colorado Springs, CO

Posted: 23rd Jun 2004 21:12

Link

Noooo our umbilical has been cut! Dont let this thread die! We need more input neo! I got that 3d graphics primer book in the mail the other day. Gonna go start it now, and when im done reading it (heh) ill need more shader tuts!

All you need is zeal

Back to top

Profile PM Email

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 24th Jun 2004 06:42

Link

@ALPHA ZERO PRODUCTIONS

"because i tried everything and it still did not work"

A few questions:

1. What video card do you have?
2. What do you mean by "did not work"? Did you model turn black when you applied it? Or did nothing happen? What were the visual results of it not working?

@Zeal

" Dont let this thread die!"

I won't.

Its just that I really want to do something special with my next tutorial that will knock people's socks off and show the true power of the .fx file format.

I can write my next tutorial right now, but I just won't be able to include the stuff I wanted so it would come out rather uninteresting though still important. Hopefully, MS will eventually get back to me about the questions that I asked. I just don't think they'll do it anytime soon.

Back to top

Profile PM

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 24th Jun 2004 07:09

Link

Neo you ever thought of perhaps asking your question on here.
Whether you want to admit it or not, I do actually know one hell of alot about this stuff that I could no doubt answer (and no doubt in alot better detail and understanding than Microsoft would give you).

Or maybe you wanna just stay petty about things just like other users around here.

Back to top

Profile PM Email Website

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 24th Jun 2004 13:41

Link

I seriously doubt that you could answer my question, Raven(though I was wondering when you'd ask). They aren't easy questions at all. Thank you for offering your assitance though.

Back to top

Profile PM

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 24th Jun 2004 14:57

Link

You never know unless you try.

Back to top

Profile PM Email Website

aG Annihilator

19

Years of Service

User Offline

Joined: 20th Jun 2004

Location: UK

Posted: 24th Jun 2004 16:57

Link

Quote: "I seriously doubt that you could answer my question, Raven(though I was wondering when you'd ask). They aren't easy questions at all. Thank you for offering your assitance though."

you guys should help each other out, even if he cant help you out its still usefull to get feedback from someone else

ya never know

------------------------
Annihilator of Annihilator Units
http://dynamic5.gamespy.com/~au

Back to top

Profile PM Email Website

Scraggle

Moderator

20

Years of Service

User Offline

Joined: 10th Jul 2003

Location: Yorkshire

Posted: 24th Jun 2004 17:11

Link

@Neophyte

Ask the question!!

I like a good laugh and I'm sure Ravens answer will provide one

S.O.S. Site Of Scraggle

Back to top

Profile PM Email

ALPHA ZERO PRODUCTIONS

20

Years of Service

User Offline

Joined: 28th Sep 2003

Location: Mom ! I forgot where we live !

Posted: 25th Jun 2004 01:40

Link

i have a 16mb nvidia tnt2
and it says "cannot create vertex shader"

Back to top

Profile PM Email Website

Eldar

20

Years of Service

User Offline

Joined: 26th Nov 2003

Location:

Posted: 25th Jun 2004 04:41 Edited at: 25th Jun 2004 04:42

Link

Alpha, there is a reason your card "can't create vertex shader". Your card doesn't support shaders.

Neo, thanks for keeping this going(even if it isn't stickied anymore). Since Raven is making an atempt to be civil, you could at least try to do the same. If you post the question, at the worst it would be a few wasted minutes. And you never know, some one might be able to help you with it.

3.1 ghz Pentium 4
Geforce FX 5800 ultra @ 535/1300
DX 9

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 25th Jun 2004 07:15

Link

@Eldar

" Since Raven is making an atempt to be civil, you could at least try to do the same."

I am being civil(notice how I said Thank You for him offering his assitance). I just don't want to reveal what exactly I'm working on because I want it to be a suprise. In all of the posts I've made regarding this topic I have never once given away what the subject matter of this tutorial is other than the fact that it has to do with the .fx file format. Never. I did that deliberately.

This isn't because its Raven that's offering. Even if it were someone else I'd still decline, because I want to keep this thing a secret until I'm ready to spring it. So it's nothing personal. I've just have had the goal of keeping this tutorial as a surprise every since I concieved of it.

It's going to be a really impressive peice of work when it's done. It will reveal the true power of the .fx file format and make effect files a lot more usefull in other people's eyes. But that's all I'm going to say on the matter.

Back to top

Profile PM

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 25th Jun 2004 10:39 Edited at: 25th Jun 2004 10:41

Link

/******************************************************************************

Copyright NVIDIA Corporation 2004
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Comments:
	Lava Effect by Sergey A. Makovkin (sergeymak@pisem.net)

******************************************************************************/
#define MARBLE_SIZE 64

#define MARBLE_COL_PALE float3(0.25, 0.25, 0.35)
#define MARBLE_COL_MED float3(0.40, 0.30, 0.30)
#define MARBLE_COL_DARK float3(0.05, 0.05, 0.26)
#define MARBLE_COL_DARKER float3(0.03, 0.03, 0.20)

float TexelIncrement < string UIWidget = "none"; > = 1.0f / 128.0f;

#define MARBLE_KNOTS 13
#define CR00	-0.5
#define CR01	 1.5
#define CR02	-1.5
#define CR03	 0.5
#define CR10	 1.0
#define CR11	-2.5
#define CR12	 2.0
#define CR13	-0.5
#define CR20	-0.5
#define CR21	 0.0
#define CR22	 0.5
#define CR23     0.0
#define CR30     0.0
#define CR31	 1.0
#define CR32     0.0
#define CR33     0.0

float3 InterpSplineCatmullRom(float u, float3 knot0, float3 knot1, float3 knot2, float3 knot3 )
{
	float3 c0;
	float3 c1;
	float3 c2;
	float3 c3;

c3 = (CR00 * knot0) + (CR01 * knot1) + (CR02 * knot2) + (CR03 * knot3);
	c2 = (CR10 * knot0) + (CR11 * knot1) + (CR12 * knot2) + (CR13 * knot3);
	c1 = (CR20 * knot0) + (CR21 * knot1) + (CR22 * knot2) + (CR23 * knot3);
	c0 = (CR30 * knot0) + (CR31 * knot1) + (CR32 * knot2) + (CR33 * knot3);

return ((c3*u + c2)*u + c1)*u + c0;
}

static const float3 marble_knots[MARBLE_KNOTS+4] = 
{
  MARBLE_COL_PALE,  // dummy
  MARBLE_COL_PALE,  // dummy
  MARBLE_COL_PALE,      // 0
  MARBLE_COL_PALE,
  MARBLE_COL_MED, 
  MARBLE_COL_MED, 
  MARBLE_COL_MED,
  MARBLE_COL_PALE, 
  MARBLE_COL_PALE,
  MARBLE_COL_DARK, 
  MARBLE_COL_DARK,
  MARBLE_COL_DARKER, 
  MARBLE_COL_DARKER,
  MARBLE_COL_PALE, 
  MARBLE_COL_DARKER,     // 1
  MARBLE_COL_DARKER, // dummy
  MARBLE_COL_DARKER, // dummy
};

// put map in texture 4, 64 entries cubic interpolation over the surface
float3 make_marble_map(float x)
{
    float3 knot0, knot1, knot2, knot3;

// need to get 0-1 -> 1-13 for knot values
    float f = x * 15.0 + 1.0;

float k = floor(f); // get lower integer for knots

knot0 = marble_knots[k - 1];
    knot1 = marble_knots[k];
    knot2 = marble_knots[k + 1];
    knot3 = marble_knots[k + 2];
    
    return InterpSplineCatmullRom(f - k, knot0, knot1, knot2, knot3);            
}

// Matrices
float4x4 WorldInverseTranspose : WorldInverseTranspose < string UIWidget = "none"; >;
float4x4 WorldViewProjection : WorldViewProjection < string UIWidget = "none"; >;
float4x4 World : World < string UIWidget = "none"; >;
float4x4 ViewInverse : ViewInverse < string UIWidget = "none"; >;

float Time : TIME < string UIWidget = "none"; >;

/* data from application vertex buffer */
struct appdata {
    float3 Position	: POSITION;
    float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord	: TEXCOORD0;    
    float3 WorldNormal	: TEXCOORD2;
    float3 WorldPos	: TEXCOORD3;
    float3 WorldEyePos	: TEXCOORD4;
};

/* Output pixel values */
struct pixelOutput {
  float4 col : COLOR;
};

// Volume texture
texture VolumeMap 
< 
    string texturetype = "VOLUME"; 
    string function = "GenerateVolumeMap"; 
    int width = 64;
    int height = 64;
    int depth = 64; 
>;

// Volume texture
texture MarbleColorTexture
< 
    string texturetype = "2D"; 
    string function = "MarbleColor"; 
    int width = MARBLE_SIZE;
    int height = MARBLE_SIZE;
>;

sampler3D VolumeTexture =
sampler_state
{
    texture = (VolumeMap);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    
    AddressU = WRAP;
    AddressV = WRAP;
    AddressW = WRAP;
};

sampler2D MarbleColorSampler =
sampler_state
{
    texture = (MarbleColorTexture);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    
    AddressU = WRAP;
    AddressV = WRAP;
};

float4 GenerateVolumeMap(float3 Pos : POSITION) : COLOR
{
	return (noise(Pos * 50.5) * .5) + .5f;
}

float3 MarbleColor(float3 Pos : POSITION) : COLOR
{
	return make_marble_map(Pos.x);
}

texture bark : Diffuse
<
	string ResourceName = "bark.dds";
    string TextureType = "2D";
>;

sampler2D BarkSampler = sampler_state
{
    Texture = <bark>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
};

/*********** vertex shader ******/
vertexOutput mainVS(appdata IN,
    uniform float4x4 WorldViewProjection,
    uniform float4x4 WorldInverseTranspose,
    uniform float4x4 World,
    uniform float4x4 ViewInverse
) {
    vertexOutput OUT;
    OUT.WorldNormal = mul(IN.Normal, WorldInverseTranspose).xyz;
    float3 WorldSpacePos = mul(float4(IN.Position, 1), World).xyz;
    OUT.WorldPos = WorldSpacePos;
    OUT.TexCoord = IN.UV;
    OUT.WorldEyePos = ViewInverse[3].xyz;
    OUT.HPosition = mul(float4(IN.Position, 1), WorldViewProjection);
    return OUT;
}

/*********** pixel shader ******/

pixelOutput mainPS(vertexOutput IN,
    uniform float4 LavaColor1,
    uniform float4 LavaColor2,
    uniform float LavaFactor
) {
    pixelOutput OUT; 
         
	// Sample 4 octaves of noise
	
	float rnd = 0.0f;
	float f = 1;
	float3 Coord = IN.WorldPos + (Time * .03f);
	for (int i = 0; i < 4; i++)
	{
		half4 fnoise = tex3D(VolumeTexture, Coord * .2f * f);
		fnoise -=.5f;
		fnoise *= 4.0f;
		rnd += ( fnoise) / f;
		f *= 4.17;	
	}
	    
	float3 coord = IN.WorldPos;
	coord.x += rnd*LavaFactor;
	coord.y += rnd*LavaFactor;
	float4 tex = tex2D(BarkSampler, coord);
	
	// Add the terms
	OUT.col = tex * LavaColor1 * (rnd + 0.1) * 10 + LavaColor2;
    return OUT;
}

pixelOutput mainGlowPS(vertexOutput IN,
    uniform float4 LavaColor1,
    uniform float4 LavaColor2,
    uniform float LavaFactor
) {
    pixelOutput OUT;     
    
	// Sample 4 octaves of noise
	
	float rnd = 0.0f;
	float f = 1;
	float3 Coord = IN.WorldPos + (Time * .03f);
	for (int i = 0; i < 4; i++)
	{
		half4 fnoise = tex3D(VolumeTexture, Coord * .2f * f);
		fnoise -=.5f;
		fnoise *= 4.0f;
		rnd += ( fnoise) / f;
		f *= 4.17;	
	}
	    
	float3 coord = IN.WorldPos;
	coord.x += rnd*LavaFactor;
	coord.y += rnd*LavaFactor;
	float4 tex = tex2D(BarkSampler, coord);
	
	// Add the terms
	OUT.col = tex * LavaColor1 * (rnd + 0.1) * 0.5;    
    return OUT;
}

float4 LavaColor1
<
    string UIName = "Lava Color 1";
    string UIWidget = "color";
> = {0.8f, 0.8f, 0.4f, 1.0f};

float4 LavaColor2
<
    string UIName = "Lava Color 2";
    string UIWidget = "color";
> = {0.5f, 0.0f, 0.0f, 0.0f};

float LavaFactor
<
    string uiwidget = "slider";
    float uimin = 0.01;
    float uimax = 1.0;
    float uistep = 0.01;
    string uiname = "Lava factor";
> = 0.1;

struct VS_OUTPUT
{
   	float4 Position   : POSITION;
    float4 Diffuse    : COLOR0;
    float4 TexCoord0   : TEXCOORD0;
};

/*************/

technique Lava
{
	pass GlowBuffer
	{
		cullmode = none;
		ZEnable = true;
		VertexShader = compile vs_2_0 mainVS(WorldViewProjection, WorldInverseTranspose,World,ViewInverse);
        PixelShader  = compile ps_2_0 mainGlowPS(LavaColor1, LavaColor2, LavaFactor);
	}
	
	pass p0
	{		
        VertexShader = compile vs_2_0 mainVS(WorldViewProjection, WorldInverseTranspose,World,ViewInverse);

ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;

PixelShader = compile ps_2_0 mainPS(LavaColor1, LavaColor2, LavaFactor);
	}

}

+ Code Snippet

/******************************************************************************

Copyright NVIDIA Corporation 2004
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Comments:
	Lava Effect by Sergey A. Makovkin (sergeymak@pisem.net)

******************************************************************************/
#define MARBLE_SIZE 64

#define MARBLE_COL_PALE float3(0.25, 0.25, 0.35)
#define MARBLE_COL_MED float3(0.40, 0.30, 0.30)
#define MARBLE_COL_DARK float3(0.05, 0.05, 0.26)
#define MARBLE_COL_DARKER float3(0.03, 0.03, 0.20)

float TexelIncrement < string UIWidget = "none"; > = 1.0f / 128.0f;

#define MARBLE_KNOTS 13
#define CR00	-0.5
#define CR01	 1.5
#define CR02	-1.5
#define CR03	 0.5
#define CR10	 1.0
#define CR11	-2.5
#define CR12	 2.0
#define CR13	-0.5
#define CR20	-0.5
#define CR21	 0.0
#define CR22	 0.5
#define CR23     0.0
#define CR30     0.0
#define CR31	 1.0
#define CR32     0.0
#define CR33     0.0

float3 InterpSplineCatmullRom(float u, float3 knot0, float3 knot1, float3 knot2, float3 knot3 )
{
	float3 c0;
	float3 c1;
	float3 c2;
	float3 c3;

	c3 = (CR00 * knot0) + (CR01 * knot1) + (CR02 * knot2) + (CR03 * knot3);
	c2 = (CR10 * knot0) + (CR11 * knot1) + (CR12 * knot2) + (CR13 * knot3);
	c1 = (CR20 * knot0) + (CR21 * knot1) + (CR22 * knot2) + (CR23 * knot3);
	c0 = (CR30 * knot0) + (CR31 * knot1) + (CR32 * knot2) + (CR33 * knot3);

	return ((c3*u + c2)*u + c1)*u + c0;
}

static const float3 marble_knots[MARBLE_KNOTS+4] = 
{
  MARBLE_COL_PALE,  // dummy
  MARBLE_COL_PALE,  // dummy
  MARBLE_COL_PALE,      // 0
  MARBLE_COL_PALE,
  MARBLE_COL_MED, 
  MARBLE_COL_MED, 
  MARBLE_COL_MED,
  MARBLE_COL_PALE, 
  MARBLE_COL_PALE,
  MARBLE_COL_DARK, 
  MARBLE_COL_DARK,
  MARBLE_COL_DARKER, 
  MARBLE_COL_DARKER,
  MARBLE_COL_PALE, 
  MARBLE_COL_DARKER,     // 1
  MARBLE_COL_DARKER, // dummy
  MARBLE_COL_DARKER, // dummy
};

// put map in texture 4, 64 entries cubic interpolation over the surface
float3 make_marble_map(float x)
{
    float3 knot0, knot1, knot2, knot3;

    // need to get 0-1 -> 1-13 for knot values
    float f = x * 15.0 + 1.0;

    float k = floor(f); // get lower integer for knots

    knot0 = marble_knots[k - 1];
    knot1 = marble_knots[k];
    knot2 = marble_knots[k + 1];
    knot3 = marble_knots[k + 2];
    
    return InterpSplineCatmullRom(f - k, knot0, knot1, knot2, knot3);            
}

// Matrices
float4x4 WorldInverseTranspose : WorldInverseTranspose < string UIWidget = "none"; >;
float4x4 WorldViewProjection : WorldViewProjection < string UIWidget = "none"; >;
float4x4 World : World < string UIWidget = "none"; >;
float4x4 ViewInverse : ViewInverse < string UIWidget = "none"; >;

float Time : TIME < string UIWidget = "none"; >;

/* data from application vertex buffer */
struct appdata {
    float3 Position	: POSITION;
    float4 UV		: TEXCOORD0;
    float4 Normal	: NORMAL;
};

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float4 TexCoord	: TEXCOORD0;    
    float3 WorldNormal	: TEXCOORD2;
    float3 WorldPos	: TEXCOORD3;
    float3 WorldEyePos	: TEXCOORD4;
};

/* Output pixel values */
struct pixelOutput {
  float4 col : COLOR;
};

// Volume texture
texture VolumeMap 
< 
    string texturetype = "VOLUME"; 
    string function = "GenerateVolumeMap"; 
    int width = 64;
    int height = 64;
    int depth = 64; 
>;

// Volume texture
texture MarbleColorTexture
< 
    string texturetype = "2D"; 
    string function = "MarbleColor"; 
    int width = MARBLE_SIZE;
    int height = MARBLE_SIZE;
>;

sampler3D VolumeTexture =
sampler_state
{
    texture = (VolumeMap);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    
    AddressU = WRAP;
    AddressV = WRAP;
    AddressW = WRAP;
};


sampler2D MarbleColorSampler =
sampler_state
{
    texture = (MarbleColorTexture);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    
    AddressU = WRAP;
    AddressV = WRAP;
};

float4 GenerateVolumeMap(float3 Pos : POSITION) : COLOR
{
	return (noise(Pos * 50.5) * .5) + .5f;
}

float3 MarbleColor(float3 Pos : POSITION) : COLOR
{
	return make_marble_map(Pos.x);
}

texture bark : Diffuse
<
	string ResourceName = "bark.dds";
    string TextureType = "2D";
>;

sampler2D BarkSampler = sampler_state
{
    Texture = <bark>;
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Linear;
};

/*********** vertex shader ******/
vertexOutput mainVS(appdata IN,
    uniform float4x4 WorldViewProjection,
    uniform float4x4 WorldInverseTranspose,
    uniform float4x4 World,
    uniform float4x4 ViewInverse
) {
    vertexOutput OUT;
    OUT.WorldNormal = mul(IN.Normal, WorldInverseTranspose).xyz;
    float3 WorldSpacePos = mul(float4(IN.Position, 1), World).xyz;
    OUT.WorldPos = WorldSpacePos;
    OUT.TexCoord = IN.UV;
    OUT.WorldEyePos = ViewInverse[3].xyz;
    OUT.HPosition = mul(float4(IN.Position, 1), WorldViewProjection);
    return OUT;
}

/*********** pixel shader ******/

pixelOutput mainPS(vertexOutput IN,
    uniform float4 LavaColor1,
    uniform float4 LavaColor2,
    uniform float LavaFactor
) {
    pixelOutput OUT; 
         
	// Sample 4 octaves of noise
	
	float rnd = 0.0f;
	float f = 1;
	float3 Coord = IN.WorldPos + (Time * .03f);
	for (int i = 0; i < 4; i++)
	{
		half4 fnoise = tex3D(VolumeTexture, Coord * .2f * f);
		fnoise -=.5f;
		fnoise *= 4.0f;
		rnd += ( fnoise) / f;
		f *= 4.17;	
	}
	    
	float3 coord = IN.WorldPos;
	coord.x += rnd*LavaFactor;
	coord.y += rnd*LavaFactor;
	float4 tex = tex2D(BarkSampler, coord);
	
	// Add the terms
	OUT.col = tex * LavaColor1 * (rnd + 0.1) * 10 + LavaColor2;
    return OUT;
}

pixelOutput mainGlowPS(vertexOutput IN,
    uniform float4 LavaColor1,
    uniform float4 LavaColor2,
    uniform float LavaFactor
) {
    pixelOutput OUT;     
    
	// Sample 4 octaves of noise
	
	float rnd = 0.0f;
	float f = 1;
	float3 Coord = IN.WorldPos + (Time * .03f);
	for (int i = 0; i < 4; i++)
	{
		half4 fnoise = tex3D(VolumeTexture, Coord * .2f * f);
		fnoise -=.5f;
		fnoise *= 4.0f;
		rnd += ( fnoise) / f;
		f *= 4.17;	
	}
	    
	float3 coord = IN.WorldPos;
	coord.x += rnd*LavaFactor;
	coord.y += rnd*LavaFactor;
	float4 tex = tex2D(BarkSampler, coord);
	
	// Add the terms
	OUT.col = tex * LavaColor1 * (rnd + 0.1) * 0.5;    
    return OUT;
}


float4 LavaColor1
<
    string UIName = "Lava Color 1";
    string UIWidget = "color";
> = {0.8f, 0.8f, 0.4f, 1.0f};

float4 LavaColor2
<
    string UIName = "Lava Color 2";
    string UIWidget = "color";
> = {0.5f, 0.0f, 0.0f, 0.0f};

float LavaFactor
<
    string uiwidget = "slider";
    float uimin = 0.01;
    float uimax = 1.0;
    float uistep = 0.01;
    string uiname = "Lava factor";
> = 0.1;

struct VS_OUTPUT
{
   	float4 Position   : POSITION;
    float4 Diffuse    : COLOR0;
    float4 TexCoord0   : TEXCOORD0;
};


/*************/

technique Lava
{
	pass GlowBuffer
	{
		cullmode = none;
		ZEnable = true;
		VertexShader = compile vs_2_0 mainVS(WorldViewProjection, WorldInverseTranspose,World,ViewInverse);
        PixelShader  = compile ps_2_0 mainGlowPS(LavaColor1, LavaColor2, LavaFactor);
	}
	
	pass p0
	{		
        VertexShader = compile vs_2_0 mainVS(WorldViewProjection, WorldInverseTranspose,World,ViewInverse);

		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;

        PixelShader = compile ps_2_0 mainPS(LavaColor1, LavaColor2, LavaFactor);
	}

}

It is Moscow shader from FX composer. Please, help me whit writing Dark basic code for corect work this shader.

all is fine!

Back to top

Profile PM Website

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 25th Jun 2004 12:22

Link

Meh! I'm kinda past caring, i offered you declined. whatever

As for your Shader Alex, i'll have to take some time to recode the procedual texture as Lee still hasn't got them working for 5.4;
but i'm totally swaped for the next week, so I'll see about getting it done for next Friday.

Back to top

Profile PM Email Website

Eldar

20

Years of Service

User Offline

Joined: 26th Nov 2003

Location:

Posted: 26th Jun 2004 06:07 Edited at: 26th Jun 2004 06:18

Link

The moscow shader uses volume textures. I don't think Db supports them.

Quote: "" Since Raven is making an atempt to be civil, you could at least try to do the same."

I am being civil(notice how I said Thank You for him offering his assitance). I just don't want to reveal what exactly I'm working on because I want it to be a suprise. In all of the posts I've made regarding this topic I have never once given away what the subject matter of this tutorial is other than the fact that it has to do with the .fx file format. Never. I did that deliberately.

This isn't because its Raven that's offering. Even if it were someone else I'd still decline, because I want to keep this thing a secret until I'm ready to spring it. So it's nothing personal. I've just have had the goal of keeping this tutorial as a surprise every since I concieved of it.

It's going to be a really impressive peice of work when it's done. It will reveal the true power of the .fx file format and make effect files a lot more usefull in other people's eyes. But that's all I'm going to say on the matter. "

Didn't know it was a secret. Thanks again, for your work on this tutorial

.

3.1 ghz Pentium 4
Geforce FX 5800 ultra @ 535/1300
DX 9

Back to top

Profile PM

Final Epsilon

20

Years of Service

User Offline

Joined: 26th Jan 2004

Location: CA, USA

Posted: 27th Jun 2004 18:29

Link

mmm. Thanks for all your work. I'm just curious, when do you think that you'll have the information needed to finish writing the tutorial?

Back to top

Profile PM Website

Final Epsilon

20

Years of Service

User Offline

Joined: 26th Jan 2004

Location: CA, USA

Posted: 30th Jun 2004 10:55

Link

hm.... i just thought of an idea. Why dont we create some sort of "dbp shader repository" in which we have premodified shaders and example DBP source, all packaged in one little nifty zip file. Then we could have download links, each with a screenshot of the shader in action.

It'd be a great resource to the community, especially for those hard to modify shaders, and those really cool effects. I could host the files if you guys want to do it. I personally know very little about shaders, but i just thought it'd be nice to have such a resource when working on projects and such.

Oh well... just a thought. If it's stupid you guys can just like ignore me or something.

Back to top

Profile PM Website

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 30th Jun 2004 19:06

Link

Quote: "hm.... i just thought of an idea. Why dont we create some sort of "dbp shader repository" in which we have premodified shaders "

It is very nice idea!

all is fine!

Back to top

Profile PM Website

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 30th Jun 2004 19:53

Link

@Final Epsilon

"I'm just curious, when do you think that you'll have the information needed to finish writing the tutorial?"

I'm not sure. That's mostly up to Microsoft. However, I've just recently managed to figuare out a few important things for myself so I'm a lot closer to actually getting the tutorial done.

But there are still some issues that I need to get some clarity on.

Further, there is a shader competition going on and I'm thinking about entering. Since the deadline is August 1 I have about a month to hurry up and start working on my shader. To add to the pressure, I'll be going on vacation in a few weeks. So I'll be gone when the compo deadline occurs. So I really have less than a month to get my shader and a demo up and running. And they all have to be under 3mb in size!

I think it's a fairly safe bet that I won't be able to get this tutorial out for this month unfortunately. I'll probably be able to get it out next month given a little luck and some effort.

As for the DBPro shader repository we could start something like that using the codebase. It would be a little difficult to do for some shaders given the difficult file size limits(Some textures from FX Composer can't be compressed small enough to fit into the required limit let along a whole program with source included.)

Back to top

Profile PM

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 30th Jun 2004 23:09

Link

Quote: "As for the DBPro shader repository we could start something like that using the codebase. It would be a little difficult to do for some shaders given the difficult file size limits(Some textures from FX Composer can't be compressed small enough to fit into the required limit let along a whole program with source included.) "

There is no limit on the source length, convert the images to data statements.
Even so you could simply put in the text of the codebase entry

`// Requires *.DDS, *.TGA, Available In FX Composer //

Back to top

Profile PM Email Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 1st Jul 2004 08:05 Edited at: 1st Jul 2004 08:09

Link

@Kajisan
A bloom lighting effect? Well, I've been fiddling around to make one that works in DB, and here's what I've got so far:

//	eMalice Glow Test Shader - 1.0
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;

//------------------------------------
texture texMap
<
	string name = "Null.tga";
>;

//------------------------------------
technique blurTest
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.005, 0.005, 0.0, 0.0
			def c5, 0.005, -0.005, 0.0, 0.0

// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			add oT3, v1, -c5
		};
		
		PixelShader = asm
		{
			// Initilise Shader
			ps.1.4
			def c0, 0.25, 0.25, 0.25, 0.5
			
			// Load Sample Textures
			texld r0, t0
			texld r1, t1
			texld r2, t2
			texld r3, t3
			
			// Take the Average of the Textures
			mul r3, r3, c0
			mad r2, r2, c0, r3
			mad r1, r1, c0, r2
			mad r0, r0, c0, r1
			
			// Scale for Glow
			sub_sat r0.rgb, r0_x2, c0.w
			//mul r0, r0, r0
			mul_sat r0, r0, r0
		};
		
		Texture[0] = <texMap>;
		Texture[1] = <texMap>;
		Texture[2] = <texMap>;
		Texture[3] = <texMap>;

MinFilter[0] = Linear;
		MinFilter[1] = Linear;
		MinFilter[2] = Linear;
		MinFilter[3] = Linear;

MagFilter[0] = Linear;
		MagFilter[1] = Linear;
		MagFilter[2] = Linear;
		MagFilter[3] = Linear;

MipFilter[0] = Linear;
		MipFilter[1] = Linear;
		MipFilter[2] = Linear;
		MipFilter[3] = Linear;
	}

pass p1 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.007, 0.0, 0.0, 0.0
			def c5, 0.0, 0.007, 0.0, 0.0

// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			//add oT3, v1, -c5
			mov oT3, v1
		};

AlphaBlendEnable = true;

SrcBlend = One;
		DestBlend = One;
	}
}

+ Code Snippet

//	eMalice Glow Test Shader - 1.0
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;

//------------------------------------
texture texMap
<
	string name = "Null.tga";
>;

//------------------------------------
technique blurTest
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

		VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.005, 0.005, 0.0, 0.0
			def c5, 0.005, -0.005, 0.0, 0.0

			// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			add oT3, v1, -c5
		};
		
		PixelShader = asm
		{
			// Initilise Shader
			ps.1.4
			def c0, 0.25, 0.25, 0.25, 0.5
			
			// Load Sample Textures
			texld r0, t0
			texld r1, t1
			texld r2, t2
			texld r3, t3
			
			// Take the Average of the Textures
			mul r3, r3, c0
			mad r2, r2, c0, r3
			mad r1, r1, c0, r2
			mad r0, r0, c0, r1
			
			// Scale for Glow
			sub_sat r0.rgb, r0_x2, c0.w
			//mul r0, r0, r0
			mul_sat r0, r0, r0
		};
		
		Texture[0] = <texMap>;
		Texture[1] = <texMap>;
		Texture[2] = <texMap>;
		Texture[3] = <texMap>;

		MinFilter[0] = Linear;
		MinFilter[1] = Linear;
		MinFilter[2] = Linear;
		MinFilter[3] = Linear;

		MagFilter[0] = Linear;
		MagFilter[1] = Linear;
		MagFilter[2] = Linear;
		MagFilter[3] = Linear;

		MipFilter[0] = Linear;
		MipFilter[1] = Linear;
		MipFilter[2] = Linear;
		MipFilter[3] = Linear;
	}

	pass p1 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;

		VertexShader = asm
		{
			// Initialise Shader
			vs.1.1
			dcl_position	v0
			dcl_texcoord	v1
			def c4, 0.007, 0.0, 0.0, 0.0
			def c5, 0.0, 0.007, 0.0, 0.0

			// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3

			// Displace and Output Tex Coords
			add oT0, v1, c4
			add oT1, v1, c5
			add oT2, v1, -c4
			//add oT3, v1, -c5
			mov oT3, v1
		};

		AlphaBlendEnable = true;

		SrcBlend = One;
		DestBlend = One;
	}
}

Currently, the shader works by using a seperate camera to render the scene to an image, preferably of size 128/128 or 256/256, and then using that image to texture a ghosted plain in front of the main camera. The shader will then blur the image and scale the colours to get a good glow. Also, you'll need to make sure that the second camera, used to capture the glow image, doesn't include the plain, otherwise it'll mess up. The way I did that was to position the plain three units in front of the main camera, then set the second camera's minimum view range to four units. Also, you have to remember to tell the shader to use the textures already applied to the object when you load it, otherwise it'll mess up.

I've included a modified version of the RoadTerrain program in the code box below, since that's what I use to test all my shaders out! To use it, you'll need to have this shader saved as "GlowTest2.fx" in the "RoadTerrain" folder, where the .dba file is stored. Then start a new project and paste the code below into it. If it doesn't work - kick me until I fix it!

You might also want to go into the shader itself and mess around with the "Scale for Glow" part, since that's what affects the final colour output the most.

@Clever People
Well, the above shader works, but it's shoddy. It's the bad result of a bad shader programmer! I wondered if you could help me improve it by imparting some of your knowledge?

Of course, the single best way to improve it would be to avoid the whole camera and plane malarky. It would be nice if more, if not all of this, could be encapsulated in the shader itself; but then, we're moving onto render targets, aren't we?

The other thing I'm worried about is the blur. As it stands, the blur is done through multitexturing and slightly perturbed UV coordinates for each texture. Then, it's a simple case of taking the average colour value of the textures for each pixel. The problem is, I'm getting eight sample points out of two passes, using four textures per pass (I'm not sure if I can use more...), which doesn't give a very smooth effect. Would it be at all possible to blur the texture horizontally, then send the resulting half-blurred texture into the next pass to blur it vertically? Effectively, I want to be able to squash the four textures of the first pass into a single texture, then use that texture four times to do the same thing in the next pass.

*EDIT*
Also, this is my first attempt at using multiple passes, so I'm still not entirely sure how it works. As far as I can tell, it pretty much just re-renders the object over the top of the original and relies on alpha-blending to combine them.

Whoah, I've rambled a bit - I'd better stop now! Thanks in advance!

Back to top

Profile PM Email

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 1st Jul 2004 12:53

Link

@Raven

"There is no limit on the source length, convert the images to data statements."

Sure. I'll give it a try next time.

"Even so you could simply put in the text of the codebase entry"

I believe that's what I did with one of mine.

@Ninja Matt

" It's the bad result of a bad shader programmer! "

I wouldn't say that. You did pretty good considering the limitations that DBPro places on us.

" It would be nice if more, if not all of this, could be encapsulated in the shader itself; but then, we're moving onto render targets, aren't we?"

Yup. I've been hounding lee and mike for support for render targets for quite some time. I think that eventually they will become a part of DBPro but I'm not too optimisitic about it happening anytime soon.

"Would it be at all possible to blur the texture horizontally, then send the resulting half-blurred texture into the next pass to blur it vertically?"

Yes. In fact, that's exactly how the pros do it. I think there are a few examples on the web that demostrate how to do that. I don't have any links on hand, but I'll see what I can come up with. However, internet access for me has been spotty at best lately. So I don't know if I'll be able to dig anything up anytime soon.

"As far as I can tell, it pretty much just re-renders the object over the top of the original and relies on alpha-blending to combine them."

Yeah, that's basically what they do. I can see you've been reading the DirectX SDK help files.

@Everyone

Well I just got a response from Microsoft(Yay!) they said they couldn't give me an example of what I wanted in a "non-convoluted way"(Boo!).

I'm composing my response right now. I'll see if I can use the information that I've gleaned so far and try rephrasing my questions so as to narrow the problem down more. Hopefully, they'll be able to help me figuare out some of the more specific problems I'm dealing with.

On an interesting side note:

They also said that as a result of my questions they'll be including some examples in the next SDK release that deal with my questions.

Back to top

Profile PM

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 1st Jul 2004 22:33

Link

Ninja Matt, The shader isn't to shabby.
However for the way your doing it, there isn't a way (even in DirectX) to encapsulate all the data into the shader.

If you keep using PS 1.1 then, again no you can't do a single pass blur; Especially considering your doing this as an ASM not a HLSL based shader.
I'll have some time after I finish up some shaders for a level i'm working on (about an hr if all goes well), i'll see if i can't throw together a faster more flexible example of what you want.

Back to top

Profile PM Email Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 2nd Jul 2004 08:56

Link

@Neophyte
Yeah, I've seen how the pros do the shader itself, since I've had a good look at some of the screen-space effects in FX Composer. The problem is that I can't for the life of me figure out what part of the code is 'baking' and then transfering the half-blurred texture! I scarcely know anything about HLSL and I'm not too familiar with the phase marker and dependent reads, so I'm a bit stumped at the moment.

I'll take your advice and have a quick scan over the 'net to see what I can dig up, but everything tends to be written in HLSL, so I've usually got to figure stuff out for myself.

Anyway, thanks for the help and tutorials! I'd never have got this far without you!

@Raven
"If you keep using PS 1.1 then"

Actually, I'm using VS 1.1 and PS 1.4. VS because I don't seem to need to use anything higher at the moment, and PS because the texture instructions of 1.0 - 1.3 confuse me too much!

Back to top

Profile PM Email

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 2nd Jul 2004 09:47

Link

// An empty material, which simply transforms the vertex and sets the color to white.

//------------------------------------
float4x4 matWorldViewProj : WorldViewProjection;

// Blur Offsets
float4 T0_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T1_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T2_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T3_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };

// Adverageing Weights
float4 Weight0 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight1 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight2 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight3 = { 1.0f, 1.0f, 1.0f, 1.0f };

// Textures
texture AlphaTexture : Diffuse
<
	string ResourceName = "alpha.dds";
    string TextureType = "2D";
>;

//------------------------------------
struct vertexInput {
    float4 Position		: POSITION;
    float4 TexCoord0 	: TEXCOORD0;
};

struct vertexOutput {
    float4 HPosition 	: POSITION;
    float4 TexCoord0	: TEXCOORD0;
    float4 TexCoord1	: TEXCOORD1;
    float4 TexCoord2	: TEXCOORD2;
    float4 TexCoord3	: TEXCOORD3;
};

//------------------------------------
vertexOutput VS_GlowPattern( vertexInput IN, uniform float4 T0_Offset ) 
{
    vertexOutput OUT;
    // Transform Position -> Horizontal Clip Space
    OUT.HPosition = mul( matWorldViewProj, IN.Position );
   	
   	/* 	Altering this will change the output pattern calculated
   		within the pixel shader. Basically the futher the Offset
   		the more the texels will blur. */
   	OUT.TexCoord0 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord1 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord2 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord3 = IN.TexCoord0 + T0_Offset;
   	
    return OUT;
}

vertexOutput VS_GlowPatternAdvanced( vertexInput IN, 
							 		 uniform float4 T0_Offset,uniform float4 T1_Offset,
							 		 uniform float4 T2_Offset,uniform float4 T3_Offset ) 
{
    vertexOutput OUT;
    // Transform Position -> Horizontal Clip Space
    OUT.HPosition = mul( matWorldViewProj, IN.Position );
   	
   	/* 	Altering this will change the output pattern calculated
   		within the pixel shader. Unlike the basic version which
   		uses a simple single sample, this allows you to edit your
   		samples per texture target. */
   	OUT.TexCoord0 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord1 = IN.TexCoord0 + T1_Offset;
   	OUT.TexCoord2 = IN.TexCoord0 + T2_Offset;
   	OUT.TexCoord3 = IN.TexCoord0 + T3_Offset;
   	
    return OUT;
}

//-----------------------------------

struct pixelInput
{
	float4 TexCoord0 : TEXCOORD0;
	float4 TexCoord1 : TEXCOORD1;
	float4 TexCoord2 : TEXCOORD2;
	float4 TexCoord3 : TEXCOORD3;
};

//-----------------------------------

sampler2D Tex0 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex1 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex2 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex3 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};

//-----------------------------------

float4 PS_Glow( pixelInput IN,uniform float4 Weight0 ) : COLOR
{
	float4 OUT;
	
	// Grab Colours from all the texture stages
	float4 t0 = tex2D( Tex0, IN.TexCoord0 );
	float4 t1 = tex2D( Tex1, IN.TexCoord1 );
	float4 t2 = tex2D( Tex2, IN.TexCoord2 );
	float4 t3 = tex2D( Tex3, IN.TexCoord3 );
	
	float4 temp;
	temp  =   Weight0 * t0;
	temp += ( Weight0 * t1 ); 
	temp += ( Weight0 * t2 );
	temp += ( Weight0 * t3 );
	
	return temp;
}

float4 PS_GlowAdvanced( pixelInput IN, 
						uniform float4 Weight0,uniform float4 Weight1,
						uniform float4 Weight2,uniform float4 Weight3 ) : COLOR
{
	float4 OUT;
	
	// Grab Colours from all the texture stages
	float4 t0 = tex2D( Tex0, IN.TexCoord0 );
	float4 t1 = tex2D( Tex1, IN.TexCoord1 );
	float4 t2 = tex2D( Tex2, IN.TexCoord2 );
	float4 t3 = tex2D( Tex3, IN.TexCoord3 );
	
	float4 temp;
	temp  =   Weight0 * t0;
	temp += ( Weight1 * t1 ); 
	temp += ( Weight2 * t2 );
	temp += ( Weight3 * t3 );
	
	return temp;
}

//-----------------------------------

technique StandardGlow
{
    pass p0 
    {		
		VertexShader = compile vs_1_1 VS_GlowPattern( T0_Offset );
		PixelShader  = compile ps_1_1 PS_Glow( Weight0 );
		
		// Just use the color
		ColorArg1[0] = Diffuse;
		AlphaArg1[0] = Diffuse;
		ColorOp[0] = SelectArg1;
		AlphaOp[1] = SelectArg1;
    }
}

technique StandardGlow
{
    pass p0 
    {		
		VertexShader = compile vs_1_1 VS_GlowPatternAdvanced( T0_Offset, T1_Offset, T2_Offset, T3_Offset );
		PixelShader  = compile ps_1_1 PS_GlowAdvanced( Weight0, Weight1, Weight2, Weight3 );
		
		// Just use the color
		ColorArg1[0] = Diffuse;
		AlphaArg1[0] = Diffuse;
		ColorOp[0] = SelectArg1;
		AlphaOp[1] = SelectArg1;
    }
}

+ Code Snippet

// An empty material, which simply transforms the vertex and sets the color to white.

//------------------------------------
float4x4 matWorldViewProj : WorldViewProjection;

// Blur Offsets
float4 T0_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T1_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T2_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 T3_Offset = { 1.0f, 1.0f, 1.0f, 1.0f };

// Adverageing Weights
float4 Weight0 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight1 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight2 = { 1.0f, 1.0f, 1.0f, 1.0f };
float4 Weight3 = { 1.0f, 1.0f, 1.0f, 1.0f };

// Textures
texture AlphaTexture : Diffuse
<
	string ResourceName = "alpha.dds";
    string TextureType = "2D";
>;

//------------------------------------
struct vertexInput {
    float4 Position		: POSITION;
    float4 TexCoord0 	: TEXCOORD0;
};

struct vertexOutput {
    float4 HPosition 	: POSITION;
    float4 TexCoord0	: TEXCOORD0;
    float4 TexCoord1	: TEXCOORD1;
    float4 TexCoord2	: TEXCOORD2;
    float4 TexCoord3	: TEXCOORD3;
};

//------------------------------------
vertexOutput VS_GlowPattern( vertexInput IN, uniform float4 T0_Offset ) 
{
    vertexOutput OUT;
    // Transform Position -> Horizontal Clip Space
    OUT.HPosition = mul( matWorldViewProj, IN.Position );
   	
   	/* 	Altering this will change the output pattern calculated
   		within the pixel shader. Basically the futher the Offset
   		the more the texels will blur. */
   	OUT.TexCoord0 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord1 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord2 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord3 = IN.TexCoord0 + T0_Offset;
   	
    return OUT;
}

vertexOutput VS_GlowPatternAdvanced( vertexInput IN, 
							 		 uniform float4 T0_Offset,uniform float4 T1_Offset,
							 		 uniform float4 T2_Offset,uniform float4 T3_Offset ) 
{
    vertexOutput OUT;
    // Transform Position -> Horizontal Clip Space
    OUT.HPosition = mul( matWorldViewProj, IN.Position );
   	
   	/* 	Altering this will change the output pattern calculated
   		within the pixel shader. Unlike the basic version which
   		uses a simple single sample, this allows you to edit your
   		samples per texture target. */
   	OUT.TexCoord0 = IN.TexCoord0 + T0_Offset;
   	OUT.TexCoord1 = IN.TexCoord0 + T1_Offset;
   	OUT.TexCoord2 = IN.TexCoord0 + T2_Offset;
   	OUT.TexCoord3 = IN.TexCoord0 + T3_Offset;
   	
    return OUT;
}

//-----------------------------------

struct pixelInput
{
	float4 TexCoord0 : TEXCOORD0;
	float4 TexCoord1 : TEXCOORD1;
	float4 TexCoord2 : TEXCOORD2;
	float4 TexCoord3 : TEXCOORD3;
};

//-----------------------------------

sampler2D Tex0 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex1 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex2 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};
sampler2D Tex3 = sampler_state
{
    texture = (AlphaTexture);  
    AddressU = WRAP;
    AddressV = WRAP;
};

//-----------------------------------

float4 PS_Glow( pixelInput IN,uniform float4 Weight0 ) : COLOR
{
	float4 OUT;
	
	// Grab Colours from all the texture stages
	float4 t0 = tex2D( Tex0, IN.TexCoord0 );
	float4 t1 = tex2D( Tex1, IN.TexCoord1 );
	float4 t2 = tex2D( Tex2, IN.TexCoord2 );
	float4 t3 = tex2D( Tex3, IN.TexCoord3 );
	
	float4 temp;
	temp  =   Weight0 * t0;
	temp += ( Weight0 * t1 ); 
	temp += ( Weight0 * t2 );
	temp += ( Weight0 * t3 );
	
	return temp;
}

float4 PS_GlowAdvanced( pixelInput IN, 
						uniform float4 Weight0,uniform float4 Weight1,
						uniform float4 Weight2,uniform float4 Weight3 ) : COLOR
{
	float4 OUT;
	
	// Grab Colours from all the texture stages
	float4 t0 = tex2D( Tex0, IN.TexCoord0 );
	float4 t1 = tex2D( Tex1, IN.TexCoord1 );
	float4 t2 = tex2D( Tex2, IN.TexCoord2 );
	float4 t3 = tex2D( Tex3, IN.TexCoord3 );
	
	float4 temp;
	temp  =   Weight0 * t0;
	temp += ( Weight1 * t1 ); 
	temp += ( Weight2 * t2 );
	temp += ( Weight3 * t3 );
	
	return temp;
}

//-----------------------------------

technique StandardGlow
{
    pass p0 
    {		
		VertexShader = compile vs_1_1 VS_GlowPattern( T0_Offset );
		PixelShader  = compile ps_1_1 PS_Glow( Weight0 );
		
		// Just use the color
		ColorArg1[0] = Diffuse;
		AlphaArg1[0] = Diffuse;
		ColorOp[0] = SelectArg1;
		AlphaOp[1] = SelectArg1;
    }
}

technique StandardGlow
{
    pass p0 
    {		
		VertexShader = compile vs_1_1 VS_GlowPatternAdvanced( T0_Offset, T1_Offset, T2_Offset, T3_Offset );
		PixelShader  = compile ps_1_1 PS_GlowAdvanced( Weight0, Weight1, Weight2, Weight3 );
		
		// Just use the color
		ColorArg1[0] = Diffuse;
		AlphaArg1[0] = Diffuse;
		ColorOp[0] = SelectArg1;
		AlphaOp[1] = SelectArg1;
    }
}

have a tinker with that in FX Composer. it won't work atm, converting it over from my Cg version... always get mixxed up with the Samplers in HLSL though; in Cg you'd set them up in C.

but that's a full 1.1 with single pass; just uses multiple textures instead.

Back to top

Profile PM Email Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 2nd Jul 2004 12:18

Link

Hmmm, that's pretty much what I'm doing already, but using four textures in one pass rather than eight textures in two passes. In fact, my two-pass shader started life as a single-pass, four-sample shader, but the blur left too many artifacts to be useful.

The only real difference is that you've defined the texture offsets in a tweakable, while I've defined them as a constant within the shader itself.

Also, I don't quite see how the non-advanced technique is going to work. As far as I can tell, each of the four samples is given the same offset, meaning that it won't blur it at all. Still, I don't know much about HLSL, so I could be wrong...

Back to top

Profile PM Email

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 5th Jul 2004 15:57

Link

Could anyone please help with writing the shader similar to that used in Doom3, combining glossmap, normal map and diffuse map? I only need one directional light source and ambient light (fortuntately I can manage adjusting the parameters). Use any textures, I'll also be able to change that

DarkBasic code so that the shader would plug there would be greatly appreciated. Thanks a lot in advance to those who could help

all is fine!

Back to top

Profile PM Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 6th Jul 2004 07:38

Link

I can give it a go. I've already written a basic shader that uses normal maps, so I should be able to work from there.

Although, I'm not too sure about the glossmap - it's basically an environment map, right? I haven't used cube or sphere mapping before, so it would be a learning experience to get something like that working!

Oh, and I've figured out how the two-pass blur works in the samples I was looking at. Unfortunately, it seems to be done with render targets - the first pass would blur horizontally and render the output to a target texture, which would then be used by the second pass to blur vertically. Are render targets completely out of the question, or only those that pass the texture to DarkBasic instead of to the next pass?

Back to top

Profile PM Email

Shadow Robert

21

Years of Service

User Offline

Joined: 22nd Sep 2002

Location: Hertfordshire, England

Posted: 6th Jul 2004 08:25

Link

Tweaking the pattern Matt allows you to alter how the samples are combined together. This can either give different effects, or it cand give you more control over the number of effects.

I know that it is essencially what your already using, basically what i wanted to do was give you the HLSL version so you could tweak it further; you add in a function for a blur pass you can do it in 2 with 1.1 and 1 with 2.0 as you can define the vector in 2.0 Tex2D.

A rendertarget actually isn't anything special; infact all it is technically is a camera attached to a texture. You can simply alter the rendering output to your needs, ie ZDepth Render, Alpha Render, etc... So techically speaking your already using a Render Target in your example.

Basically pass back what you render, to that camera then pass it back into the shader for the second pass. If you need specialised things then as you update the shader first alter your scene to render 1frame how you need it then change everything back.

It is effectively how i did an object mask effect a year ago with the backbuffer; if you want full access to render targets, let me know and i'll post up an explaination on how to acces them from dbp as is.

Back to top

Profile PM Email Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 7th Jul 2004 07:26 Edited at: 7th Jul 2004 07:36

Link

@Raven
Thanks for the offer to help, but I'm fine at the moment. Actually, I don't plan to use the glow effect, or anything else that needs render targets in the game I'm working on. In fact, the most complex shader I'll be using is a combined bumpmap and depthmap shader for modelling realistic, 3D-looking debris and particle effects. I've already got one of each shader, but now I've just got to combine them. Should look pretty sw33t when it's done!

@Alexy
Well, it's only a quick attempt, and it might well be buggy, but I've had a go at your 'Doom III' shader:

float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldInverse;
float4x4 eyePos : ViewInverseTranspose;

//------------------------------------
// TWEAK HERE FOR THE LIGHT DIRECTION
//   (Normalised in shader)
float4 lightDir <> = {1.0f, 0.0f, 0.0f, 0.0f};

// TWEAK HERE TO CHANGE DIFFUSE TEXTURE
texture texMap
<
	string name = "Fieldstone.tga";
>;

// TWEAK HERE TO CHANGE NORMAL MAP
texture normMap
<
	string name = "FieldstoneNormal.tga";
>;

//------------------------------------
technique bumpmap
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <eyePos>;
		VertexShaderConstant[12] = <lightDir>;

VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			dcl_tangent		v3
			dcl_binormal	v4
			def c13, 1.0, 0.5, 0.0, 0.0

// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3
			
			// Output Texture Coordinates
			mov oT0, v2
			mov oT1, v2
			
			// Move Light Vector to Object Space
			mov r1, c12
			dp4 r0.x, r1, c4
			dp4 r0.y, r1, c5
			dp4 r0.z, r1, c6
			dp4 r0.w, r1, c7
			
			// Normalise Light Vector
			dp3 r1.w, r0, r0
			rsq r1.w, r1.w
			mul r0, r0, r1.w
			
			// Move Light Vector to Texture Space
			dp3 r1.x, r0, v3
			dp3 r1.y, r0, v4
			dp3 r1.z, r0, v1
			
			// Scale, Bias and Output Light Vector
			add r2, r1, c13.x
			mul oT2, r2, c13.y
			
			// Move Eye Position to Object Space
			mov r2, c11
			dp4 r0.x, r2, c4
			dp4 r0.y, r2, c5
			dp4 r0.z, r2, c6
			dp4 r0.w, r2, c7

// Compute Eye Vector
			sub r0, r0, v0
			
			// Normalise Eye Vector
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w
			
			// Move Eye Vector to Texture Space
			dp3 r0.x, r0, v3
			dp3 r0.y, r0, v4
			dp3 r0.z, r0, v1
			
			// Compute Half Vector
			add r0, r0, r1

// Normalise Half Vector
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w
			
			// Scale, Bias and Output Half Vector
			add r0, r0, c13.x
			mul oT3, r0, c13.y
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.4
			
			// TWEAK HERE TO CHANGE AMBIENT COLOUR
			//       R    G    B    A
			def c0, 0.1, 0.1, 0.1, 0.0
			
			// Read Texture Data
			texld r0, t0	
			texld r1, t1
			texcrd r2.xyz, t2
			texcrd r3.xyz, t3
			
			// Dot3 Bumpmapping
			dp3_sat r2, r1_bx2, r2_bx2
			dp3_sat r3, r1_bx2, r3_bx2
			
			// Scale Specular
			mul r3, r3, r3
			mul r3, r3, r3
			mul r3, r3, r3
			mul r3, r3, r3
			
			// Combine the Textures
			mad r0, r0, r2, r3
			
			// Add Ambient Light
			add r0, r0, c0
		};

Texture[0] = <texMap>;
		Texture[1] = <normMap>;
		
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
	}
}

+ Code Snippet

float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldInverse;
float4x4 eyePos : ViewInverseTranspose;

//------------------------------------
// TWEAK HERE FOR THE LIGHT DIRECTION
//   (Normalised in shader)
float4 lightDir <> = {1.0f, 0.0f, 0.0f, 0.0f};

// TWEAK HERE TO CHANGE DIFFUSE TEXTURE
texture texMap
<
	string name = "Fieldstone.tga";
>;

// TWEAK HERE TO CHANGE NORMAL MAP
texture normMap
<
	string name = "FieldstoneNormal.tga";
>;

//------------------------------------
technique bumpmap
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <eyePos>;
		VertexShaderConstant[12] = <lightDir>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			dcl_tangent		v3
			dcl_binormal	v4
			def c13, 1.0, 0.5, 0.0, 0.0

			// Transform Position to Clip
			dp4 oPos.x, v0, c0
			dp4 oPos.y, v0, c1
			dp4 oPos.z, v0, c2
			dp4 oPos.w, v0, c3
			
			// Output Texture Coordinates
			mov oT0, v2
			mov oT1, v2
			
			// Move Light Vector to Object Space
			mov r1, c12
			dp4 r0.x, r1, c4
			dp4 r0.y, r1, c5
			dp4 r0.z, r1, c6
			dp4 r0.w, r1, c7
			
			// Normalise Light Vector
			dp3 r1.w, r0, r0
			rsq r1.w, r1.w
			mul r0, r0, r1.w
			
			// Move Light Vector to Texture Space
			dp3 r1.x, r0, v3
			dp3 r1.y, r0, v4
			dp3 r1.z, r0, v1
			
			// Scale, Bias and Output Light Vector
			add r2, r1, c13.x
			mul oT2, r2, c13.y
			
			// Move Eye Position to Object Space
			mov r2, c11
			dp4 r0.x, r2, c4
			dp4 r0.y, r2, c5
			dp4 r0.z, r2, c6
			dp4 r0.w, r2, c7

			// Compute Eye Vector
			sub r0, r0, v0
			
			// Normalise Eye Vector
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w
			
			// Move Eye Vector to Texture Space
			dp3 r0.x, r0, v3
			dp3 r0.y, r0, v4
			dp3 r0.z, r0, v1
			
			// Compute Half Vector
			add r0, r0, r1

			// Normalise Half Vector
			dp3 r0.w, r0, r0
			rsq r0.w, r0.w
			mul r0, r0, r0.w
			
			// Scale, Bias and Output Half Vector
			add r0, r0, c13.x
			mul oT3, r0, c13.y
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.4
			
			// TWEAK HERE TO CHANGE AMBIENT COLOUR
			//       R    G    B    A
			def c0, 0.1, 0.1, 0.1, 0.0
			
			// Read Texture Data
			texld r0, t0	
			texld r1, t1
			texcrd r2.xyz, t2
			texcrd r3.xyz, t3
			
			// Dot3 Bumpmapping
			dp3_sat r2, r1_bx2, r2_bx2
			dp3_sat r3, r1_bx2, r3_bx2
			
			// Scale Specular
			mul r3, r3, r3
			mul r3, r3, r3
			mul r3, r3, r3
			mul r3, r3, r3
			
			// Combine the Textures
			mad r0, r0, r2, r3
			
			// Add Ambient Light
			add r0, r0, c0
		};

		Texture[0] = <texMap>;
		Texture[1] = <normMap>;
		
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
	}
}

Unfortunately, it's minus the gloss map that you asked for, but it does have specular bumpmapping to hopefully make up for that. As for tweaking, you can change the light direction by altering the lightDir float4 either by hand in the .FX file or by plugging it into a vector in DarkBasic. Also, you should be able to find the lines that point to textures up near the top too. The only other things you might want to change are the ambient colour, which can be found as a constant defined in the pixel shader, and the specular power. I'm not sure if it's the best way to do it, but the specular power is controlled by the four mul operations in the pixel shader - you won't be able to add any more, because I've hit the eight arithmetic instruction limit, but you can remove one or two of them to make the specular effect more pronounced.

I haven't had time to create a demo for you but, if you're having trouble getting it working, I'll knock one up for you. It shouldn't be too hard to make it work - all the non-tweakables are automatically set by DB.

I hope this is what you're looking for! If not, I can try to make a better one for you!

Back to top

Profile PM Email

alexey vlasov

19

Years of Service

User Offline

Joined: 28th May 2004

Location:

Posted: 7th Jul 2004 16:29 Edited at: 7th Jul 2004 16:32

Link

To Ninja Matt Diffuse texture don`t displayed

Glossmap texture is very need for best picture quwality.

P. s. Thanks for lot.

all is fine!

Back to top

Profile PM Website

Ninja Matt

19

Years of Service

User Offline

Joined: 5th Jun 2004

Location: Lincolnshire, UK

Posted: 8th Jul 2004 01:25

Link

But the bump texture and specular lighting work? That's a bit odd...

Although, if you really need the gloss map, I don't think I should be the one to make the shader for you - I still haven't gotten round to figuring out cubemaps, and my last attempt at using them was a bit of a failure.

Back to top

Profile PM Email

Final Epsilon

20

Years of Service

User Offline

Joined: 26th Jan 2004

Location: CA, USA

Posted: 18th Jul 2004 08:20

Link

hmmm... this was a useful thread, wonder why it died.

*bump*

Back to top

Profile PM Website

Sam Cameron

20

Years of Service

User Offline

Joined: 26th Dec 2003

Location: 0,0,0 I\'m the center of the world !!!

Posted: 18th Jul 2004 08:51

Link

do you want to see something really cool with shaders? try this:

http://www.virtools.com/downloads/vmo/head/Shaders_Demo.exe

when the users of darkbasic could use this technology? because I only see shaders from the original darkbasic software, but we can't use all the rest of the shaders of internet, that's stupid implementation and not very usefull only use 2 o 3 shaders when we have a directx 9.0 engine

Back to top

Profile PM

Neophyte

21

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 19th Jul 2004 00:49

Link

@SamCameron

"because I only see shaders from the original darkbasic software, but we can't use all the rest of the shaders of internet, that's stupid implementation and not very usefull only use 2 o 3 shaders when we have a directx 9.0 engine "

You obviously haven't looked at the second post in this thread. I've detailed how to get shaders working in DBPro. The only shaders you can't get to work right now are the ones that generate procedural textures. But they will eventually be added to DBPro.

I'm pretty sure that almost all of those shaders can be used by DBPro.

@Final Epsilon

"hmmm... this was a useful thread, wonder why it died."

I've been busy lately and haven't really gotten the time to post. On the bright side, I do have some good news regarding my next tutorial. I've managed to figuare out what I have to do in order to get the paticular effect working. Unfortunately, I need the vertex commands that are not "offically" in DBPro yet in order to achieve what I'm after.

I'd could probably use some known approximations, but that would limit the usefullness of what I'm trying to do and I don't want to do that. But I also don't want to delay this tutorial until patch 6 or whenever those vert manipulation commands are supposed to offically become apart of DBPro.

So it looks like I'm going to have to write the tutorial with the approximations and hope that that doesn't introduce too many unacceptable graphical glitches. Sometimes you just have to make do with what you have I guess.

Back to top

Profile PM

Sorry your browser is not supported!

DarkBASIC Professional Discussion / The Ultimate Shader Thread.