Jump to content

  • Log In with Google      Sign In   
  • Create Account


Match OpenGL matrices with CgFX


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
4 replies to this topic

#1 Mexx Cuter   Members   -  Reputation: 122

Like
0Likes
Like

Posted 06 October 2008 - 10:48 PM

At this moment I'am kinda clueless on how to match the matrices in OpenGL with the ones in the CgFX shader. I'am new to it. - Using NVIDIA FX Composer 2.5 i created a Blinn_Bump CgFX shader. - Then I tried loading it into my application using OpenGL. At this point i got stuck with the matrices. I searched the forum to see if I could find some awnsers to my issue, but i couldn't. This is why I would like to ask for some help. Found link <- but it did not solve my problem I have the following:
	CGparameter cgWorldITXf = cgGetEffectParameterBySemantic(cgEffect, "WorldInverseTranspose");
	CGparameter cgWvpXf = cgGetEffectParameterBySemantic(cgEffect, "WorldViewProjection");
	CGparameter cgWorldXf =	cgGetEffectParameterBySemantic(cgEffect, "World");
	CGparameter cgViewIXf =	cgGetEffectParameterBySemantic(cgEffect, "ViewInverse");

	cgGLSetStateMatrixParameter(cgWorldITXf, CG_GL_MODELVIEW_MATRIX,CG_GL_MATRIX_INVERSE_TRANSPOSE);
	cgGLSetStateMatrixParameter(cgWvpXf, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
	cgGLSetStateMatrixParameter(cgWorldXf, CG_GL_MODELVIEW_MATRIX,  CG_GL_MATRIX_IDENTITY);
	cgGLSetStateMatrixParameter(cgViewIXf, CG_GL_MODELVIEW_MATRIX,  CG_GL_MATRIX_INVERSE);


1: How should i setup the matrices(WorldInverseTranspose, WorldViewProjection, World and ViewInverse ) using cgGLSetStateMatrixParameter? 2: If those are correctly set what could be the problem ? Can anyone point me in the correct direction or provide my with some code snippets? Thanks My shader looks like this:

float Script : STANDARDSGLOBAL <
    string UIWidget = "none";
    string ScriptClass = "object";
    string ScriptOrder = "standard";
    string ScriptOutput = "color";
    string Script = "Technique=Main;";
> = 0.8;

//// UN-TWEAKABLES - AUTOMATICALLY-TRACKED TRANSFORMS ////////////////

float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WvpXf : WorldViewProjection < string UIWidget="None"; >;
float4x4 WorldXf : World < string UIWidget="None"; >;
float4x4 ViewIXf : ViewInverse < string UIWidget="None"; >;

//// TWEAKABLE PARAMETERS ////////////////////

/// Point Lamp 0 ////////////
float3 Lamp0Pos : Position <
    string Object = "PointLight0";
    string UIName =  "Lamp 0 Position";
    string Space = "World";
> = {-0.5f,2.0f,1.25f};
float3 Lamp0Color : Specular <
    string UIName =  "Lamp 0";
    string Object = "Pointlight0";
    string UIWidget = "Color";
> = {1.0f,1.0f,1.0f};

// Ambient Light
float3 AmbiColor : Ambient <
    string UIName =  "Ambient Light";
    string UIWidget = "Color";
> = {0.07f,0.07f,0.07f};

float Ks <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.05;
    string UIName =  "Specular";
> = 0.4;

float Eccentricity <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.0001;
    string UIName =  "Highlight Eccentricity";
> = 0.3;


float Bump <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 3.0;
    float UIStep = 0.01;
    string UIName =  "Bumpiness";
> = 1.0; 

float Kr <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.01;
    string UIName =  "Reflection Strength";
> = 0.5;

//////// COLOR & TEXTURE /////////////////////


texture ColorTexture  <							
    string ResourceName = "D:\\Projects\\Pupil\\Empty_test\\Resources\\Rock.tga";
    string UIName =  "Diffuse Texture";
    string ResourceType = "2D";
>;

sampler2D ColorSampler = sampler_state {
    Texture = <ColorTexture>;
    MinFilter = LinearMipMapLinear;
    MagFilter = Linear;
    WrapS = Repeat;
    WrapT = Repeat;
}; 

texture NormalTexture <
    string ResourceName = "D:\\Projects\\Pupil\\Empty_test\\Resources\\RockNormal.tga";
    string UIName =  "Normal-Map Texture";
    string ResourceType = "2D";
>;

sampler2D NormalSampler = sampler_state {
    Texture = <NormalTexture>;
    MinFilter = LinearMipMapLinear;
    MagFilter = Linear;
    WrapS = Repeat;
    WrapT = Repeat;
}; 


//
// #define this macro to permit the import and use of shared shadow
//  maps created by COLLADA-FX. Make sure that the macro is defined
//  and the code recompile *before* executing "Convert to Collada-FX"!
//
// #define USE_SHARED_SHADOW

#ifdef USE_SHARED_SHADOW
#include "include/shadowMap.cgh"
DECLARE_SHADOW_XFORMS("SpotLight0",LampViewXf,LampProjXf,ShadowViewProjXf)
DECLARE_SHADOW_BIAS
DECLARE_SHADOW_MAPS(ColorShadTarget,ColorShadSampler,DepthShadTarget,DepthShadSampler)

float ShadDens <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.01;
    string UIName =  "Shadow Density";
> = 0.7;
#endif /* USE_SHARED_SHADOW */


//////// CONNECTOR DATA STRUCTURES ///////////

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

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
    float4 HPosition	: POSITION;
    float2 UV		: TEXCOORD0;
    // The following values are passed in "World" coordinates since
    //   it tends to be the most flexible and easy for handling
    //   reflections, sky lighting, and other "global" effects.
    float3 LightVec	: TEXCOORD1;
    float3 WorldNormal	: TEXCOORD2;
    float3 WorldTangent	: TEXCOORD3;
    float3 WorldBinormal : TEXCOORD4;
    float3 WorldView	: TEXCOORD5;
#ifdef USE_SHARED_SHADOW
    // This optional value expresses the current location in "light"
    //   coordinates for use with shadow mapping.
    float4 LProj	: LPROJ_COORD;
#endif /* USE_SHARED_SHADOW */
};
 
///////// VERTEX SHADING /////////////////////

/*********** Generic Vertex Shader ******/

vertexOutput std_VS(appdata IN) {
    vertexOutput OUT = (vertexOutput)0;
    OUT.WorldNormal = mul(WorldITXf,IN.Normal).xyz;
    OUT.WorldTangent = mul(WorldITXf,IN.Tangent).xyz;
    OUT.WorldBinormal = mul(WorldITXf,IN.Binormal).xyz;
    float4 Po = float4(IN.Position.xyz,1);
    float3 Pw = mul(WorldXf,Po).xyz;
    OUT.LightVec = (Lamp0Pos - Pw);
#ifdef FLIP_TEXTURE_Y
    OUT.UV = float2(IN.UV.x,(1.0-IN.UV.y));
#else /* !FLIP_TEXTURE_Y */
    OUT.UV = IN.UV.xy;
#endif /* !FLIP_TEXTURE_Y */
#ifdef USE_SHARED_SHADOW
    float4 Pl = mul(ShadowViewProjXf,Pw);  // "P" in light coords
    float4x4 BiasXf = make_bias_mat(ShadBias);
    OUT.LProj = mul(BiasXf,Pl);		// bias to make texcoord
#endif /* USE_SHARED_SHADOW */
    OUT.WorldView = normalize(float3(ViewIXf[0].w,ViewIXf[1].w,ViewIXf[2].w) - Pw);
    OUT.HPosition = mul(WvpXf,Po);
    return OUT;
}

///////// PIXEL SHADING //////////////////////

// Utility function for blinn shading

void blinn_shading(vertexOutput IN,
		    float3 LightColor,
		    float3 Nn,
		    float3 Ln,
		    float3 Vn,
		    out float3 DiffuseContrib,
		    out float3 SpecularContrib)
{
    float3 Hn = normalize(Vn + Ln);
    float hdn = dot(Hn,Nn);
    float3 R = reflect(-Ln,Nn);
    float rdv = dot(R,Vn);
    rdv = max(rdv,0.001);
    float ldn=dot(Ln,Nn);
    ldn = max(ldn,0.0);
    float ndv = dot(Nn,Vn);
    float hdv = dot(Hn,Vn);
    float eSq = Eccentricity*Eccentricity;
    float distrib = eSq / (rdv * rdv * (eSq - 1.0) + 1.0);
    distrib = distrib * distrib;
    float Gb = 2.0 * hdn * ndv / hdv;
    float Gc = 2.0 * hdn * ldn / hdv;
    float Ga = min(1.0,min(Gb,Gc));
    float fresnelHack = 1.0 - pow(ndv,5.0);
    hdn = distrib * Ga * fresnelHack / ndv;
    DiffuseContrib = ldn * LightColor;
    SpecularContrib = hdn * Ks * LightColor;
}

float4 std_PS(vertexOutput IN) : COLOR {
    float3 diffContrib;
    float3 specContrib;
    float3 Ln = normalize(IN.LightVec);
    float3 Vn = normalize(IN.WorldView);
    float3 Nn = normalize(IN.WorldNormal);
    float3 Tn = normalize(IN.WorldTangent);
    float3 Bn = normalize(IN.WorldBinormal);
    float3 bump = Bump * (tex2D(NormalSampler,IN.UV).rgb - float3(0.5,0.5,0.5));
    Nn = Nn + bump.x*Tn + bump.y*Bn;
    Nn = normalize(Nn);
	blinn_shading(IN,Lamp0Color,Nn,Ln,Vn,diffContrib,specContrib);
    float3 diffuseColor = tex2D(ColorSampler,IN.UV).rgb;
#ifdef USE_SHARED_SHADOW
    float shadowed = tex2Dproj(DepthShadSampler,IN.LProj).x;
	float faded = 1.0-(ShadDens*(1.0-shadowed));
	diffContrib *= faded;
	specContrib *= shadowed;
#endif /* USE_SHARED_SHADOW */
    float3 result = specContrib+(diffuseColor*(diffContrib+AmbiColor));
    return float4(result,1);
}

///// TECHNIQUES /////////////////////////////

technique Main <
	string Script = "Pass=p0;";
> {
    pass p0 <
	string Script = "Draw=geometry;";
    > {
        VertexProgram = compile vp40 std_VS();
		DepthTestEnable = true;
		DepthMask = true;
		CullFaceEnable = false;
		BlendEnable = false;
		DepthFunc = LEqual;
        FragmentProgram = compile fp40 std_PS();
    }
}

/////////////////////////////////////// eof //


My code to which tries to load the shader looks like this:
	const char* file = "Resources//Blinn_bump_reflect.cgfx";
	// construct cgContext so we can use it to load CgFX shaders.
	cgContext = cgCreateContext();
	cgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);			// Get The Latest GL Vertex Profile
	cgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);		// Get The Latest GL Fragment Profile
	cgGLSetOptimalOptions(cgVertexProfile);
	cgGLSetOptimalOptions(cgFragmentProfile);	
	cgGLRegisterStates(cgContext);
	cgGLSetManageTextureParameters(cgContext, CG_TRUE);

	cgProgram = cgCreateProgramFromFile(cgContext, CG_SOURCE, file, cgVertexProfile, "std_VS", 0);
	cgGLLoadProgram(cgProgram);

	// load effect from file
	cgEffect = cgCreateEffectFromFile(cgContext, file, NULL);

	if(!cgEffect)
	{
		OutputDebugString(cgGetLastListing( cgContext ));
		return false;
	}

	// Get valid techique
	cgTechnique = cgGetFirstTechnique(cgEffect);
	while (cgTechnique && cgValidateTechnique(cgTechnique) == CG_FALSE)
	{		
		// get next technique
		cgTechnique = cgGetNextTechnique(cgTechnique);
	}
	CGparameter cgParamSampler2D, cgTextureParam;
	CGstateassignment cgSamplerStateAssignment;
	CGannotation cgTextureAnnotation;

	cgParamSampler2D = cgGetNamedEffectParameter(cgEffect, "ColorSampler");
	cgSamplerStateAssignment = cgGetNamedSamplerStateAssignment(cgParamSampler2D, "Texture");
	cgTextureParam = cgGetTextureStateAssignmentValue(cgSamplerStateAssignment);
	cgTextureAnnotation = cgGetNamedParameterAnnotation(cgTextureParam, "ResourceName");	
	const char* name = cgGetStringAnnotationValue(cgTextureAnnotation);
	LoadTexture(std::string(name), &g_TextureDiffuse);
	cgGLSetupSampler(cgParamSampler2D, g_TextureDiffuse)

	cgParamSampler2D = cgGetNamedEffectParameter(cgEffect, "NormalSampler");
	cgSamplerStateAssignment = cgGetNamedSamplerStateAssignment(cgParamSampler2D, "Texture");
	cgTextureParam = cgGetTextureStateAssignmentValue(cgSamplerStateAssignment);
	cgTextureAnnotation = cgGetNamedParameterAnnotation(cgTextureParam, "ResourceName");	
	LoadTexture(std::string(cgGetStringAnnotationValue(cgTextureAnnotation)), &g_TextureNormal);	
	cgGLSetupSampler(cgParamSampler2D, g_TextureNormal);


	CGparameter cgWorldITXf =	cgGetEffectParameterBySemantic(cgEffect, "WorldInverseTranspose");
	CGparameter cgWvpXf =		cgGetEffectParameterBySemantic(cgEffect, "WorldViewProjection");
	CGparameter cgWorldXf =		cgGetEffectParameterBySemantic(cgEffect, "World");
	CGparameter cgViewIXf =		cgGetEffectParameterBySemantic(cgEffect, "ViewInverse");

	cgGLSetStateMatrixParameter(cgWorldITXf,	CG_GL_MODELVIEW_MATRIX,	CG_GL_MATRIX_INVERSE_TRANSPOSE);
	cgGLSetStateMatrixParameter(cgWvpXf,		CG_GL_MODELVIEW_PROJECTION_MATRIX,	CG_GL_MATRIX_IDENTITY);
	cgGLSetStateMatrixParameter(cgWorldXf,		CG_GL_MODELVIEW_MATRIX,  CG_GL_MATRIX_IDENTITY);
	cgGLSetStateMatrixParameter(cgViewIXf,		CG_GL_MODELVIEW_MATRIX,  CG_GL_MATRIX_INVERSE);



My code which tries to draw the scene looks like this:
	// Bind shader program
	cgGLBindProgram( cgProgram);
	// Render
	CGpass pass = cgGetFirstPass( cgTechnique );
	while (pass) 
	{
		cgSetPassState(pass);
		
		//DrawGeometry
		glBegin(GL_TRIANGLE_STRIP);				
			
			if (bIsTextured) {		glTexCoord2f(-1.0f, 1.0f);				}
			else			 {		glColor4f(0.0f,1.0f,0.0f,0.0f);			}
			glVertex3f(-1000, -10.0f, 1000);

			
			if (bIsTextured) {		glTexCoord2f(-1.0f, -1.0f);				}
			else			 {		glColor4f(1.0f,1.0f,1.0f,0.0f);			}
			glVertex3f(-1000, -10.0f,-1000);			

			
			if (bIsTextured) {		glTexCoord2f(1.0f, 1.0f);				}
			else			 {		glColor4f(1.0f,0.0f,1.0f,0.0f);			}
			glVertex3f( 1000, -10.0f, 1000);

			
			if (bIsTextured) {		glTexCoord2f(1.0f, -1.0f);				}
			else			 {		glColor4f(0.0f,0.0f,1.0f,0.0f);			}
			glVertex3f( 1000, -10.0f,-1000);			
		glEnd();

		cgResetPassState(pass);
		pass = cgGetNextPass(pass);
	}
	cgGLUnbindProgram( cgVertexProfile );


[Edited by - Mexx Cuter on October 8, 2008 9:32:58 AM]

Sponsor:

#2 D3DXVECTOR3   Members   -  Reputation: 147

Like
0Likes
Like

Posted 06 October 2008 - 11:44 PM

If i'm not mistaken you have to set the matrices each time you draw:

bind program
set matrices, textures etc
set pass
draw
end pass

btw in CgFX you can use opengl matrixes from the state:
state.matrix.mvp
state.matrix.wordview[x]
state.matrix....

see doc for more information

#3 Mexx Cuter   Members   -  Reputation: 122

Like
0Likes
Like

Posted 07 October 2008 - 01:08 AM

Thank you for replying.

I tried both options the matrices within the shader and within the OpenGL app.
Is setting the matrices in the Cg file itself the prefered method to use?

What I don't yet understand is which matrices i should use to set the shader matrices, Can you tell me or how can i find out?(I'am not that good with matrices)

Code within shader( found table 13-float4x4 state semantics in the CG_Usermanual.book.pdf ):

vertexOutput std_VS(appdata IN) {
vertexOutput OUT = (vertexOutput)0;

//#ifdef PROFILE_ARBVP1
WorldITXf = glstate.matrix.invtrans.modelview[0];
WvpXf = glstate.matrix.mvp;
WorldXf = glstate.matrix.modelview[0];
ViewIXf = glstate.matrix.inverse.projection;
//#endif

OUT.WorldNormal = mul(WorldITXf,IN.Normal).xyz;
OUT.WorldTangent = mul(WorldITXf,IN.Tangent).xyz;
OUT.WorldBinormal = mul(WorldITXf,IN.Binormal).xyz;
float4 Po = float4(IN.Position.xyz,1);
float3 Pw = mul(WorldXf,Po).xyz;
OUT.LightVec = (Lamp0Pos - Pw);
#ifdef FLIP_TEXTURE_Y
OUT.UV = float2(IN.UV.x,(1.0-IN.UV.y));
#else /* !FLIP_TEXTURE_Y */
OUT.UV = IN.UV.xy;
#endif /* !FLIP_TEXTURE_Y */
#ifdef USE_SHARED_SHADOW
float4 Pl = mul(ShadowViewProjXf,Pw); // "P" in light coords
float4x4 BiasXf = make_bias_mat(ShadBias);
OUT.LProj = mul(BiasXf,Pl); // bias to make texcoord
#endif /* USE_SHARED_SHADOW */
OUT.WorldView = normalize(float3(ViewIXf[0].w,ViewIXf[1].w,ViewIXf[2].w) - Pw);
OUT.HPosition = mul(WvpXf,Po);
return OUT;
}





In my code I set the vertex profile to CG_PROFILE_ARBVP1 and the fragment profile to CG_PROFILE_ARBFP1.



EDIT:

Can anybody give me a hint on how the matrices should be set in OpenGL before drawing geometry. Everywhere I look on the internet I found the matrices setup below, if these are correct what could be the problem(my shader isn't visible, it's black)?


CGparameter cgWorldITXf = cgGetEffectParameterBySemantic(cgEffect, "WorldInverseTranspose");
CGparameter cgWvpXf = cgGetEffectParameterBySemantic(cgEffect, "WorldViewProjection");
CGparameter cgWorldXf = cgGetEffectParameterBySemantic(cgEffect, "World");
CGparameter cgViewIXf = cgGetEffectParameterBySemantic(cgEffect, "ViewInverse");

cgGLSetStateMatrixParameter(cgWorldITXf, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE );
cgGLSetStateMatrixParameter(cgWvpXf, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(cgWorldXf, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(cgViewIXf, CG_GL_PROJECTION_MATRIX, CG_GL_MATRIX_INVERSE);





Could anybody give me a Hint ?

[Edited by - Mexx Cuter on October 8, 2008 9:08:14 AM]

#4 D3DXVECTOR3   Members   -  Reputation: 147

Like
0Likes
Like

Posted 08 October 2008 - 07:08 AM

Are you sure you dont have any other error in the shader, i mean does it build in FX Composer?

Post your complete shader and will take a look into it. If you not seeing anything it usually means shader compile error or an incorrect matrix.

#5 Mexx Cuter   Members   -  Reputation: 122

Like
0Likes
Like

Posted 08 October 2008 - 10:28 PM

It is actually the default blinn_bump_reflect shader from FX composer.
The code below seems to work in FX Composer.

Here is the version I work with. Some parts are commented..those are things I tried. And I do update the matrices after positions have been updated and before geometry is drawn.



float Script : STANDARDSGLOBAL <
string UIWidget = "none";
string ScriptClass = "object";
string ScriptOrder = "standard";
string ScriptOutput = "color";
string Script = "Technique=Main;";
> = 0.8;

//// UN-TWEAKABLES - AUTOMATICALLY-TRACKED TRANSFORMS ////////////////

float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WvpXf : WorldViewProjection < string UIWidget="None"; >;
float4x4 WorldXf : World < string UIWidget="None"; >;
float4x4 ViewIXf : ViewInverse < string UIWidget="None"; >;
//uniform float4x4 WorldITXf : state.matrix.modelview.invtrans;
//uniform float4x4 WvpXf : state.matrix.mvp;
//uniform float4x4 WorldXf : state.matrix.modelview[0];
//uniform float4x4 ViewIXf : state.matrix.projection.inverse;

//// TWEAKABLE PARAMETERS ////////////////////

/// Point Lamp 0 ////////////
float3 Lamp0Pos : Position <
string Object = "PointLight0";
string UIName = "Lamp 0 Position";
string Space = "World";
//> = {-0.5f,2.0f,1.25f};
> = {0.0f,100.0f,0.0f};
float3 Lamp0Color : Specular <
string UIName = "Lamp 0";
string Object = "Pointlight0";
string UIWidget = "Color";
> = {1.0f,1.0f,1.0f};

// Ambient Light
float3 AmbiColor : Ambient <
string UIName = "Ambient Light";
string UIWidget = "Color";
> = {0.07f,0.07f,0.07f};

float Ks <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.05;
string UIName = "Specular";
> = 0.4;

float Eccentricity <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.0001;
string UIName = "Highlight Eccentricity";
> = 0.3;


float Bump <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 3.0;
float UIStep = 0.01;
string UIName = "Bumpiness";
> = 1.0;

float Kr <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.01;
string UIName = "Reflection Strength";
> = 0.5;

//////// COLOR & TEXTURE /////////////////////


texture ColorTexture <
//"default_color.dds";
string ResourceName = "Resources//Rock.tga";
string UIName = "Diffuse Texture";
string ResourceType = "2D";
>;

sampler2D ColorSampler = sampler_state {
Texture = <ColorTexture>;
MinFilter = LinearMipMapLinear;
MagFilter = Linear;
WrapS = Repeat;
WrapT = Repeat;
};

texture NormalTexture <
string ResourceName = "Resources//RockNormal.tga";
string UIName = "Normal-Map Texture";
string ResourceType = "2D";
>;

sampler2D NormalSampler = sampler_state {
Texture = <NormalTexture>;
MinFilter = LinearMipMapLinear;
MagFilter = Linear;
WrapS = Repeat;
WrapT = Repeat;
};


//
// #define this macro to permit the import and use of shared shadow
// maps created by COLLADA-FX. Make sure that the macro is defined
// and the code recompile *before* executing "Convert to Collada-FX"!
//
// #define USE_SHARED_SHADOW

#ifdef USE_SHARED_SHADOW
#include "include/shadowMap.cgh"
DECLARE_SHADOW_XFORMS("SpotLight0",LampViewXf,LampProjXf,ShadowViewProjXf)
DECLARE_SHADOW_BIAS
DECLARE_SHADOW_MAPS(ColorShadTarget,ColorShadSampler,DepthShadTarget,DepthShadSampler)

float ShadDens <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.01;
string UIName = "Shadow Density";
> = 0.7;
#endif /* USE_SHARED_SHADOW */


//////// CONNECTOR DATA STRUCTURES ///////////

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

/* data passed from vertex shader to pixel shader */
struct vertexOutput {
float4 HPosition : POSITION;
float2 UV : TEXCOORD0;
// The following values are passed in "World" coordinates since
// it tends to be the most flexible and easy for handling
// reflections, sky lighting, and other "global" effects.
float3 LightVec : TEXCOORD1;
float3 WorldNormal : TEXCOORD2;
float3 WorldTangent : TEXCOORD3;
float3 WorldBinormal : TEXCOORD4;
float3 WorldView : TEXCOORD5;
#ifdef USE_SHARED_SHADOW
// This optional value expresses the current location in "light"
// coordinates for use with shadow mapping.
float4 LProj : LPROJ_COORD;
#endif /* USE_SHARED_SHADOW */
};

///////// VERTEX SHADING /////////////////////

/*********** Generic Vertex Shader ******/

vertexOutput std_VS(appdata IN) {
vertexOutput OUT = (vertexOutput)0;

//WorldITXf = glstate.matrix.invtrans.modelview[0];
//WvpXf = glstate.matrix.mvp;
//WorldXf = glstate.matrix.modelview[0];
//ViewIXf = glstate.matrix.inverse.projection;


OUT.WorldNormal = mul(WorldITXf,IN.Normal).xyz;
OUT.WorldTangent = mul(WorldITXf,IN.Tangent).xyz;
OUT.WorldBinormal = mul(WorldITXf,IN.Binormal).xyz;
float4 Po = float4(IN.Position.xyz,1);
float3 Pw = mul(WorldXf,Po).xyz;
OUT.LightVec = (Lamp0Pos - Pw);
#ifdef FLIP_TEXTURE_Y
OUT.UV = float2(IN.UV.x,(1.0-IN.UV.y));
#else /* !FLIP_TEXTURE_Y */
OUT.UV = IN.UV.xy;
#endif /* !FLIP_TEXTURE_Y */
//#ifdef USE_SHARED_SHADOW
// float4 Pl = mul(ShadowViewProjXf,Pw); // "P" in light coords
// float4x4 BiasXf = make_bias_mat(ShadBias);
// OUT.LProj = mul(BiasXf,Pl); // bias to make texcoord
//#endif /* USE_SHARED_SHADOW */
OUT.WorldView = normalize(float3(ViewIXf[0].w,ViewIXf[1].w,ViewIXf[2].w) - Pw);
OUT.HPosition = mul(WvpXf,Po);
return OUT;
}

///////// PIXEL SHADING //////////////////////

// Utility function for blinn shading

void blinn_shading(vertexOutput IN,
float3 LightColor,
float3 Nn,
float3 Ln,
float3 Vn,
out float3 DiffuseContrib,
out float3 SpecularContrib)
{
float3 Hn = normalize(Vn + Ln);
float hdn = dot(Hn,Nn);
float3 R = reflect(-Ln,Nn);
float rdv = dot(R,Vn);
rdv = max(rdv,0.001);
float ldn=dot(Ln,Nn);
ldn = max(ldn,0.0);
float ndv = dot(Nn,Vn);
float hdv = dot(Hn,Vn);
float eSq = Eccentricity*Eccentricity;
float distrib = eSq / (rdv * rdv * (eSq - 1.0) + 1.0);
distrib = distrib * distrib;
float Gb = 2.0 * hdn * ndv / hdv;
float Gc = 2.0 * hdn * ldn / hdv;
float Ga = min(1.0,min(Gb,Gc));
float fresnelHack = 1.0 - pow(ndv,5.0);
hdn = distrib * Ga * fresnelHack / ndv;
DiffuseContrib = ldn * LightColor;
SpecularContrib = hdn * Ks * LightColor;
}

float4 std_PS(vertexOutput IN) : COLOR {
float3 diffContrib;
float3 specContrib;
float3 Ln = normalize(IN.LightVec);
float3 Vn = normalize(IN.WorldView);
float3 Nn = normalize(IN.WorldNormal);
float3 Tn = normalize(IN.WorldTangent);
float3 Bn = normalize(IN.WorldBinormal);
float3 bump = Bump * (tex2D(NormalSampler,IN.UV).rgb - float3(0.5,0.5,0.5));
Nn = Nn + bump.x*Tn + bump.y*Bn;
Nn = normalize(Nn);
blinn_shading(IN,Lamp0Color,Nn,Ln,Vn,diffContrib,specContrib);
float3 diffuseColor = tex2D(ColorSampler,IN.UV).rgb;
//#ifdef USE_SHARED_SHADOW
// float shadowed = tex2Dproj(DepthShadSampler,IN.LProj).x;
// float faded = 1.0-(ShadDens*(1.0-shadowed));
// diffContrib *= faded;
// specContrib *= shadowed;
//#endif /* USE_SHARED_SHADOW */
float3 result = specContrib+(diffuseColor*(diffContrib+AmbiColor));
return float4(result,1);
}

///// TECHNIQUES /////////////////////////////

technique Main <
string Script = "Pass=p0;";
> {
pass p0 <
string Script = "Draw=geometry;";
> {
VertexProgram = compile vp40 std_VS();
DepthTestEnable = true;
DepthMask = true;
CullFaceEnable = false;
BlendEnable = false;
DepthFunc = LEqual;
FragmentProgram = compile fp40 std_PS();
}
}

/////////////////////////////////////// eof //





EDIT:

Guess I forgot to set the Appdata IN?
When I added the following code inside opengl before geometry is drawn the shader seem to work like in FXComposer.


cgParamPosition = cgGetNamedParameter(cgProgram, "IN.Position");
cgParamTexCoord = cgGetNamedParameter(cgProgram, "IN.UV");
cgParamNormal = cgGetNamedParameter(cgProgram, "IN.Normal");
cgParamTangent = cgGetNamedParameter(cgProgram, "IN.Tangent");
cgParamBiNormal = cgGetNamedParameter(cgProgram, "IN.Binormal");

cgGLSetParameter3f(cgParamPosition, 1.0f, 0.0f, 0.0f);
cgGLSetParameter4f(cgParamTexCoord, 0.0f, 0.0f, 0.0f, 0.0f);
cgGLSetParameter4f(cgParamNormal, 0.0f, 1.0f, 0.0f, 0.0f);
cgGLSetParameter4f(cgParamTangent, 0.0f, 0.0f, 1.0f, 0.0f);
cgGLSetParameter4f(cgParamBiNormal, 1.0f, 0.0f, 0.0f, 0.0f);



[Edited by - Mexx Cuter on October 10, 2008 6:28:01 AM]




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS