maya_phong.cgfx

// Copyright (C) 2012 Simon Otter
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//
// Loads into Maya using the bundled CGFX Shader Plugin.
// 

// Some notes about variable naming.
// - dir = direction
// - pos = position
// - tsdir & tspos = same but in tangent space.
// - osdir & ospos = same but in object space.

// ######################################################################
// UNIFORM PARAMETERS.
// ######################################################################

// An additive ambient term, set to black for no ambient.
float3 ambient : DIFFUSE
<
	string UIHelp = "Ambient";
> = {0.0, 0.0, 0.0};

texture diffuse_tex
<
	string ResourceType = "2D";
	string UIName =  "Diffuse Texture";
>;

texture normalmap_tex : NormalTexture
<
	string ResourceType = "2D";
	string UIName =  "Normal Map Texture";
>;

texture specular_tex
<
	string ResourceType = "2D";
	string UIName =  "Normal Map Texture";
>;

texture gloss_tex
<
	string ResourceType = "2D";
	string UIName = "Gloss Map Texture";
>;

texture emissive_tex
<
	string ResourceType = "2D";
	string UIName = "Emissive Map Texture";
>;

texture alpha_tex
<
	string ResourceType = "2D";
	string UIName = "Alpha Map";
>;

// LIGHT 1

float3 light1_pos : Position
<
	string UIHelp = "Light 1 Position";
> = {250, 250, -70};

float3 light1_color : DIFFUSE
<
	string UIName = "Light 1 Colour";
	string UIWidget = "Color";
> = {1.480, 1.470, 1.381};

// LIGHT 2

float3 light2_pos : POSITION
<
	string UIHelp = "Light 2 Position";
> = {160, 0, 670};

float3 light2_color : DIFFUSE
<
	string UIName = "Light 2 Colour";
	string UIWidget = "Color";
> = {0.650, 0.8, 1.25};

// TEXTURES.

sampler2D diffuse_tex_sampler  
<
	string UIName = "Diffuse Map";
> =
	sampler_state 
	{
		Texture = <diffuse_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

sampler2D normalmap_tex_sampler
<
	string UIName = "Normal Map";
> =
	sampler_state  
	{
		Texture = <normalmap_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

bool flip_y_normal
<
	string UIHelp = "Flip Y Normal (UDK, CryEngine etc.)";
> = false;

sampler2D specular_tex_sampler
<
	string UIName = "Specular Map";
> =
	sampler_state  
	{
		Texture = <specular_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

float gloss_multiplier
<
	string UIHelp = "Spec. Exponent scale";
	string UIWidget = "Slider";
	float UIMin = 0.01;
	float UIMax = 1.0;
> = 1;

sampler2D gloss_tex_sampler
<
	string UIName = "Gloss Map";
> =
	sampler_state  
	{
		Texture = <gloss_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

sampler2D emissive_tex_sampler
<
	string UIName = "Emissive Map";
> =
	sampler_state 
	{
		Texture = <emissive_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

sampler2D alpha_tex_sampler
<
	string UIName = "Alpha Map";
> =
	sampler_state 
	{
		Texture = <alpha_tex>;
		MinFilter = LinearMipMapLinear;
		MagFilter = Linear;
	};

//
// Provided by Maya for viewspace transform.
// object space -> clip space
//
float4x4 WorldViewProjXf : WorldViewProjection;
float4x4 WorldViewProjInverseXf : WorldViewProjectionInverse;
float4x4 WorldViewProjInverseTransposeXf : WorldViewProjectionInverseTranspose;
float4x4 WorldXf : World;
float4x4 WorldInverseXf : WorldInverse;
float4x4 ViewInverseXf : ViewInverse;

float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="none";>;
float4x4 ViewITXf : ViewInverseTranspose < string UIWidget="none";>;

// These control how the gloss map is interpreted. The gloss map is 
// averaged between the three channels and scaled to [0.0, 1.0]. The 
// result is used to interpolate between these extremes.

#define GLOSS_MIN_EXPONENT 1
#define GLOSS_MAX_EXPONENT 200

// ######################################################################
// INPUT STRUCTURES.
// ######################################################################

//
// This is Maya's derp structure, it feeds the vertex shader with this.
//
struct appdata
{
	float3 position 	: POSITION;
	float4 normal 		: NORMAL;
	float2 texCoord0 	: TEXCOORD0;
	float3 tangent 		: TEXCOORD1;
	float3 binormal 	: TEXCOORD2;
};


// ######################################################################
// HELPER FUNCS.
// ######################################################################

// Schlick's Approximation (WIP)
//float get_fresnel(float refindex, float3 light_dir, float3 view_dir)
//{
//	float f0 = pow((1 - refindex) / (1 + refindex), 2);
//
//	return f0 + (1 - f0) * pow(1 - dot(light_dir, dot(light_dir, v) / 2)), 5);
//}

// Calculates a lambert term.
inline float lambert(float3 l_dir, float3 normal)
{
	float l = dot(l_dir, normal);
	return max(l, 0);
}

// Finds the unit direction of l_pos from pos.
inline float3 direction(float3 pos, float3 l_pos)
{
	return normalize(l_pos - pos);
}

// ######################################################################
// PASS 1.
// ######################################################################

struct vertex_out
{
	// Clip-space.
	float4 position 	: POSITION;
	float2 texCoord0	: TEXCOORD0;
	// These are in object space.
	float3 ospos;
	// Tangent space.
	float3 camera_tsdir;
	float3 normal;

	// Transforms object -> tangent space.
	float3x3 tangent_transform;
};

vertex_out vertex_f(appdata IN)
{
	vertex_out OUT;

	OUT.position = mul(WorldViewProjXf, float4(IN.position, 1));

	OUT.tangent_transform = 
	float3x3(
		IN.tangent.xyz, 
		flip_y_normal? -IN.binormal.xyz : IN.binormal.xyz, 
		IN.normal.xyz
	);

	OUT.ospos = IN.position.xyz;
	OUT.texCoord0 = IN.texCoord0;
	
	OUT.camera_tsdir = normalize(mul(WorldViewProjInverseXf, float4(0, 0, 1, 1))).xyz;
	OUT.camera_tsdir = mul(OUT.tangent_transform, OUT.camera_tsdir);

	OUT.normal = mul(OUT.tangent_transform, IN.normal.xyz);

	return OUT;
}

float3 calculate_light_contrib(float lamb_term, float3 diffuse_map_term, float3 light_color)
{
	return (float3(lamb_term) * light_color.xyz) * diffuse_map_term;
}

float3 diffuse(float2 lamb_term, float2 texCoord)
{
	// Add the ambient term here, might not be strictly kosher but
	// gives a better looking ambient where the diffuse texture 
	// contributes.
	float3 diffuse_map_term = tex2D(diffuse_tex_sampler, texCoord);

	// light 1
	float3 light_contrib = calculate_light_contrib(lamb_term.x, diffuse_map_term.rgb, light1_color);
	// light 2
	light_contrib += calculate_light_contrib(lamb_term.y, diffuse_map_term, light2_color);

	float4 emissive = tex2D(emissive_tex_sampler, texCoord);
	if (emissive.r == 1.0 && emissive.g == 1.0 && emissive.b == 1.0 && emissive.a == 1.0)
	{
		emissive.a = 0.0;
	}

	return (emissive.a * emissive.rgb) + light_contrib + (ambient *  diffuse_map_term.rgb);
}

// Calculates a Phong specular term.
float3 phong(float3 light_dir, float3 light_col, float3 normal, float3 camera_dir, float2 texCoord)
{
	float3 light_reflect = reflect(light_dir, normal);
	// We use max here to remove highlights for surface points pointing away from the light.
	float light_to_camera_ang = max(dot(light_reflect, camera_dir), 0);

	float exponent = lerp(GLOSS_MIN_EXPONENT, GLOSS_MAX_EXPONENT, tex2D(gloss_tex_sampler, texCoord).r);
	exponent *= gloss_multiplier;

	// Technically, the light has a specular term too, but we don't care.
	return pow(light_to_camera_ang, exponent) * tex2D(specular_tex_sampler, texCoord) * light_col;
}

float4 fragment_f(vertex_out IN) : COLOR 
{
	// ospos is interpolated by the GPU here between the vertices,
	// so we must do the transform in the fragment shader.
	float3 tspos = mul(IN.tangent_transform, IN.ospos);

	float3 light1_tspos = mul(IN.tangent_transform, light1_pos);
	float3 light2_tspos = mul(IN.tangent_transform, light2_pos);

	float3 normal = IN.normal;

	// Todo: might be more efficient as tex2D(normalmap_tex_sampler, IN.texCoord0) * 2 - 1
	float3 mapped_normal = 
		lerp(
			float4(-1.0), 
			float4( 1.0), 
			tex2D(normalmap_tex_sampler, IN.texCoord0));

	float3 light1_tsdir = direction(tspos, light1_tspos);
	float3 light2_tsdir = direction(tspos, light2_tspos);	
	
	if (mapped_normal.x != 1.0 && mapped_normal.y != 1.0 && mapped_normal.z != 1.0) 
	// mostly true if no nmap assigned.
	{
		normal = mapped_normal.xyz;
	}

	float3 diff_term = diffuse(
		float2(
			lambert(
				light1_tsdir, 
				normal),
			lambert(
				light2_tsdir, 
				normal)
		),
		IN.texCoord0);

	float3 spec_term1 = phong(light1_tsdir, light1_color, normal, IN.camera_tsdir, IN.texCoord0);
	float3 spec_term2 = phong(light2_tsdir, light2_color, normal, IN.camera_tsdir, IN.texCoord0);

	float4 alpha = tex2D(alpha_tex_sampler, IN.texCoord0);

	return saturate(float4(diff_term + spec_term1 + spec_term2, alpha.r));
}

// ######################################################################
// TECHNIQUES.
// ######################################################################

technique main {
	pass p1 {
		VertexProgram = compile vs_3_0 vertex_f();
		DepthTestEnable = true;
		DepthMask = true;
		CullFaceEnable = False;
        CullFace = Back;
		FragmentProgram = compile ps_3_0 fragment_f();

		BlendEnable = true;
		BlendFunc = int2(SrcAlpha, OneMinusSrcAlpha);
		BlendFuncSeparate = int4( SrcAlpha, OneMinusSrcAlpha, One, OneMinusSrcAlpha);
		BlendEquationSeparate = int2( Add, Add );
		BlendColor = float4(1.0f,1.0f,1.0f,1.0f);
	}
}