if (!driver->queryFeature(video::EVDF_PIXEL_SHADER_1_1) &&
		!driver->queryFeature(video::EVDF_ARB_FRAGMENT_PROGRAM_1))
	{
		device->getLogger()->log("WARNING: Pixel shaders disabled "\
			"because of missing driver/hardware support.");
		psFileName = 0;
	}
	
	if (!driver->queryFeature(video::EVDF_VERTEX_SHADER_1_1) &&
		!driver->queryFeature(video::EVDF_ARB_VERTEX_PROGRAM_1))
	{
		device->getLogger()->log("WARNING: Vertex shaders disabled "\
			"because of missing driver/hardware support.");
		vsFileName = 0;
	}

	// create materials

	video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();

	s32 newMaterialType1 = 0;
	s32 newMaterialType2 = 0;

	if (gpu)
	{
		MyShaderCallBack* mc = new MyShaderCallBack();
	

		// create the shaders depending on if the user wanted high level
		// or low level shaders:

		if (UseHighLevelShaders)
		{
			// create material from high level shaders (hlsl or glsl)

			newMaterialType1 = gpu->addHighLevelShaderMaterialFromFiles(
				vsFileName,	"vertexMain", video::EVST_VS_1_1,
				psFileName, "pixelMain", video::EPST_PS_1_1,
				mc, video::EMT_SOLID);

			newMaterialType2 = gpu->addHighLevelShaderMaterialFromFiles(
				vsFileName,	"vertexMain", video::EVST_VS_1_1,
				psFileName, "pixelMain", video::EPST_PS_1_1,
				mc, video::EMT_TRANSPARENT_ADD_COLOR);
		}
		else
		{
			// create material from low level shaders (asm or arb_asm)

			newMaterialType1 = gpu->addShaderMaterialFromFiles(vsFileName,
				psFileName, mc, video::EMT_SOLID);

			newMaterialType2 = gpu->addShaderMaterialFromFiles(vsFileName,
				psFileName, mc, video::EMT_TRANSPARENT_ADD_COLOR);
		}

		mc->drop();
	}

	// create test scene node 1, with the new created material type 1



	scene::ISceneNode* node = smgr->addCubeSceneNode(50);

	node->setPosition(core::vector3df(0,0,0));

	node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

	node->setMaterialFlag(video::EMF_LIGHTING, false);

	node->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType1);



	smgr->addTextSceneNode(gui->getBuiltInFont(),

			L"PS & VS & EMT_SOLID",

			video::SColor(255,255,255,255),	node);



	scene::ISceneNodeAnimator* anim = smgr->createRotationAnimator(

			core::vector3df(0,0.3f,0));

	node->addAnimator(anim);

	anim->drop();

	// create test scene node 2, with the new created material type 2



	node = smgr->addCubeSceneNode(50);

	node->setPosition(core::vector3df(0,-10,50));

	node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

	node->setMaterialFlag(video::EMF_LIGHTING, false);

	node->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType2);



	smgr->addTextSceneNode(gui->getBuiltInFont(),

			L"PS & VS & EMT_TRANSPARENT",

			video::SColor(255,255,255,255),	node);



	anim = smgr->createRotationAnimator(core::vector3df(0,0.3f,0));

	node->addAnimator(anim);

	anim->drop();

	// add a scene node with no shader 



	node = smgr->addCubeSceneNode(50);

	node->setPosition(core::vector3df(0,50,25));

	node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));

	node->setMaterialFlag(video::EMF_LIGHTING, false);

	smgr->addTextSceneNode(gui->getBuiltInFont(), L"NO SHADER",

		video::SColor(255,255,255,255), node);

            

	// add a nice skybox

	driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);

	smgr->addSkyBoxSceneNode(
		driver->getTexture("../../media/irrlicht2_up.jpg"),
		driver->getTexture("../../media/irrlicht2_dn.jpg"),
		driver->getTexture("../../media/irrlicht2_lf.jpg"),
		driver->getTexture("../../media/irrlicht2_rt.jpg"),
		driver->getTexture("../../media/irrlicht2_ft.jpg"),
		driver->getTexture("../../media/irrlicht2_bk.jpg"));

	driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);

	// add a camera and disable the mouse cursor

	scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(0, 100.0f, 100.0f);
	cam->setPosition(core::vector3df(-100,50,100));
	cam->setTarget(core::vector3df(0,0,0));
	device->getCursorControl()->setVisible(false);

	int lastFPS = -1;

	while(device->run())
		if (device->isWindowActive())
	{
		driver->beginScene(true, true, video::SColor(255,0,0,0));
		smgr->drawAll();
		driver->endScene();

		int fps = driver->getFPS();

		if (lastFPS != fps)
		{
		  core::stringw str = L"Irrlicht Engine - Vertex and pixel shader example [";
		  str += driver->getName();
		  str += "] FPS:";
		  str += fps;
		  device->setWindowCaption(str.c_str());
		  lastFPS = fps;
		}
	}

	device->drop();
	
	return 0;

// part of the Irrlicht Engine Shader example.

// These simple Direct3D9 pixel and vertex shaders
// will be loaded by the shaders

// example. Please note that these example shaders don't do
// anything really useful. 

// They only demonstrate that shaders can be used in Irrlicht.



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

// Global variables

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

float4x4 mWorldViewProj;  // World * View * Projection transformation

float4x4 mInvWorld;       // Inverted world matrix

float4x4 mTransWorld;     // Transposed world matrix

float3 mLightPos;         // Light position

float4 mLightColor;       // Light color





// Vertex shader output structure

struct VS_OUTPUT

{

	float4 Position   : POSITION;   // vertex position 

	float4 Diffuse    : COLOR0;     // vertex diffuse color

	float2 TexCoord   : TEXCOORD0;  // tex coords

};





VS_OUTPUT vertexMain( in float4 vPosition : POSITION,

                      in float3 vNormal   : NORMAL,

                      float2 texCoord     : TEXCOORD0 )

{

	VS_OUTPUT Output;



	// transform position to clip space 

	Output.Position = mul(vPosition, mWorldViewProj);

	

	// transform normal 

	float3 normal = mul(vNormal, mInvWorld);

	

	// renormalize normal 

	normal = normalize(normal);

	

	// position in world coodinates

	float3 worldpos = mul(mTransWorld, vPosition);

	

	// calculate light vector, vtxpos - lightpos

	float3 lightVector = worldpos - mLightPos;

	

	// normalize light vector 

	lightVector = normalize(lightVector);

	

	// calculate light color 

	float3 tmp = dot(-lightVector, normal);

	tmp = lit(tmp.x, tmp.y, 1.0);

	

	tmp = mLightColor * tmp.y;

	Output.Diffuse = float4(tmp.x, tmp.y, tmp.z, 0);

	Output.TexCoord = texCoord;

	

	return Output;

}







// Pixel shader output structure

struct PS_OUTPUT

{

    float4 RGBColor : COLOR0;  // Pixel color    

};





sampler2D tex0;

	

PS_OUTPUT pixelMain( float2 TexCoord : TEXCOORD0,

                     float4 Position : POSITION,

                     float4 Diffuse  : COLOR0 ) 

{ 

	PS_OUTPUT Output;



	float4 col = tex2D( tex0, TexCoord );  // sample color map

	

	// multiply with diffuse and do other senseless operations

	Output.RGBColor = Diffuse * col;

	Output.RGBColor *= 4.0;



	return Output;

}

; part of the Irrlicht Engine Shader example.

; This Direct3D9 vertex shader will be loaded by the engine.

; Please note that these example shaders don't do anything really useful. 

; They only demonstrate that shaders can be used in Irrlicht.


vs.1.1



dcl_position v0;    ; declare position

dcl_normal v1;      ; declare normal

dcl_color v2;       ; declare color

dcl_texcoord0 v3;   ; declare texture coordinate


; transpose and transform position to clip space 

mul r0, v0.x, c4      

mad r0, v0.y, c5, r0   

mad r0, v0.z, c6, r0   

add oPos, c7, r0       



; transform normal 

dp3 r1.x, v1, c0  

dp3 r1.y, v1, c1  

dp3 r1.z, v1, c2  



; renormalize normal 

dp3 r1.w, r1, r1  

rsq r1.w, r1.w    

mul r1, r1, r1.w  



; calculate light vector 

m4x4 r6, v0, c10      ; vertex into world position

add r2, c8, -r6       ; vtxpos - lightpos



; normalize light vector 

dp3 r2.w, r2, r2  

rsq r2.w, r2.w    

mul r2, r2, r2.w  



; calculate light color 

dp3 r3, r1, r2       ; dp3 with negative light vector 

lit r5, r3           ; clamp to zero if r3 < 0, r5 has diffuce component in r5.y

mul oD0, r5.y, c9    ; ouput diffuse color 

mov oT0, v3          ; store texture coordinates     

; part of the Irrlicht Engine Shader example.

; This simple Direct3D9 pixel shader will be loaded by the engine.

; Please note that these example shaders don't do anything really useful. 

; They only demonstrate that shaders can be used in Irrlicht.


ps.1.1



tex t0          ; sample color map

add r0, v0, v0  ; mulitply with color

mul t0, t0, r0  ; mulitply with color

add r0, t0, t0  ; make it brighter and store result              

              

; part of the Irrlicht Engine Shader example.

; This Direct3D9 vertex shader will be loaded by the engine.

; Please note that these example shaders don't do anything really useful. 

; They only demonstrate that shaders can be used in Irrlicht.


vs.1.1



; transpose and transform position to clip space 

mul r0, v0.x, c4      

mad r0, v0.y, c5, r0   

mad r0, v0.z, c6, r0   

add oPos, c7, r0       



; transform normal 

dp3 r1.x, v1, c0  

dp3 r1.y, v1, c1  

dp3 r1.z, v1, c2  



; renormalize normal 

dp3 r1.w, r1, r1  

rsq r1.w, r1.w    

mul r1, r1, r1.w  



; calculate light vector 

m4x4 r6, v0, c10      ; vertex into world position

add r2, c8, -r6       ; vtxpos - lightpos



; normalize light vector 

dp3 r2.w, r2, r2  

rsq r2.w, r2.w    

mul r2, r2, r2.w  



; calculate light color 

dp3 r3, r1, r2       ; dp3 with negative light vector 

lit r5, r3           ; clamp to zero if r3 < 0, r5 has diffuce component in r5.y

mul oD0, r5.y, c9    ; ouput diffuse color 

mov oT0, v3          ; store texture coordinates             

; part of the Irrlicht Engine Shader example.

; This simple Direct3D9 pixel shader will be loaded by the engine.

; Please note that these example shaders don't do anything really useful. 

; They only demonstrate that shaders can be used in Irrlicht.


ps.1.1



tex t0             ; sample color map

mul_x2 t0, t0, v0  ; mulitply with color

add r0, t0, t0     ; make it brighter and store result      

!!ARBvp1.0

# part of the Irrlicht Engine Shader example.

# Please note that these example shaders don't do anything really useful. 

# They only demonstrate that shaders can be used in Irrlicht.


#input

ATTRIB InPos = vertex.position;

ATTRIB InColor = vertex.color;

ATTRIB InNormal = vertex.normal;

ATTRIB InTexCoord = vertex.texcoord;



#output

OUTPUT OutPos = result.position;

OUTPUT OutColor = result.color;

OUTPUT OutTexCoord = result.texcoord;



PARAM MVP[4] = { state.matrix.mvp }; # modelViewProjection matrix.

TEMP Temp;

TEMP TempColor;

TEMP TempNormal;

TEMP TempPos;



#transform position to clip space 

DP4 Temp.x, MVP[0], InPos;

DP4 Temp.y, MVP[1], InPos;

DP4 Temp.z, MVP[2], InPos;

DP4 Temp.w, MVP[3], InPos;



#transform normal

DP3 TempNormal.x, InNormal.x, program.local[0];

DP3 TempNormal.y, InNormal.y, program.local[1]; 

DP3 TempNormal.z, InNormal.z, program.local[2];



#renormalize normal

DP3 TempNormal.w, TempNormal, TempNormal;  

RSQ TempNormal.w, TempNormal.w;    

MUL TempNormal, TempNormal, TempNormal.w;



# calculate light vector 

DP4 TempPos.x, InPos, program.local[10];   # vertex into world position

DP4 TempPos.y, InPos, program.local[11];

DP4 TempPos.z, InPos, program.local[12];

DP4 TempPos.w, InPos, program.local[13];



ADD TempPos, program.local[8], -TempPos;    # vtxpos - lightpos



# normalize light vector

DP3 TempPos.w, TempPos, TempPos;  

RSQ TempPos.w, TempPos.w;    

MUL TempPos, TempPos, TempPos.w;



# calculate light color

DP3 TempColor, TempNormal, TempPos;    # dp3 with negative light vector 

LIT OutColor, TempColor;  # clamp to zero if r3 < 0

MUL OutColor, TempColor.y, program.local[9]; # ouput diffuse color 

MOV OutColor.w, 1.0;          # we want alpha to be always 1

MOV OutTexCoord, InTexCoord; # store texture coordinate

MOV OutPos, Temp;



END

!!ARBfp1.0

# part of the Irrlicht Engine Shader example.

# Please note that these example shaders don't do anything really useful. 

# They only demonstrate that shaders can be used in Irrlicht.


#Input

ATTRIB inTexCoord = fragment.texcoord;      # texture coordinates

ATTRIB inColor = fragment.color.primary; # interpolated diffuse color



#Output

OUTPUT outColor = result.color;



TEMP texelColor;

TEMP tmp;

TXP texelColor, inTexCoord, texture, 2D; 



ADD tmp, inColor, inColor; # mulitply with color

MUL texelColor, texelColor, tmp;  # mulitply with color   

ADD outColor, texelColor, texelColor;  # make it brighter and store result



END