Sorry your browser is not supported!

set object transparency 1,1

technique t_add
{
pass p0
{
VertexShader = compile vs_2_0 DefaultVertexShader();
PixelShader = compile ps_2_0 DefaultPixelShader();
AlphaBlendEnable = TRUE;
BlendOp = ADD;
SrcBlend = SRCALPHA;
DestBlend = INVSRCALPHA;
}
}

struct
{
...
float4 Color : COLOR0;     
...
};

float4x4 WorldViewProj : WorldViewProjection;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;
float4 AmbientColor = float4(1, 1, 1, 1);
float AmbientIntensity = 0.5;

sampler BaseSamp = sampler_state
{
	Texture = <BaseTex>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

struct vs_in
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
};

vs_out DefaultVertexShader( vs_in IN )
{
	vs_out OUT;
	
	OUT.pos = mul( IN.pos, WorldViewProj );
	OUT.uv = IN.uv;
	
	return OUT;
}

float4 DefaultPixelShader( vs_out IN ) : COLOR
{
	return tex2D(BaseSamp,IN.uv)*AmbientColor*AmbientIntensity;
}

technique MyShader
{
	pass p0
	{
		VertexShader = compile vs_1_1 DefaultVertexShader( );
		PixelShader = compile ps_1_1 DefaultPixelShader( );
	}
}

matrix WorldViewProj : WorldViewProjection;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;
float3 AmbientColor = float3(1.0, 1.0, 0.0); // 0.0-1.0 = 0-255 where 0.5 = 127
float AmbientIntensity = 0.2;

sampler BaseSamp = sampler_state
{
        Texture = <BaseTex>;
};

struct vs_in
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        float2 uv1 : TEXCOORD1;
};

struct vs_out
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        float valpha : TEXCOORD1;
};

vs_out DefaultVertexShader(vs_in IN)
{
        vs_out OUT;
        OUT.pos = mul(IN.pos, WorldViewProj);
        OUT.uv0 = IN.uv0;
        OUT.valpha = IN.uv1.x; // vertex alpha
        return OUT;
}

float4 DefaultPixelShader(vs_out IN) : COLOR
{
        float4 texcolor = tex2D(BaseSamp,IN.uv0); // texcolor.a as texture alpha
        return float4(texcolor.rgb+AmbientColor*AmbientIntensity,IN.valpha);
}

technique MyShader
{
        pass p0
        {
                VertexShader = compile vs_2_0 DefaultVertexShader();
                PixelShader = compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable = TRUE;
                BlendOp = ADD;
                SrcBlend = SRCALPHA;
                DestBlend = INVSRCALPHA;
        }
}

                SrcBlend = One;  // play with this value, possible values (take names, like ONE, not numbers!):
                DestBlend = One; // http://msdn.microsoft.com/en-us/library/windows/desktop/bb172508(v=vs.85).aspx

// the following are the default settings and can often be omitted
                AlphaBlendEnable = True;
                BlendOp = add;
                SrcBlend = srcAlpha;
                DestBlend = invSrcAlpha;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;

texture tex_Clonkex < string Name = ""; >;
	sampler2D sam_Clonkex = sampler_state
{
	texture = <tex_Clonkex>;
};

matrix WorldViewProj : WorldViewProjection;

texture BaseTex < string Name = ""; >;
float3 AmbientColor = float3(1.0, 1.0, 0.0); // 0.0-1.0 = 0-255 where 0.5 = 127
float AmbientIntensity = 0.2;

sampler2D BaseSamp = sampler_state
{
        Texture = <BaseTex>;
};

struct vs_in
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        //float2 uv1 : TEXCOORD1;
};

struct vs_out
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        //float valpha : TEXCOORD1;
};

vs_out DefaultVertexShader(vs_in IN)
{
        vs_out OUT;
        OUT.pos = mul(IN.pos, WorldViewProj);
        OUT.uv0 = IN.uv0;
        //OUT.valpha = IN.uv1.x; // vertex alpha
        OUT.valpha = 0; // vertex alpha
        return OUT;
}

float4 DefaultPixelShader(vs_out IN) : COLOR
{
        float4 texcolor = tex2D(BaseSamp,IN.uv0); // texcolor.a as texture alpha
        return float4(texcolor.rgb+AmbientColor*AmbientIntensity,IN.valpha);
        //return float4(texcolor.rgb+AmbientColor,IN.valpha);
}

technique MyShader
{
        pass p0
        {
                VertexShader = compile vs_2_0 DefaultVertexShader();
                PixelShader = compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable = TRUE;
                BlendOp = ADD;
                SrcBlend = SRCALPHA;
                DestBlend = INVSRCALPHA;
        }
}

sync on
sync rate 0
autocam off
hide mouse
set display mode desktop width(),desktop height(),32,1
sync

global debug=1

load image "cedar.bmp",1

load effect "meshshader v3.fx",1,0

make object cube 1,1

texture object 1,1

set object effect 1,1

move camera -4
move camera right 4
move camera up 4
point camera 0,0,0

set camera range 0.1,1000

do
if debug=1
 set cursor 0,0
 print "--Debug Information--"
 print "Graphics card: ";current graphics card$()
 print "Frames per second: ";screen fps()
 print "Polygons rendered: ";statistic(1)
 print "Camera position, x: ";camera position x();" y: ";camera position y();" z: ";camera position z()
 print "Camera angle, x: ";camera angle x();" y: ";camera angle y();" z: ";camera angle z()
 print "--Variables--"
endif

sync
loop

make object new 1,4,6,274,0
lock vertexdata for limb 1,0
set vertexdata position 0,-1,0,1
set vertexdata position 1,1,0,1
set vertexdata position 2,1,0,-1
set vertexdata position 3,-1,0,-1
set vertexdata normals 0,0,1,0
set vertexdata normals 1,0,1,0
set vertexdata normals 2,0,1,0
set vertexdata normals 3,0,1,0
set vertexdata uv 0,0,0
set vertexdata uv 1,1,0
set vertexdata uv 2,1,1
set vertexdata uv 3,0,1
set indexdata 0,0
set indexdata 1,1
set indexdata 2,3
set indexdata 3,1
set indexdata 4,2
set indexdata 5,3
unlock vertexdata

matrix WorldViewProj : WorldViewProjection;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;
float3 AmbientColor = float3(1.0, 1.0, 0.0); // 0.0-1.0 = 0-255 where 0.5 = 127
float AmbientIntensity = 1;

sampler BaseSamp = sampler_state
{
        Texture = <BaseTex>;
};

struct vs_in
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        float2 uv1 : TEXCOORD1;
};

struct vs_out
{
        float4 pos : POSITION;
        float2 uv0 : TEXCOORD0;
        float valpha : TEXCOORD1;
};

vs_out DefaultVertexShader(vs_in IN)
{
        vs_out OUT;
        OUT.pos = mul(IN.pos, WorldViewProj);
        OUT.uv0 = IN.uv0;
        OUT.valpha = IN.uv1.x; // vertex alpha
        return OUT;
}

float4 DefaultPixelShader(vs_out IN) : COLOR
{
        float4 texcolor = tex2D(BaseSamp,IN.uv0); // texcolor.a as texture alpha
        return float4(texcolor.rgb*AmbientColor*AmbientIntensity,IN.valpha);
}

technique MyShader
{
        pass p0
        {
                VertexShader = compile vs_2_0 DefaultVertexShader();
                PixelShader = compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable = TRUE;
                BlendOp = ADD;
                SrcBlend = SRCALPHA;
                DestBlend = INVSRCALPHA;
        }
}

set object transparency 1, 2

matrix WorldViewProj : WorldViewProjection;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;

sampler BaseSamp = sampler_state
{
        Texture = <BaseTex>;
};

struct vs_in
{
        float4 position : POSITION;
        float2 uv0 : TEXCOORD0;
        float4 diffuse : DIFFUSE;
};

struct vs_out
{
        float4 position : POSITION;
        float2 uv0 : TEXCOORD0;
        float4 diffuse : TEXCOORD1;
};

vs_out DefaultVertexShader(vs_in IN)
{
        vs_out OUT;
        OUT.position = mul(IN.position, WorldViewProj);
        OUT.uv0 = IN.uv0;
        OUT.diffuse = IN.diffuse; // vertex alpha
        return OUT;
}

float4 DefaultPixelShader(vs_out IN) : COLOR
{
        float4 texcolor = tex2D(BaseSamp,IN.uv0); // texcolor.a as texture alpha
        return float4(texcolor.rgb*IN.diffuse.rgb,1);
}

technique MyShader
{
        pass p0
        {
                VertexShader = compile vs_2_0 DefaultVertexShader();
                PixelShader = compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable = TRUE;
                BlendOp = ADD;
                SrcBlend = SRCALPHA;
                DestBlend = INVSRCALPHA;
        }
}

//------------------
// untweaks
//------------------

matrix WorldViewProj : WorldViewProjection;

//------------------
// tweaks
//------------------

float4 lightDirection = { 1, -0.7, 1, 0};
float textureScale = 0.5f;

//------------------
// textures
//------------------

texture BaseTex : DIFFUSE <string ResourceName="";>;

sampler BaseSamp=sampler_state
{
        Texture=<BaseTex>;
};

//------------------
// structs
//------------------

struct vs_in
{
        float4 position : POSITION0;
	float3 normal : NORMAL0;
        float2 uv0 : TEXCOORD0;
        float2 uv1 : TEXCOORD1;
};

struct vs_out
{
        float4 position : POSITION0;
        float2 uv0 : TEXCOORD0;
        float valpha : TEXCOORD1;
	float3 normal : TEXCOORD2;
	float3 worldPosition : TEXCOORD3;
};

//------------------
// vertex shader
//------------------

vs_out DefaultVertexShader(vs_in input)
{
        vs_out output;
        output.position=mul(input.position,WorldViewProj);
        output.uv0=input.uv0;
        output.valpha=input.uv1.x;
	output.worldPosition=input.position.xyz/input.position.w;
	output.normal=normalize(input.normal);
        return output;
}

//------------------
// pixel shader
//------------------

float4 DefaultPixelShader(vs_out input) : COLOR0
{
	input.normal=normalize(input.normal);
	float3 absNormal=abs(input.normal);
	float3 blend_weights=absNormal;
	blend_weights=blend_weights - 0.2679f;
	blend_weights=max(blend_weights, 0);
	//force sum to 1.0
	blend_weights/=(blend_weights.x+blend_weights.y+blend_weights.z).xxx;

	float4 blended_color;

	float2 coord1=input.worldPosition.yz*textureScale;
	float2 coord2=input.worldPosition.zx*textureScale;
	float2 coord3=input.worldPosition.xy*textureScale;

	float4 col1=tex2D(BaseSamp,coord1); //*0.01+float4(1.0,0.0,0.0,1.0); //uncomment to see the blending in red/green/blue only
	float4 col2=tex2D(BaseSamp,coord2); //*0.01+float4(0.0,1.0,0.0,1.0);
	float4 col3=tex2D(BaseSamp,coord3); //*0.01+float4(0.0,0.0,1.0,1.0);

	blended_color=col1.xyzw*blend_weights.xxxx+col2.xyzw*blend_weights.yyyy+col3.xyzw*blend_weights.zzzz;

	//directional lighting
	float4 light=-normalize(lightDirection);
	float ldn=max(0,dot(light,input.normal));
	float ambient=0.5f;

	//return float4(blended_color.xyz*(ambient+ldn),1);
	return float4(blended_color.xyz*(ambient+ldn),input.valpha);

        //float4 texcolor=tex2D(BaseSamp,input.uv0); //texcolor.a as texture alpha
	//texcolor*=blended_color;
        //return float4(blended_color.rgb,input.valpha);
}

//------------------
// techniques
//------------------

technique Technique1
{
        pass Pass1
        {
                VertexShader=compile vs_2_0 DefaultVertexShader();
                PixelShader=compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable=True;
                BlendOp=Add;
                SrcBlend=SrcAlpha;
                DestBlend=InvSrcAlpha;
        }
}

float2 coord1=input.worldPosition.zy*textureScale;
float2 coord2=input.worldPosition.zx*textureScale;
float2 coord3=input.worldPosition.yx*textureScale;

//------------------
// untweaks
//------------------

matrix WorldViewProj : WorldViewProjection;

//------------------
// tweaks
//------------------

float4 lightDirection={1,-0.7,1,0};
float textureScale=0.5f;

//------------------
// textures
//------------------

texture BaseTex : DIFFUSE <string ResourceName="";>;

sampler BaseSamp=sampler_state
{
        Texture=<BaseTex>;
};

//------------------
// structs
//------------------

struct vs_in
{
        float4 position : POSITION0;
	float3 normal : NORMAL0;
        float2 uv0 : TEXCOORD0;
        float2 uv1 : TEXCOORD1;
};

struct vs_out
{
        float4 position : POSITION0;
        float2 uv0 : TEXCOORD0;
        float valpha : TEXCOORD1;
	float3 normal : TEXCOORD2;
	float3 worldPosition : TEXCOORD3;
};

//------------------
// vertex shader
//------------------

vs_out DefaultVertexShader(vs_in input)
{
        vs_out output;
        output.position=mul(input.position,WorldViewProj);
        output.uv0=input.uv0;
        output.valpha=input.uv1.x;
	output.worldPosition=input.position.xyz/input.position.w;
	output.normal=normalize(input.normal);
        return output;
}

//------------------
// pixel shader
//------------------

float4 DefaultPixelShader(vs_out input) : COLOR0
{
	input.normal=normalize(input.normal);
	float3 absNormal=abs(input.normal);
	float3 blend_weights=absNormal;
	blend_weights=blend_weights-0.2f;
	blend_weights=max(blend_weights,0);
	//force sum to 1.0
	blend_weights/=(blend_weights.x+blend_weights.y+blend_weights.z).xxx;

	float4 blended_color;

	float2 coord1=input.worldPosition.zy*textureScale;
	float2 coord2=input.worldPosition.zx*textureScale;
	float2 coord3=input.worldPosition.yx*textureScale;

	float4 col1=tex2D(BaseSamp,coord1); //*0.01+float4(1.0,0.0,0.0,1.0); //uncomment to see the blending in red/green/blue only
	float4 col2=tex2D(BaseSamp,coord2); //*0.01+float4(0.0,1.0,0.0,1.0);
	float4 col3=tex2D(BaseSamp,coord3); //*0.01+float4(0.0,0.0,1.0,1.0);

	blended_color=col1.xyzw*blend_weights.xxxx+col2.xyzw*blend_weights.yyyy+col3.xyzw*blend_weights.zzzz;

	//directional lighting
	float4 light=-normalize(lightDirection);
	float ldn=max(0,dot(light,input.normal));
	float ambient=0.5f;

	return float4(blended_color.xyz*(ambient+ldn),input.valpha);
}

//------------------
// techniques
//------------------

technique Technique1
{
        pass Pass1
        {
                VertexShader=compile vs_2_0 DefaultVertexShader();
                PixelShader=compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable=True;
                BlendOp=Add;
                SrcBlend=SrcAlpha;
                DestBlend=InvSrcAlpha;
        }
}

matrix WorldViewProj : WorldViewProjection;

texture BaseTex : DIFFUSE < string ResourceName = ""; >;

sampler BaseSamp = sampler_state
{
        Texture = <BaseTex>;
};

struct vs_in
{
        float4 position : POSITION;
        float2 uv0 : TEXCOORD0;
        float4 diffuse : DIFFUSE;
};

struct vs_out
{
        float4 position : POSITION;
        float2 uv0 : TEXCOORD0;
        float4 diffuse : TEXCOORD1;
};

vs_out DefaultVertexShader(vs_in IN)
{
        vs_out OUT;
        OUT.position = mul(IN.position, WorldViewProj);
        OUT.uv0 = IN.uv0;
        OUT.diffuse = IN.diffuse; // vertex alpha
        return OUT;
}

float4 DefaultPixelShader(vs_out IN) : COLOR
{
        float4 texcolor = tex2D(BaseSamp,IN.uv0); // texcolor.a as texture alpha
        return float4(texcolor.rgb*IN.diffuse.rgb,1);
}

technique MyShader
{
        pass p0
        {
                VertexShader = compile vs_2_0 DefaultVertexShader();
                PixelShader = compile ps_2_0 DefaultPixelShader();
                AlphaBlendEnable = TRUE;
                BlendOp = ADD;
                SrcBlend = SRCALPHA;
                DestBlend = INVSRCALPHA;
        }
}