Pages: [1] 2   Go Down
  Print  
Author Topic: Quest3D 5 import and shading issue !!  (Read 8386 times)
March 20, 2012, 05:32:13 pm
Since Q3D5 section have been removed i am posting it here.

First and worst is about importing mesh. I just used (Import and Conver to CGR) with its default setting to import a .DAE (40,000 Tri) from maya 2012 and the end result was horrible.
I import a same mesh in Q3D4 (Same shading) but same mesh in Q3D5 with Import and Conver to CGR was 6 ms slower than imported mesh from Q3D4 (There should not be any different at all). 6 ms  Shocked. Rather i did something wrong or we are facing a huge bug here.

Second issue is about tangent. I added tangent to my mesh but yet lighting result is a bit wrong (Normal map section perhaps). So remko or anyone else could you please take a look at my g-buffer code and see what might be the problem. In 4.3.2 its all working fine therefore i really have no idea what might be wrong.
Code:
int UseTangent : UseTangent;
int UseBiNormal : UseBiNormal;

float Tile_UV           :CHANNELVALUE0;
float Spec_Power        :CHANNELVALUE1;
float Spec_Glossiness   :CHANNELVALUE2;
float Material_ID       :CHANNELVALUE3;

float4x4 wvp            : WorldViewProjection ;
float4x4 wv             : WorldView;
float4x4 viewIT         : ViewInverseTranspose;
float4x4 worldIT        : WorldInverseTranspose;

texture Albedo_Spec : TEXTURE0
<
string ResourceType = "2D";
>;
 
sampler2D Albedo_Spec_Sampler = sampler_state
{
Texture = <Albedo_Spec>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};
 
texture Normal_Map : TEXTURE1
<
string ResourceType = "2D";
>;
 
sampler2D Normal_Map_Sampler = sampler_state
{
Texture = <Normal_Map>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};

// input from application to vertex shader
struct a2v {
float4 position : POSITION;
float2 texCoord : TEXCOORD0;
float4 tangent : TANGENT;
float4 binormal : BINORMAL;
float3 Normal       : NORMAL;


};

// output from vertex shader to pixel shader
struct v2f {
    float4 position        : POSITION;
float  Depth            : TEXCOORD0;
float3 Normal           : TEXCOORD1;
float2 texCoord    : TEXCOORD2;
float3 worldTangent   : TEXCOORD3;
    float3 worldBinormal : TEXCOORD4;
    float3 worldNormal   : TEXCOORD5;

};

// output from pixel shader
struct PixelShaderOut {
        float4 rtarget0 : COLOR0;
        float4 rtarget1 : COLOR1;
        float4 rtarget2 : COLOR2;
        float4 rtarget3 : COLOR3;
};

v2f av(a2v In)
{
v2f Out = (v2f)0;
Out.position = mul(In.position, wvp); //transform vert position to homogeneous clip space
float3 view_pos = mul(In.position, wv);
Out.Depth = view_pos.z;
// float3 World_Normal = mul(In.Normal, world);
// Out.Normal =  mul(World_Normal, viewIT);
Out.worldNormal = mul((mul(In.Normal, worldIT).xyz),viewIT);
Out.worldBinormal = mul((mul(In.binormal, worldIT).xyz),viewIT);
Out.worldTangent = mul((mul(In.tangent, worldIT).xyz),viewIT);

Out.texCoord = In.texCoord*Tile_UV;

return Out;
}

float2 SphereMapEncode2( float3 normal )
{
    float2 enc = normalize(normal.xy) * sqrt(normal.z*0.5f + 0.5f);
    enc = enc*0.5 + 0.5f;
    return enc;
}
// Pixel shaders
PixelShaderOut af(v2f In)
{
// Color 0:
float4 Albedo_Spec = tex2D(Albedo_Spec_Sampler, In.texCoord.xy);
float4 Normal_Map = tex2D(Normal_Map_Sampler, In.texCoord.xy);

float4 input1 = float4(In.Depth, 0, 0, 0);

// Color 1:
    Normal_Map.xyz = Normal_Map.xyz * 2 - 1; //expand to -1 to 1 range
float3 Nn = normalize(In.worldNormal); //input the vectors required for tangent to world space transform
float3 Tn = normalize(In.worldTangent);
float3 Bn = normalize(In.worldBinormal);
Normal_Map = float4((Nn * Normal_Map.z) + (Normal_Map.x * Tn + Normal_Map.y * -Bn), Normal_Map.w); //create a per-pixel normal for Y up

// float2 EncNormal = SphereMapEncode2(normalize(In.Normal.xyz));
float2 EncNormal = SphereMapEncode2(normalize(Normal_Map.xyz));
float4 input2 = float4 (EncNormal, 0,0);

// Color 2:
float Spec_Power_Out = Albedo_Spec.a * Spec_Power;
float4 input3 = float4(Albedo_Spec.rgb,Spec_Power_Out);

// Color 3:
float4 input4 = float4(0,0, Spec_Glossiness, Material_ID);

// Output Pixel Shader:
PixelShaderOut output;
output.rtarget0 = input1;
output.rtarget1 = input2;
output.rtarget2 = input3;
output.rtarget3 = input4;
return output;
}

technique GBuffer  
{  
pass pass0  
    {
VertexShader = compile vs_3_0 av();
ZEnable = TRUE;
ZWriteEnable = TRUE;
ZFunc = LESS;
StencilEnable = TRUE;
stencilfunc = ALWAYS;
StencilPass = REPLACE;
StencilFail = KEEP;
StencilZFail = KEEP;
StencilRef = 1;
PixelShader = compile ps_3_0 af();
}  

}    

Third issue is that my skin mesh did not draw at all.
Code:
// Application matrix inputs

int UseTangent : UseTangent;
int UseBiNormal : UseBiNormal;

float Spec_Power        :CHANNELVALUE0;
float Spec_Glossiness   :CHANNELVALUE1;
float Material_ID       :CHANNELVALUE2;

float4x4 wvp : WorldViewProjection ;
float4x4 wv : WorldView;
float4x4 world_to_clip : ViewProjection;
float4x4 world_to_view : View;

static const int MAX_MATRICES = 47; //amount of bones
float4x3 mWorldMatrixArray[MAX_MATRICES] : WORLDMATRIXARRAY;

texture Albedo_Spec : TEXTURE0
<
string ResourceType = "2D";
>;
 
sampler2D Albedo_Spec_Sampler = sampler_state
{
Texture = <Albedo_Spec>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};
 
texture Normal_Map : TEXTURE1
<
string ResourceType = "2D";
>;
 
sampler2D Normal_Map_Sampler = sampler_state
{
Texture = <Normal_Map>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};


// input from application to vertex shader
struct a2v{
float4 position : POSITION;
float4 blendWeights : BLENDWEIGHT;
float4 blendIndices : BLENDINDICES;
float3 Normal : NORMAL;
float2 texCoord : TEXCOORD0;
float3 tangent : TANGENT;
float3 binormal : BINORMAL;
};

//////////////////////////////////

struct v2f{
float4 position : POSITION;
float Depth : TEXCOORD0;
float3 Normal : TEXCOORD1;
float2 texCoord    : TEXCOORD2;
float3 worldTangent   : TEXCOORD3;
    float3 worldBinormal : TEXCOORD4;
    float3 worldNormal   : TEXCOORD5;

};

// output from pixel shader
struct PixelShaderOut {
        float4 rtarget0 : COLOR0;
        float4 rtarget1 : COLOR1;
        float4 rtarget2 : COLOR2;
        float4 rtarget3 : COLOR3;
};

v2f av(a2v In)
{
    v2f Out = (v2f)0;

float3 temp_pos = 0;

float weights[4] = (float[4])In.blendWeights;
weights[3] = 1.0f-weights[0]-weights[1]-weights[2];
int   index[4] = (int[4])In.blendIndices;
for (int i = 0; i < 4; i++)
   {
     temp_pos  += weights[i]*mul(In.position, mWorldMatrixArray[index[i]]);
Out.Normal += weights[i]*mul(In.Normal, (float3x3)mWorldMatrixArray[index[i]]);
   }
    Out.position = mul(float4(temp_pos,1), world_to_clip);

float3 view_pos = mul(float4(temp_pos,1), world_to_view);
Out.Depth = view_pos.z;

Out.worldNormal = mul( float4(In.Normal, 0), wv  ).xyz;
    Out.worldTangent = mul( float4(In.tangent, 0), wv ).xyz;
    Out.worldBinormal = mul( float4(In.binormal, 0), wv ).xyz;
Out.texCoord = In.texCoord;

return Out;
}

float2 SphereMapEncode2( float3 normal )
{
    float2 enc = normalize(normal.xy) * sqrt(normal.z*0.5f + 0.5f);
    enc = enc*0.5 + 0.5f;
    return enc;
}

// Pixel shaders
PixelShaderOut af(v2f In)
{
// Color 0:
float4 Albedo_Spec = tex2D(Albedo_Spec_Sampler, In.texCoord.xy);
float4 Normal_Map = tex2D(Normal_Map_Sampler, In.texCoord.xy);


float4 input1 = float4(In.Depth, 0, 0, 0);

// Color 1:
float3x3 matNormalView;
    matNormalView[0] = In.worldTangent;
    matNormalView[1] = In.worldBinormal;
    matNormalView[2] = In.worldNormal;

    Normal_Map.xyz = Normal_Map.xyz * 2 - 1; //expand to -1 to 1 range
    Normal_Map.xyz = mul(Normal_Map, matNormalView);
float2 EncNormal = SphereMapEncode2(normalize(Normal_Map.xyz));
float4 input2 = float4 (EncNormal, 0,0);

// Color 2:
float Spec_Power_Out = Normal_Map.a * Spec_Power;
float4 input3 = float4(Albedo_Spec.rgb,Spec_Power_Out);

// Color 3:
float4 input4 = float4(0,0, Spec_Glossiness, Material_ID);

// Output Pixel Shader:
PixelShaderOut output;
output.rtarget0 = input1;
output.rtarget1 = input2;
output.rtarget2 = input3;
output.rtarget3 = input4;
return output;
}

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

technique GBuffer { //Tech #1
pass pass0 {

ZEnable = TRUE;
ZWriteEnable = TRUE;
ZFunc = LESS;
StencilEnable = TRUE;
stencilfunc = ALWAYS;
StencilPass = REPLACE;
StencilFail = KEEP;
StencilZFail = KEEP;
StencilRef = 1;

VertexShader = compile vs_3_0 av();
PixelShader = compile ps_3_0 af();
}
}

ali-rahimi.net
March 20, 2012, 10:20:09 pm
did you made a test with 32bit version ? Concerning the rendering speed.

March 20, 2012, 10:32:20 pm
No. I did not. btw my 4.3.2 project in classic mode in both 64,32 is very slow. But in new interface its ok. Right now i am in this position  Frustrated

ali-rahimi.net
March 21, 2012, 09:58:10 am
If I remember correctly, you're not supposed to use:
Code:
int UseTangent : UseTangent;
int UseBiNormal : UseBiNormal;
in Quest3D 5. You just generate the tangents using a command and that's it. What might be the issue is that only tangents are generated. It is common practice to just form the binormal by a cross product of the normal and tangent in the pixel shader. (This saves per vertex data and if the first two are normalized, the cross product is also already normalized.)

So you'd get:
Code:
float3 Nn = normalize(In.worldNormal);
float3 Tn = normalize(In.worldTangent);
float3 Bn = cross(Nn, Tn); // No normalize, no input data needed
March 21, 2012, 10:05:37 am
I just checked my deferred it work in both setups.
It also has the same speed both in classic as well in OO mode.

March 21, 2012, 10:34:58 am
Thanks.
Well even without tangent lighting is wrong.

vs
Code:
float3 World_Normal = mul(In.Normal, (float3x3)world);
Out.Normal =  mul(World_Normal, (float3x3)viewIT);

ps
Code:
float2 EncNormal = SphereMapEncode2(normalize(In.Normal.xyz));

Problem might be in deferred calculation. Must check everything.  Lips Sealed

What about skin mesh?

ali-rahimi.net
March 21, 2012, 10:43:36 am
didn't tested yet

March 21, 2012, 11:02:32 am
I've only tested in beta's, but I also saw no issues or speed problems with our deferred setup.
March 21, 2012, 11:17:13 am
I did lots of stuff, now must check them all. we need skin mesh support with collada or fbx.

ali-rahimi.net
March 21, 2012, 12:02:18 pm
btw problem with normal happen if i recompile it, Otherwise if i open a last saved project (4.3.2) in ver 5 it works fine. So perhaps we are facing syntax issue with this new HLSL compiler. Any idea?

ali-rahimi.net
March 21, 2012, 12:19:34 pm
skinning with normal maps work for skinned mesh.
Just tested it.

see screenshot

btw. it is already possible to use skinned mesh in OO render setup. You just need to do some small handwork.


* Unbenannt.JPG (171.01 KB, 1407x672 - viewed 442 times.)

March 21, 2012, 12:22:19 pm
Do you get a compiled success messages ?

One idea about the bad performance in classic mode.
Did you disabled bones and so visualisation here (screenshot)


* Unbenannt.JPG (22.67 KB, 243x194 - viewed 838 times.)

March 21, 2012, 12:27:41 pm
Quote
skinning with normal maps work for skinned mesh.

Did you have to tweak the HLSL or did it work first time with a previous 4.3 example?

I'll have to wait until I get home but if you can, check with Viktor's normal mapped crab 'monster' (from his SSAO example). The last time I tried that model it still didn't work.
March 21, 2012, 12:32:16 pm
it works out of the box. More or less.

See the example in the Template Folder (OO mode)


* Unbenannt.JPG (23.84 KB, 253x319 - viewed 862 times.)

March 21, 2012, 01:01:20 pm
Do you get a compiled success messages ?

One idea about the bad performance in classic mode.
Did you disabled bones and so visualisation here (screenshot)


woow. Disabling Bones fixed performance issue in classic mode. Thanks alot micha  Grin
Yes sure it compiled but with several warning.
Original project from 4.3.2 after adding tangent works fine. but after recompiling normal goes wrong even after fixing all of those warning.

Original code
Code:
int UseTangent : UseTangent;
int UseBiNormal : UseBiNormal;

float Tile_UV           :CHANNELVALUE0;
float Spec_Power        :CHANNELVALUE1;
float Spec_Glossiness   :CHANNELVALUE2;
float Material_ID       :CHANNELVALUE3;

float4x4 wvp            : WorldViewProjection ;
float4x4 wv             : WorldView;
float4x4 viewIT         : ViewInverseTranspose;
float4x4 worldIT        : WorldInverseTranspose;
float4x4 PREVIOUS_WVP   : GLOBAL_PREVIOUS_WVP0;

texture Albedo_Spec : TEXTURE0
<
string ResourceType = "2D";
>;
 
sampler2D Albedo_Spec_Sampler = sampler_state
{
Texture = <Albedo_Spec>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};
 
texture Normal_Map : TEXTURE1
<
string ResourceType = "2D";
>;
 
sampler2D Normal_Map_Sampler = sampler_state
{
Texture = <Normal_Map>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};

// input from application to vertex shader
struct a2v {
float4 position : POSITION;
float2 texCoord : TEXCOORD0;
float4 tangent : TANGENT;
float4 binormal : BINORMAL;
float3 Normal       : NORMAL;


};

// output from vertex shader to pixel shader
struct v2f {
    float4 position        : POSITION;
float  Depth            : TEXCOORD0;
float3 Normal           : TEXCOORD1;
float2 texCoord     : TEXCOORD2;
float3 worldTangent  : TEXCOORD3;
    float3 worldBinormal : TEXCOORD4;
    float3 worldNormal    : TEXCOORD5;
float4 CURRENT_POS : TEXCOORD6;
float4 PREVIOUS_POS : TEXCOORD7;

};

// output from pixel shader
struct PixelShaderOut {
        float4 rtarget0 : COLOR0;
        float4 rtarget1 : COLOR1;
        float4 rtarget2 : COLOR2;
        float4 rtarget3 : COLOR3;
};

v2f av(a2v In)
{
v2f Out = (v2f)0;
Out.position = mul(In.position, wvp); //transform vert position to homogeneous clip space
float3 view_pos = mul(In.position, wv);
Out.Depth = view_pos.z;
// float3 World_Normal = mul(In.Normal, world);
// Out.Normal =  mul(World_Normal, viewIT);
Out.worldNormal = mul((mul(In.Normal, worldIT).xyz),viewIT);
Out.worldBinormal = mul((mul(In.binormal, worldIT).xyz),viewIT);
Out.worldTangent = mul((mul(In.tangent, worldIT).xyz),viewIT);

Out.texCoord = In.texCoord*Tile_UV;
Out.CURRENT_POS  = mul(In.position, wvp);
Out.PREVIOUS_POS = mul(In.position, PREVIOUS_WVP);

return Out;
}

float2 SphereMapEncode2( float3 normal )
{
    float2 enc = normalize(normal.xy) * sqrt(normal.z*0.5f + 0.5f);
    enc = enc*0.5 + 0.5f;
    return enc;
}
// Pixel shaders
PixelShaderOut af(v2f In)
{
// Color 0:
float4 Albedo_Spec = tex2D(Albedo_Spec_Sampler, In.texCoord.xy);
float4 Normal_Map = tex2D(Normal_Map_Sampler, In.texCoord.xy);


float4 input1 = float4(In.Depth, 0, 0, 0);

// Color 1:
    Normal_Map.xyz = Normal_Map.xyz * 2 - 1; //expand to -1 to 1 range
float3 Nn = normalize(In.worldNormal); //input the vectors required for tangent to world space transform
float3 Tn = normalize(In.worldTangent);
float3 Bn = normalize(In.worldBinormal);
Normal_Map = float4((Nn * Normal_Map.z) + (Normal_Map.x * Tn + Normal_Map.y * -Bn), Normal_Map.w); //create a per-pixel normal for Y up

// float2 EncNormal = SphereMapEncode2(normalize(In.Normal.xyz));
float2 EncNormal = SphereMapEncode2(normalize(Normal_Map.xyz));
float4 input2 = float4 (EncNormal, 0,0);

// Color 2:
float Spec_Power_Out = Albedo_Spec.a * Spec_Power;
float4 input3 = float4(Albedo_Spec.rgb,Spec_Power_Out);
// float4 input3 = float4(Spec_Power_Out,Spec_Power_Out,Spec_Power_Out,1);

// Color 3:
float2 VELOCITY = ((In.CURRENT_POS/In.CURRENT_POS.w)-(In.PREVIOUS_POS/In.PREVIOUS_POS.w));
           VELOCITY = VELOCITY*0.5+0.5;
float4 proxy2 = float4(0,0, Spec_Glossiness, Material_ID);
float4 input4 = proxy2;

// Output Pixel Shader:
PixelShaderOut output;
output.rtarget0 = input1;
output.rtarget1 = input2;
output.rtarget2 = input3;
output.rtarget3 = input4;
return output;
}

technique GBuffer 

pass pass0 
    {
VertexShader = compile vs_3_0 av();
ZEnable = TRUE;
ZWriteEnable = TRUE;
ZFunc = LESS;
StencilEnable = TRUE;
stencilfunc = ALWAYS;
StencilPass = REPLACE;
StencilFail = KEEP;
StencilZFail = KEEP;
StencilRef = 1;
PixelShader = compile ps_3_0 af();


}   

Edited in ver 5
Code:
int UseTangent : UseTangent;
int UseBiNormal : UseBiNormal;

float Tile_UV           :CHANNELVALUE0;
float Spec_Power        :CHANNELVALUE1;
float Spec_Glossiness   :CHANNELVALUE2;
float Material_ID       :CHANNELVALUE3;

float4x4 wvp            : WorldViewProjection ;
float4x4 wv             : WorldView;
float4x4 viewIT         : ViewInverseTranspose;
float4x4 worldIT        : WorldInverseTranspose;
float4x4 world : World;

texture Albedo_Spec : TEXTURE0
<
string ResourceType = "2D";
>;
 
sampler2D Albedo_Spec_Sampler = sampler_state
{
Texture = <Albedo_Spec>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};
 
texture Normal_Map : TEXTURE1
<
string ResourceType = "2D";
>;
 
sampler2D Normal_Map_Sampler = sampler_state
{
Texture = <Normal_Map>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = WRAP;
AddressV = WRAP;
};

// input from application to vertex shader
struct a2v {
float4 position : POSITION;
float2 texCoord : TEXCOORD0;
float4 tangent : TANGENT;
float4 binormal : BINORMAL;
float3 Normal       : NORMAL;


};

// output from vertex shader to pixel shader
struct v2f {
    float4 position        : POSITION;
float  Depth            : TEXCOORD0;
float3 Normal           : TEXCOORD1;
float2 texCoord     : TEXCOORD2;
float3 worldTangent  : TEXCOORD3;
    float3 worldBinormal : TEXCOORD4;
    float3 worldNormal    : TEXCOORD5;

};

// output from pixel shader
struct PixelShaderOut {
        float4 rtarget0 : COLOR0;
        float4 rtarget1 : COLOR1;
        float4 rtarget2 : COLOR2;
        float4 rtarget3 : COLOR3;
};

v2f av(a2v In)
{
v2f Out = (v2f)0;
Out.position = mul(In.position, wvp); //transform vert position to homogeneous clip space
float4 view_pos = mul(In.position, wv);
Out.Depth = view_pos.z;

// float3 World_Normal = mul(In.Normal, (float3x3)world);
// Out.Normal =  mul(World_Normal, (float3x3)viewIT);

Out.worldNormal = mul((mul(In.Normal, (float3x3)worldIT).xyz),(float3x3)viewIT);
Out.worldBinormal = mul((mul(In.binormal.xyz, (float3x3)worldIT).xyz),(float3x3)viewIT);
Out.worldTangent = mul((mul(In.tangent.xyz, (float3x3)worldIT).xyz),(float3x3)viewIT);

Out.texCoord = In.texCoord*Tile_UV;

return Out;
}

float2 SphereMapEncode2( float3 normal )
{
    float2 enc = normalize(normal.xy) * sqrt(normal.z*0.5f + 0.5f);
    enc = enc*0.5 + 0.5f;
    return enc;
}
// Pixel shaders
PixelShaderOut af(v2f In)
{
// Color 0:
float4 Albedo_Spec = tex2D(Albedo_Spec_Sampler, In.texCoord.xy);
float4 Normal_Map = tex2D(Normal_Map_Sampler, In.texCoord.xy);


float4 input1 = float4(In.Depth, 0, 0, 0);

// Color 1:
    Normal_Map.xyz = Normal_Map.xyz * 2 - 1; //expand to -1 to 1 range
float3 Nn = normalize(In.worldNormal); //input the vectors required for tangent to world space transform
float3 Tn = normalize(In.worldTangent);
float3 Bn = normalize(In.worldBinormal);
Normal_Map = float4((Nn * Normal_Map.z) + (Normal_Map.x * Tn + Normal_Map.y * -Bn), Normal_Map.w); //create a per-pixel normal for Y up

// float2 EncNormal = SphereMapEncode2(normalize(In.Normal.xyz));
float2 EncNormal = SphereMapEncode2(normalize(Normal_Map.xyz));
float4 input2 = float4 (EncNormal, 0,0);

// Color 2:
float Spec_Power_Out = Albedo_Spec.a * Spec_Power;
float4 input3 = float4(Albedo_Spec.rgb,Spec_Power_Out);

// Color 3:
float4 input4 = float4(0,0, Spec_Glossiness, Material_ID);

// Output Pixel Shader:
PixelShaderOut output;
output.rtarget0 = input1;
output.rtarget1 = input2;
output.rtarget2 = input3;
output.rtarget3 = input4;
return output;
}

technique GBuffer 

pass pass0 
    {
VertexShader = compile vs_3_0 av();
ZEnable = TRUE;
ZWriteEnable = TRUE;
ZFunc = LESS;
StencilEnable = TRUE;
stencilfunc = ALWAYS;
StencilPass = REPLACE;
StencilFail = KEEP;
StencilZFail = KEEP;
StencilRef = 1;
PixelShader = compile ps_3_0 af();


}   

ali-rahimi.net
Pages: [1] 2   Go Down
  Print  
 
Jump to: