Changes in 1.7.1 (05.07.2010) TA

- BurningVideo 
		- add Normalmap Rendering ( one light only), pushed Burningvideo to 0.46
		- internal vertexformat changed
		- changed fixpoint from 9 to 10 bit fract resolution
		- renamed createBurningVideoDriver to createBurningVideoDriver and uses SIrrlichtCreationParameters like opengl
		- internal interfaces for the trianglerenders unified.
		
	- Example 11.
		changed the light billboards to use the light color. ( green light, green particle, red light red particle )
		allow to disable the bump/parallax on the earth like in the room ( with transparency )


git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@3331 dfc29bdd-3216-0410-991c-e03cc46cb475

source/Irrlicht/CBurningShader_Raster_Reference.cpp

@@ -509,7 +509,7 @@ class CBurningShader_Raster_Reference : public IBurningShader
 public:
 
 	//! constructor
-	CBurningShader_Raster_Reference(IDepthBuffer* depthBuffer);
+	CBurningShader_Raster_Reference(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -536,8 +536,8 @@ private:
 };
 
 //! constructor
-CBurningShader_Raster_Reference::CBurningShader_Raster_Reference(IDepthBuffer* depthBuffer)
-: IBurningShader(depthBuffer)
+CBurningShader_Raster_Reference::CBurningShader_Raster_Reference(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CBurningShader_Raster_Reference");
@@ -1129,9 +1129,9 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererReference(IDepthBuffer* depthBuffer)
+IBurningShader* createTriangleRendererReference(CBurningVideoDriver* driver)
 {
-	return new CBurningShader_Raster_Reference(depthBuffer);
+	return new CBurningShader_Raster_Reference(driver);
 }
 
 

source/Irrlicht/CDepthBuffer.cpp

@@ -68,6 +68,7 @@ void CDepthBuffer::setSize(const core::dimension2d<u32>& size)
 	Pitch = size.Width * sizeof ( fp24 );
 	TotalSize = Pitch * size.Height;
 	Buffer = new u8[TotalSize];
+	clear ();
 }
 
 
@@ -78,6 +79,63 @@ const core::dimension2d<u32>& CDepthBuffer::getSize() const
 	return Size;
 }
 
+// -----------------------------------------------------------------
+
+//! constructor
+CStencilBuffer::CStencilBuffer(const core::dimension2d<u32>& size)
+: Buffer(0), Size(0,0)
+{
+	#ifdef _DEBUG
+	setDebugName("CDepthBuffer");
+	#endif
+
+	setSize(size);
+}
+
+
+
+//! destructor
+CStencilBuffer::~CStencilBuffer()
+{
+	if (Buffer)
+		delete [] Buffer;
+}
+
+
+
+//! clears the zbuffer
+void CStencilBuffer::clear()
+{
+	memset32 ( Buffer, 0, TotalSize );
+}
+
+
+
+//! sets the new size of the zbuffer
+void CStencilBuffer::setSize(const core::dimension2d<u32>& size)
+{
+	if (size == Size)
+		return;
+
+	Size = size;
+
+	if (Buffer)
+		delete [] Buffer;
+
+	Pitch = size.Width * sizeof ( u8 );
+	TotalSize = Pitch * size.Height;
+	Buffer = new u8[TotalSize];
+	clear ();
+}
+
+
+
+//! returns the size of the zbuffer
+const core::dimension2d<u32>& CStencilBuffer::getSize() const
+{
+	return Size;
+}
+
 
 
 } // end namespace video
@@ -100,6 +158,17 @@ IDepthBuffer* createDepthBuffer(const core::dimension2d<u32>& size)
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_
 }
 
+
+//! creates a ZBuffer
+IStencilBuffer* createStencilBuffer(const core::dimension2d<u32>& size)
+{
+	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
+	return new CStencilBuffer(size);
+	#else
+	return 0;
+	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_
+}
+
 } // end namespace video
 } // end namespace irr
 

source/Irrlicht/CDepthBuffer.h

@@ -32,21 +32,51 @@ namespace video
 		virtual const core::dimension2d<u32>& getSize() const;
 
 		//! locks the zbuffer
-		virtual void* lock()
-		{
-			return (void*) Buffer;
-		}
+		virtual void* lock() { return (void*) Buffer; }
 
 		//! unlocks the zbuffer
-		virtual void unlock()
-		{
-		}
+		virtual void unlock() {}
 
 		//! returns pitch of depthbuffer (in bytes)
-		virtual u32 getPitch() const
-		{
-			return Pitch;
-		}
+		virtual u32 getPitch() const { return Pitch; }
+
+
+	private:
+
+		u8* Buffer;
+		core::dimension2d<u32> Size;
+		u32 TotalSize;
+		u32 Pitch;
+	};
+
+
+	class CStencilBuffer : public IStencilBuffer
+	{
+	public:
+
+		//! constructor
+		CStencilBuffer(const core::dimension2d<u32>& size);
+
+		//! destructor
+		virtual ~CStencilBuffer();
+
+		//! clears the zbuffer
+		virtual void clear();
+
+		//! sets the new size of the zbuffer
+		virtual void setSize(const core::dimension2d<u32>& size);
+
+		//! returns the size of the zbuffer
+		virtual const core::dimension2d<u32>& getSize() const;
+
+		//! locks the zbuffer
+		virtual void* lock() { return (void*) Buffer; }
+
+		//! unlocks the zbuffer
+		virtual void unlock() {}
+
+		//! returns pitch of depthbuffer (in bytes)
+		virtual u32 getPitch() const { return Pitch; }
 
 
 	private:

source/Irrlicht/CGUIColorSelectDialog.cpp

@@ -302,7 +302,7 @@ void CGUIColorSelectDialog::buildColorRing( const core::dimension2d<u32> & dim,
 	bool generateMipLevels = driver->getTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS);
 	driver->setTextureCreationFlag( video::ETCF_CREATE_MIP_MAPS, false);
 
-	ColorRing.Texture = driver->addTexture ( L"#colorring", RawTexture);
+	ColorRing.Texture = driver->addTexture ( "#colorring", RawTexture);
 	RawTexture->drop();
 
 	driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, generateMipLevels);

source/Irrlicht/CIrrDeviceConsole.cpp

@@ -124,7 +124,7 @@ CIrrDeviceConsole::CIrrDeviceConsole(const SIrrlichtCreationParameters& params)
 
 	case video::EDT_BURNINGSVIDEO:
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's Video driver was not compiled in.", ELL_ERROR);
 		#endif

source/Irrlicht/CIrrDeviceFB.cpp

@@ -200,7 +200,7 @@ void CIrrDeviceFB::createDriver()
 		
 	case video::EDT_BURNINGSVIDEO:
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's video driver was not compiled in.", ELL_WARNING);
 		#endif

source/Irrlicht/CIrrDeviceLinux.cpp

@@ -782,7 +782,7 @@ void CIrrDeviceLinux::createDriver()
 
 	case video::EDT_BURNINGSVIDEO:
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's video driver was not compiled in.", ELL_ERROR);
 		#endif

source/Irrlicht/CIrrDeviceSDL.cpp

@@ -266,7 +266,7 @@ void CIrrDeviceSDL::createDriver()
 
 	case video::EDT_BURNINGSVIDEO:
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's video driver was not compiled in.", ELL_ERROR);
 		#endif

source/Irrlicht/CIrrDeviceStub.h

@@ -39,9 +39,8 @@ namespace irr
 		IVideoDriver* createSoftwareDriver(const core::dimension2d<u32>& windowSize,
 				bool fullscreen, io::IFileSystem* io,
 				video::IImagePresenter* presenter);
-		IVideoDriver* createSoftwareDriver2(const core::dimension2d<u32>& windowSize,
-				bool fullscreen, io::IFileSystem* io,
-				video::IImagePresenter* presenter);
+		IVideoDriver* createBurningVideoDriver(const irr::SIrrlichtCreationParameters& params,
+				io::IFileSystem* io, video::IImagePresenter* presenter);
 		IVideoDriver* createNullDriver(io::IFileSystem* io, const core::dimension2d<u32>& screenSize);
 	}
 

source/Irrlicht/CIrrDeviceWin32.cpp

@@ -727,7 +727,7 @@ void CIrrDeviceWin32::createDriver()
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
 		switchToFullScreen();
 
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's Video driver was not compiled in.", ELL_ERROR);
 		#endif

source/Irrlicht/CIrrDeviceWinCE.cpp

@@ -529,7 +529,7 @@ void CIrrDeviceWinCE::createDriver()
 		#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
 		if (CreationParams.Fullscreen)
 			switchToFullScreen();
-		VideoDriver = video::createSoftwareDriver2(CreationParams.WindowSize, CreationParams.Fullscreen, FileSystem, this);
+		VideoDriver = video::createBurningVideoDriver(CreationParams, FileSystem, this);
 		#else
 		os::Printer::log("Burning's Video driver was not compiled in.", ELL_ERROR);
 		#endif

source/Irrlicht/CLightSceneNode.cpp

@@ -188,7 +188,8 @@ void CLightSceneNode::doLightRecalc()
 		const f32 r = LightData.Radius * LightData.Radius * 0.5f;
 		BBox.MaxEdge.set( r, r, r );
 		BBox.MinEdge.set( -r, -r, -r );
-		setAutomaticCulling( scene::EAC_BOX );
+		//setAutomaticCulling( scene::EAC_BOX );
+		setAutomaticCulling( scene::EAC_OFF );
 		LightData.Position = getAbsolutePosition();
 	}
 	if (LightData.Type == video::ELT_DIRECTIONAL)

source/Irrlicht/CSceneCollisionManager.cpp

@@ -916,7 +916,7 @@ inline bool CSceneCollisionManager::getLowestRoot(f32 a, f32 b, f32 c, f32 maxR,
 	f32 determinant = b*b - 4.0f*a*c;
 
 	// if determinant is negative, no solution
-	if (determinant < 0.0f) return false;
+	if (determinant < 0.0f || a == 0.f ) return false;
 
 	// calculate two roots: (if det==0 then x1==x2
 	// but lets disregard that slight optimization)

source/Irrlicht/CSoftwareDriver2.cpp

@@ -22,26 +22,335 @@ namespace irr
 namespace video
 {
 
+namespace glsl
+{
+
+typedef sVec4 vec4;
+typedef sVec3 vec3;
+typedef sVec2 vec2;
+
+#define in
+#define uniform
+#define attribute
+#define varying
+
+#pragma warning(disable:4244)
+
+struct mat4{
+   float m[4][4];
+
+   vec4 operator* ( const vec4 &in ) const
+   { 
+	   vec4 out;
+	   return out;
+   }
+
+};
+
+struct mat3{
+   float m[3][3];
+
+   vec3 operator* ( const vec3 &in ) const
+   { 
+	   vec3 out;
+	   return out;
+   }
+};
+
+const int gl_MaxLights = 8;
+
+
+inline float dot (float x, float y) { return x * y; }
+inline float dot ( const vec2 &x, const vec2 &y) { return x.x * y.x + x.y * y.y; }
+inline float dot ( const vec3 &x, const vec3 &y) { return x.x * y.x + x.y * y.y + x.z * y.z; }
+inline float dot ( const vec4 &x, const vec4 &y) { return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w; }
+
+inline float reflect (float I, float N)				{ return I - 2.0 * dot (N, I) * N; }
+inline vec2 reflect (const vec2 &I, const vec2 &N)	{ return I - N * 2.0 * dot (N, I); }
+inline vec3 reflect (const vec3 &I, const vec3 &N)	{ return I - N * 2.0 * dot (N, I); }
+inline vec4 reflect (const vec4 &I, const vec4 &N)	{ return I - N * 2.0 * dot (N, I); }
+
+
+inline float refract (float I, float N, float eta){
+    const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+    if (k < 0.0)
+        return 0.0;
+    return eta * I - (eta * dot (N, I) + sqrt (k)) * N;
+}
+
+inline vec2 refract (const vec2 &I, const vec2 &N, float eta){
+    const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+    if (k < 0.0)
+        return vec2 (0.0);
+    return I * eta - N * (eta * dot (N, I) + sqrt (k));
+}
+
+inline vec3 refract (const vec3 &I, const vec3 &N, float eta) {
+    const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+    if (k < 0.0)
+        return vec3 (0.0);
+    return I * eta - N * (eta * dot (N, I) + sqrt (k));
+}
+
+inline vec4 refract (const vec4 &I, const vec4 &N, float eta) {
+    const float k = 1.0 - eta * eta * (1.0 - dot (N, I) * dot (N, I));
+    if (k < 0.0)
+        return vec4 (0.0);
+    return I * eta - N * (eta * dot (N, I) + sqrt (k));
+}
+
+
+inline float length ( const vec3 &v ) { return sqrtf ( v.x * v.x + v.y * v.y + v.z * v.z ); }
+vec3 normalize ( const vec3 &v ) { 	float l = 1.f / length ( v ); return vec3 ( v.x * l, v.y * l, v.z * l ); }
+float max ( float a, float b ) { return a > b ? a : b; }
+float min ( float a, float b ) { return a < b ? a : b; }
+vec4 clamp ( const vec4 &a, f32 low, f32 high ) { return vec4 ( min (max(a.x,low), high), min (max(a.y,low), high), min (max(a.z,low), high), min (max(a.w,low), high) ); }
+
+
+
+typedef int sampler2D;
+sampler2D texUnit0;
+
+vec4 texture2D (sampler2D sampler, const vec2 &coord) { return vec4 (0.0); }
+
+struct gl_LightSourceParameters {
+	vec4 ambient;              // Acli
+	vec4 diffuse;              // Dcli
+	vec4 specular;             // Scli
+	vec4 position;             // Ppli
+	vec4 halfVector;           // Derived: Hi
+	vec3 spotDirection;        // Sdli
+	float spotExponent;        // Srli
+	float spotCutoff;          // Crli
+							// (range: [0.0,90.0], 180.0)
+	float spotCosCutoff;       // Derived: cos(Crli)
+							// (range: [1.0,0.0],-1.0)
+	float constantAttenuation; // K0
+	float linearAttenuation;   // K1
+	float quadraticAttenuation;// K2
+};
+
+uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];
+
+struct gl_LightModelParameters {
+    vec4 ambient;
+};
+uniform gl_LightModelParameters gl_LightModel;
+
+struct gl_LightModelProducts {
+    vec4 sceneColor;
+};
+
+uniform gl_LightModelProducts gl_FrontLightModelProduct;
+uniform gl_LightModelProducts gl_BackLightModelProduct;
+
+struct gl_LightProducts {
+    vec4 ambient;
+    vec4 diffuse;
+    vec4 specular;
+};
+
+uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];
+uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];
+
+struct gl_MaterialParameters
+{
+	vec4 emission;    // Ecm
+	vec4 ambient;     // Acm
+	vec4 diffuse;     // Dcm
+	vec4 specular;    // Scm
+	float shininess;  // Srm
+};
+uniform gl_MaterialParameters gl_FrontMaterial;
+uniform gl_MaterialParameters gl_BackMaterial;
+
+// GLSL has some built-in attributes in a vertex shader: 
+attribute vec4 gl_Vertex;			// 4D vector representing the vertex position
+attribute vec3 gl_Normal;			// 3D vector representing the vertex normal
+attribute vec4 gl_Color;			// 4D vector representing the vertex color
+attribute vec4 gl_MultiTexCoord0;	// 4D vector representing the texture coordinate of texture unit X
+attribute vec4 gl_MultiTexCoord1;	// 4D vector representing the texture coordinate of texture unit X
+
+uniform mat4 gl_ModelViewMatrix;			//4x4 Matrix representing the model-view matrix.
+uniform mat4 gl_ModelViewProjectionMatrix;	//4x4 Matrix representing the model-view-projection matrix.
+uniform mat3 gl_NormalMatrix;				//3x3 Matrix representing the inverse transpose model-view matrix. This matrix is used for normal transformation.
+
+
+varying vec4 gl_FrontColor;				// 4D vector representing the primitives front color
+varying vec4 gl_FrontSecondaryColor;	// 4D vector representing the primitives second front color
+varying vec4 gl_BackColor;				// 4D vector representing the primitives back color
+varying vec4 gl_TexCoord[4];			// 4D vector representing the Xth texture coordinate
+
+// shader output
+varying vec4 gl_Position;				// 4D vector representing the final processed vertex position. Only  available in vertex shader.
+varying vec4 gl_FragColor;				// 4D vector representing the final color which is written in the frame buffer. Only available in fragment shader.
+varying float gl_FragDepth;				// float representing the depth which is written in the depth buffer. Only available in fragment shader.
+
+varying vec4 gl_SecondaryColor;
+varying float gl_FogFragCoord;
+
+
+vec4 ftransform(void)
+{
+	return gl_ModelViewProjectionMatrix * gl_Vertex;
+}
+
+vec3 fnormal(void)
+{
+    //Compute the normal 
+    vec3 normal = gl_NormalMatrix * gl_Normal;
+    normal = normalize(normal);
+    return normal;
+}
+
+
+
+struct program1
+{
+	vec4 Ambient;
+	vec4 Diffuse;
+	vec4 Specular;
+
+	void pointLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3)
+	{
+	   float nDotVP;       // normal . light direction
+	   float nDotHV;       // normal . light half vector
+	   float pf;           // power factor
+	   float attenuation;  // computed attenuation factor
+	   float d;            // distance from surface to light source
+	   vec3  VP;           // direction from surface to light position
+	   vec3  halfVector;   // direction of maximum highlights
+
+	   // Compute vector from surface to light position
+	   VP = vec3 (gl_LightSource[i].position) - ecPosition3;
+
+	   // Compute distance between surface and light position
+	   d = length(VP);
+
+	   // Normalize the vector from surface to light position
+	   VP = normalize(VP);
+
+	   // Compute attenuation
+	   attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +
+		   gl_LightSource[i].linearAttenuation * d +
+		   gl_LightSource[i].quadraticAttenuation * d * d);
+
+	   halfVector = normalize(VP + eye);
+
+	   nDotVP = max(0.0, dot(normal, VP));
+	   nDotHV = max(0.0, dot(normal, halfVector));
+
+	   if (nDotVP == 0.0)
+	   {
+		   pf = 0.0;
+	   }
+	   else
+	   {
+		   pf = pow(nDotHV, gl_FrontMaterial.shininess);
+
+	   }
+	   Ambient  += gl_LightSource[i].ambient * attenuation;
+	   Diffuse  += gl_LightSource[i].diffuse * nDotVP * attenuation;
+	   Specular += gl_LightSource[i].specular * pf * attenuation;
+	}
+
+	vec3 fnormal(void)
+	{
+		//Compute the normal 
+		vec3 normal = gl_NormalMatrix * gl_Normal;
+		normal = normalize(normal);
+		return normal;
+	}
+
+	void ftexgen(in vec3 normal, in vec4 ecPosition)
+	{
+
+		gl_TexCoord[0] = gl_MultiTexCoord0;
+	}
+
+	void flight(in vec3 normal, in vec4 ecPosition, float alphaFade)
+	{
+		vec4 color;
+		vec3 ecPosition3;
+		vec3 eye;
+
+		ecPosition3 = (vec3 (ecPosition)) / ecPosition.w;
+		eye = vec3 (0.0, 0.0, 1.0);
+
+		// Clear the light intensity accumulators
+		Ambient  = vec4 (0.0);
+		Diffuse  = vec4 (0.0);
+		Specular = vec4 (0.0);
+
+		pointLight(0, normal, eye, ecPosition3);
+
+		pointLight(1, normal, eye, ecPosition3);
+
+		color = gl_FrontLightModelProduct.sceneColor +
+		  Ambient  * gl_FrontMaterial.ambient +
+		  Diffuse  * gl_FrontMaterial.diffuse;
+		gl_FrontSecondaryColor = Specular * gl_FrontMaterial.specular;
+		color = clamp( color, 0.0, 1.0 );
+		gl_FrontColor = color;
+
+		gl_FrontColor.a *= alphaFade;
+	}
+
+
+	void vertexshader_main (void)
+	{
+		vec3  transformedNormal;
+		float alphaFade = 1.0;
+
+		// Eye-coordinate position of vertex, needed in various calculations
+		vec4 ecPosition = gl_ModelViewMatrix * gl_Vertex;
+
+		// Do fixed functionality vertex transform
+		gl_Position = ftransform();
+		transformedNormal = fnormal();
+		flight(transformedNormal, ecPosition, alphaFade);
+		ftexgen(transformedNormal, ecPosition);
+	}
+
+	void fragmentshader_main (void) 
+	{
+		vec4 color;
+
+		color = gl_Color;
+
+		color *= texture2D(texUnit0, gl_TexCoord[0].xy);
+
+		color += gl_SecondaryColor;
+		color = clamp(color, 0.0, 1.0);
+
+		gl_FragColor = color;
+	}
+};
+
+}
 
 //! constructor
-CBurningVideoDriver::CBurningVideoDriver(const core::dimension2d<u32>& windowSize, bool fullscreen, io::IFileSystem* io, video::IImagePresenter* presenter)
-: CNullDriver(io, windowSize), BackBuffer(0), Presenter(presenter),
+CBurningVideoDriver::CBurningVideoDriver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, video::IImagePresenter* presenter)
+: CNullDriver(io, params.WindowSize), BackBuffer(0), Presenter(presenter),
 	WindowId(0), SceneSourceRect(0),
 	RenderTargetTexture(0), RenderTargetSurface(0), CurrentShader(0),
-	 DepthBuffer(0), CurrentOut ( 12 * 2, 128 ), Temp ( 12 * 2, 128 )
+	 DepthBuffer(0), StencilBuffer ( 0 ),
+	 CurrentOut ( 12 * 2, 128 ), Temp ( 12 * 2, 128 )
 {
 	#ifdef _DEBUG
 	setDebugName("CBurningVideoDriver");
 	#endif
 
 	// create backbuffer
-	BackBuffer = new CImage(BURNINGSHADER_COLOR_FORMAT, windowSize);
+	BackBuffer = new CImage(BURNINGSHADER_COLOR_FORMAT, params.WindowSize);
 	if (BackBuffer)
 	{
 		BackBuffer->fill(SColor(0));
 
 		// create z buffer
 		DepthBuffer = video::createDepthBuffer(BackBuffer->getDimension());
+		// create stencil buffer
+		StencilBuffer = video::createStencilBuffer(BackBuffer->getDimension());
 	}
 
 	// create triangle renderers
@@ -49,32 +358,33 @@ CBurningVideoDriver::CBurningVideoDriver(const core::dimension2d<u32>& windowSiz
 	irr::memset32 ( BurningShader, 0, sizeof ( BurningShader ) );
 	//BurningShader[ETR_FLAT] = createTRFlat2(DepthBuffer);
 	//BurningShader[ETR_FLAT_WIRE] = createTRFlatWire2(DepthBuffer);
-	BurningShader[ETR_GOURAUD] = createTriangleRendererGouraud2(DepthBuffer);
-	BurningShader[ETR_GOURAUD_ALPHA] = createTriangleRendererGouraudAlpha2(DepthBuffer );
-	BurningShader[ETR_GOURAUD_ALPHA_NOZ] = createTRGouraudAlphaNoZ2(DepthBuffer );
+	BurningShader[ETR_GOURAUD] = createTriangleRendererGouraud2(this);
+	BurningShader[ETR_GOURAUD_ALPHA] = createTriangleRendererGouraudAlpha2(this );
+	BurningShader[ETR_GOURAUD_ALPHA_NOZ] = createTRGouraudAlphaNoZ2(this );
 	//BurningShader[ETR_GOURAUD_WIRE] = createTriangleRendererGouraudWire2(DepthBuffer);
 	//BurningShader[ETR_TEXTURE_FLAT] = createTriangleRendererTextureFlat2(DepthBuffer);
 	//BurningShader[ETR_TEXTURE_FLAT_WIRE] = createTriangleRendererTextureFlatWire2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD] = createTriangleRendererTextureGouraud2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M1] = createTriangleRendererTextureLightMap2_M1(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M2] = createTriangleRendererTextureLightMap2_M2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M4] = createTriangleRendererGTextureLightMap2_M4(DepthBuffer);
-	BurningShader[ETR_TEXTURE_LIGHTMAP_M4] = createTriangleRendererTextureLightMap2_M4(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_ADD] = createTriangleRendererTextureLightMap2_Add(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_DETAIL_MAP] = createTriangleRendererTextureDetailMap2(DepthBuffer);
+	BurningShader[ETR_TEXTURE_GOURAUD] = createTriangleRendererTextureGouraud2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M1] = createTriangleRendererTextureLightMap2_M1(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M2] = createTriangleRendererTextureLightMap2_M2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_M4] = createTriangleRendererGTextureLightMap2_M4(this);
+	BurningShader[ETR_TEXTURE_LIGHTMAP_M4] = createTriangleRendererTextureLightMap2_M4(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_LIGHTMAP_ADD] = createTriangleRendererTextureLightMap2_Add(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_DETAIL_MAP] = createTriangleRendererTextureDetailMap2(this);
 
-	BurningShader[ETR_TEXTURE_GOURAUD_WIRE] = createTriangleRendererTextureGouraudWire2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_NOZ] = createTRTextureGouraudNoZ2();
-	BurningShader[ETR_TEXTURE_GOURAUD_ADD] = createTRTextureGouraudAdd2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_ADD_NO_Z] = createTRTextureGouraudAddNoZ2(DepthBuffer);
-	BurningShader[ETR_TEXTURE_GOURAUD_VERTEX_ALPHA] = createTriangleRendererTextureVertexAlpha2 ( DepthBuffer );
+	BurningShader[ETR_TEXTURE_GOURAUD_WIRE] = createTriangleRendererTextureGouraudWire2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_NOZ] = createTRTextureGouraudNoZ2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_ADD] = createTRTextureGouraudAdd2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_ADD_NO_Z] = createTRTextureGouraudAddNoZ2(this);
+	BurningShader[ETR_TEXTURE_GOURAUD_VERTEX_ALPHA] = createTriangleRendererTextureVertexAlpha2 ( this );
 
-	BurningShader[ETR_TEXTURE_GOURAUD_ALPHA] = createTRTextureGouraudAlpha(DepthBuffer );
-	BurningShader[ETR_TEXTURE_GOURAUD_ALPHA_NOZ] = createTRTextureGouraudAlphaNoZ( DepthBuffer );
+	BurningShader[ETR_TEXTURE_GOURAUD_ALPHA] = createTRTextureGouraudAlpha(this );
+	BurningShader[ETR_TEXTURE_GOURAUD_ALPHA_NOZ] = createTRTextureGouraudAlphaNoZ( this );
 
-	BurningShader[ETR_TEXTURE_BLEND] = createTRTextureBlend( DepthBuffer );
+	BurningShader[ETR_NORMAL_MAP_SOLID] = createTRNormalMap ( this );
+	BurningShader[ETR_TEXTURE_BLEND] = createTRTextureBlend( this );
 
-	BurningShader[ETR_REFERENCE] = createTriangleRendererReference ( DepthBuffer );
+	BurningShader[ETR_REFERENCE] = createTriangleRendererReference ( this );
 
 
 	// add the same renderer for all solid types
@@ -100,12 +410,12 @@ CBurningVideoDriver::CBurningVideoDriver(const core::dimension2d<u32>& windowSiz
 	addMaterialRenderer ( tmr ); // EMT_TRANSPARENT_ALPHA_CHANNEL_REF,
 	addMaterialRenderer ( tmr ); // EMT_TRANSPARENT_VERTEX_ALPHA,
 	addMaterialRenderer ( smr ); // EMT_TRANSPARENT_REFLECTION_2_LAYER,
-	addMaterialRenderer ( umr ); // EMT_NORMAL_MAP_SOLID,
+	addMaterialRenderer ( smr ); // EMT_NORMAL_MAP_SOLID,
 	addMaterialRenderer ( umr ); // EMT_NORMAL_MAP_TRANSPARENT_ADD_COLOR,
-	addMaterialRenderer ( umr ); // EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA,
-	addMaterialRenderer ( umr ); // EMT_PARALLAX_MAP_SOLID,
-	addMaterialRenderer ( umr ); // EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR,
-	addMaterialRenderer ( umr ); // EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA,
+	addMaterialRenderer ( tmr ); // EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA,
+	addMaterialRenderer ( smr ); // EMT_PARALLAX_MAP_SOLID,
+	addMaterialRenderer ( tmr ); // EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR,
+	addMaterialRenderer ( tmr ); // EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA,
 	addMaterialRenderer ( tmr ); // EMT_ONETEXTURE_BLEND
 
 	smr->drop ();
@@ -138,6 +448,9 @@ CBurningVideoDriver::~CBurningVideoDriver()
 
 	// delete zbuffer
 
+	if (StencilBuffer)
+		StencilBuffer->drop();
+
 	if (DepthBuffer)
 		DepthBuffer->drop();
 
@@ -229,6 +542,14 @@ void CBurningVideoDriver::setCurrentShader()
 			LightSpace.Flags |= VERTEXTRANSFORM;
 			break;
 
+		case EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA:
+		case EMT_NORMAL_MAP_SOLID:
+		case EMT_PARALLAX_MAP_SOLID:
+		case EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA:
+			shader = ETR_NORMAL_MAP_SOLID;
+			LightSpace.Flags |= VERTEXTRANSFORM;
+			break;
+
 		default:
 			break;
 
@@ -318,16 +639,20 @@ void CBurningVideoDriver::setTransform(E_TRANSFORMATION_STATE state, const core:
 		case ETS_WORLD:
 			if ( TransformationFlag[state] & ETF_IDENTITY )
 			{
+				Transformation[ETS_WORLD_INVERSE] = Transformation[ETS_WORLD];
+				TransformationFlag[ETS_WORLD_INVERSE] |= ETF_IDENTITY;
 				Transformation[ETS_CURRENT] = Transformation[ETS_VIEW_PROJECTION];
 			}
 			else
 			{
+				Transformation[ETS_WORLD].getInversePrimitive ( Transformation[ETS_WORLD_INVERSE] );
 				Transformation[ETS_CURRENT].setbyproduct_nocheck (
 					Transformation[ETS_VIEW_PROJECTION],
 					Transformation[ETS_WORLD]
 				);
 			}
 			TransformationFlag[ETS_CURRENT] = 0;
+			//getLightPosObjectSpace ();
 			break;
 		case ETS_TEXTURE_0:
 		case ETS_TEXTURE_1:
@@ -428,6 +753,9 @@ void CBurningVideoDriver::setRenderTarget(video::CImage* image)
 
 	if (DepthBuffer)
 		DepthBuffer->setSize(RenderTargetSize);
+
+	if (StencilBuffer)
+		StencilBuffer->setSize(RenderTargetSize);
 }
 
 
@@ -671,7 +999,7 @@ inline void CBurningVideoDriver::ndc_2_dc_and_project ( s4DVertex *dest,s4DVerte
 		#endif
 
 	#endif
-
+		dest[g].LightTangent[0] = source[g].LightTangent[0] * iw;
 		dest[g].Pos.w = iw;
 	}
 }
@@ -711,6 +1039,7 @@ inline void CBurningVideoDriver::ndc_2_dc_and_project2 ( const s4DVertex **v, co
 		#endif
 	#endif
 
+		a[1].LightTangent[0] = a[0].LightTangent[0] * iw;
 		a[1].Pos.w = iw;
 
 	}
@@ -763,7 +1092,7 @@ inline f32 CBurningVideoDriver::texelarea2 ( const s4DVertex **v, s32 tex ) cons
 
 /*!
 */
-inline void CBurningVideoDriver::select_polygon_mipmap ( s4DVertex *v, u32 vIn, u32 tex, const core::dimension2du& texSize )
+inline void CBurningVideoDriver::select_polygon_mipmap ( s4DVertex *v, u32 vIn, u32 tex, const core::dimension2du& texSize ) const
 {
 	f32 f[2];
 
@@ -819,7 +1148,7 @@ const SVSize CBurningVideoDriver::vSize[] =
 {
 	{ VERTEX4D_FORMAT_TEXTURE_1 | VERTEX4D_FORMAT_COLOR_1, sizeof(S3DVertex), 1 },
 	{ VERTEX4D_FORMAT_TEXTURE_2 | VERTEX4D_FORMAT_COLOR_1, sizeof(S3DVertex2TCoords),2 },
-	{ VERTEX4D_FORMAT_TEXTURE_2 | VERTEX4D_FORMAT_COLOR_1, sizeof(S3DVertexTangents),2 },
+	{ VERTEX4D_FORMAT_TEXTURE_2 | VERTEX4D_FORMAT_COLOR_1 | VERTEX4D_FORMAT_BUMP_DOT3, sizeof(S3DVertexTangents),2 },
 	{ VERTEX4D_FORMAT_TEXTURE_2 | VERTEX4D_FORMAT_COLOR_1, sizeof(S3DVertex), 2 },
 };
 
@@ -828,8 +1157,7 @@ const SVSize CBurningVideoDriver::vSize[] =
 /*!
 	fill a cache line with transformed, light and clipp test triangles
 */
-void CBurningVideoDriver::VertexCache_fill(const u32 sourceIndex,
-					const u32 destIndex)
+void CBurningVideoDriver::VertexCache_fill(const u32 sourceIndex, const u32 destIndex)
 {
 	u8 * source;
 	s4DVertex *dest;
@@ -865,15 +1193,17 @@ void CBurningVideoDriver::VertexCache_fill(const u32 sourceIndex,
 		else
 		{
 			Transformation[ETS_WORLD].rotateVect ( &LightSpace.normal.x, base->Normal );
-			if ( LightSpace.Flags & NORMALIZE )
-				LightSpace.normal.normalize_xyz();
 
 			// vertex in light space
 			if ( LightSpace.Flags & ( POINTLIGHT | FOG | SPECULAR | VERTEXTRANSFORM) )
 				Transformation[ETS_WORLD].transformVect ( &LightSpace.vertex.x, base->Pos );
 		}
 
+		if ( LightSpace.Flags & NORMALIZE )
+			LightSpace.normal.normalize_xyz();
+
 	}
+
 #endif
 
 #if defined ( SOFTWARE_DRIVER_2_USE_VERTEX_COLOR )
@@ -1007,6 +1337,104 @@ void CBurningVideoDriver::VertexCache_fill(const u32 sourceIndex,
 			}
 		}
 	}
+
+#if 0
+	// tangent space light vector, emboss
+	if ( Lights.size () && ( vSize[VertexCache.vType].Format & VERTEX4D_FORMAT_BUMP_DOT3 ) )
+	{
+		const S3DVertexTangents *tangent = ((S3DVertexTangents*) source );
+		const SBurningShaderLight &light = LightSpace.Light[0];
+
+		sVec4 vp;
+
+		vp.x = light.pos.x - LightSpace.vertex.x;
+		vp.y = light.pos.y - LightSpace.vertex.y;
+		vp.z = light.pos.z - LightSpace.vertex.z;
+
+		vp.normalize_xyz();
+
+		LightSpace.tangent.x = vp.x * tangent->Tangent.X + vp.y * tangent->Tangent.Y + vp.z * tangent->Tangent.Z;
+		LightSpace.tangent.y = vp.x * tangent->Binormal.X + vp.y * tangent->Binormal.Y + vp.z * tangent->Binormal.Z;
+		//LightSpace.tangent.z = vp.x * tangent->Normal.X + vp.y * tangent->Normal.Y + vp.z * tangent->Normal.Z;
+		LightSpace.tangent.z = 0.f;
+		LightSpace.tangent.normalize_xyz();
+
+		f32 scale = 1.f / 128.f;
+		if ( Material.org.MaterialTypeParam > 0.f )
+			scale = Material.org.MaterialTypeParam;
+
+		// emboss, shift coordinates
+		dest->Tex[1].x = dest->Tex[0].x + LightSpace.tangent.x * scale;
+		dest->Tex[1].y = dest->Tex[0].y + LightSpace.tangent.y * scale;
+		//dest->Tex[1].z = LightSpace.tangent.z * scale;
+	}
+#endif
+
+	if ( LightSpace.Light.size () && ( vSize[VertexCache.vType].Format & VERTEX4D_FORMAT_BUMP_DOT3 ) )
+	{
+		const S3DVertexTangents *tangent = ((S3DVertexTangents*) source );
+
+		sVec4 vp;
+
+		dest->LightTangent[0].x = 0.f;
+		dest->LightTangent[0].y = 0.f;
+		dest->LightTangent[0].z = 0.f;
+		for ( u32 i = 0; i < 2 && i < LightSpace.Light.size (); ++i )
+		{
+			const SBurningShaderLight &light = LightSpace.Light[i];
+
+			if ( !light.LightIsOn )
+				continue;
+
+			vp.x = light.pos.x - LightSpace.vertex.x;
+			vp.y = light.pos.y - LightSpace.vertex.y;
+			vp.z = light.pos.z - LightSpace.vertex.z;
+
+	/*
+			vp.x = light.pos_objectspace.x - base->Pos.X;
+			vp.y = light.pos_objectspace.y - base->Pos.Y;
+			vp.z = light.pos_objectspace.z - base->Pos.Z;
+	*/
+
+			vp.normalize_xyz();
+
+
+			// transform by tangent matrix
+			sVec3 l;
+	#if 1
+			l.x = (vp.x * tangent->Tangent.X + vp.y * tangent->Tangent.Y + vp.z * tangent->Tangent.Z );
+			l.y = (vp.x * tangent->Binormal.X + vp.y * tangent->Binormal.Y + vp.z * tangent->Binormal.Z );
+			l.z = (vp.x * tangent->Normal.X + vp.y * tangent->Normal.Y + vp.z * tangent->Normal.Z );
+	#else
+			l.x = (vp.x * tangent->Tangent.X + vp.y * tangent->Binormal.X + vp.z * tangent->Normal.X );
+			l.y = (vp.x * tangent->Tangent.Y + vp.y * tangent->Binormal.Y + vp.z * tangent->Normal.Y );
+			l.z = (vp.x * tangent->Tangent.Z + vp.y * tangent->Binormal.Z + vp.z * tangent->Normal.Z );
+	#endif
+
+
+	/*
+			f32 scale = 1.f / 128.f;
+			scale /= dest->LightTangent[0].b;
+
+			// emboss, shift coordinates
+			dest->Tex[1].x = dest->Tex[0].x + l.r * scale;
+			dest->Tex[1].y = dest->Tex[0].y + l.g * scale;
+	*/
+			dest->Tex[1].x = dest->Tex[0].x;
+			dest->Tex[1].y = dest->Tex[0].y;
+
+			// scale bias
+			dest->LightTangent[0].x += l.x;
+			dest->LightTangent[0].y += l.y;
+			dest->LightTangent[0].z += l.z;
+		}
+		dest->LightTangent[0].setLength ( 0.5f );
+		dest->LightTangent[0].x += 0.5f;
+		dest->LightTangent[0].y += 0.5f;
+		dest->LightTangent[0].z += 0.5f;
+	}
+
+
 #endif
 
 	dest[0].flag = dest[1].flag = vSize[VertexCache.vType].Format;
@@ -1276,6 +1704,7 @@ void CBurningVideoDriver::drawVertexPrimitiveList(const void* vertices, u32 vert
 	s32 lodLevel;
 	u32 i;
 	u32 g;
+	u32 m;
 	video::CSoftwareTexture2* tex;
 
 	for ( i = 0; i < (u32) primitiveCount; ++i )
@@ -1297,23 +1726,19 @@ void CBurningVideoDriver::drawVertexPrimitiveList(const void* vertices, u32 vert
 			if ( Material.org.FrontfaceCulling && F32_GREATER_EQUAL_0( dc_area ) )
 				continue;
 
-			dc_area = core::reciprocal ( dc_area );
-
 			// select mipmap
-
-			for ( g = 0; g != vSize[VertexCache.vType].TexSize; ++g )
-			//for ( g = 0; g != BURNING_MATERIAL_MAX_TEXTURES; ++g )
+			dc_area = core::reciprocal ( dc_area );
+			for ( m = 0; m != vSize[VertexCache.vType].TexSize; ++m )
 			{
-				if ( 0 == (tex = MAT_TEXTURE ( g )) )
+				if ( 0 == (tex = MAT_TEXTURE ( m )) )
 				{
-					CurrentShader->setTextureParam(g, 0, 0);
+					CurrentShader->setTextureParam(m, 0, 0);
 					continue;
 				}
 
-				lodLevel = s32_log2_f32 ( texelarea2 ( face, g ) * dc_area );
-				CurrentShader->setTextureParam(g, tex, lodLevel);
-				select_polygon_mipmap2 ( (s4DVertex**) face, g, tex->getSize() );
-
+				lodLevel = s32_log2_f32 ( texelarea2 ( face, m ) * dc_area  );
+				CurrentShader->setTextureParam(m, tex, lodLevel );
+				select_polygon_mipmap2 ( (s4DVertex**) face, m, tex->getSize() );
 			}
 
 			// rasterize
@@ -1419,20 +1844,21 @@ void CBurningVideoDriver::drawVertexPrimitiveList(const void* vertices, u32 vert
 			continue;
 
 		// select mipmap
-		//for ( g = 0; g != BURNING_MATERIAL_MAX_TEXTURES; ++g )
-		for ( g = 0; g != vSize[VertexCache.vType].TexSize; ++g )
+		dc_area = core::reciprocal ( dc_area );
+		for ( m = 0; m != vSize[VertexCache.vType].TexSize; ++m )
 		{
-			if ( 0 == (tex = MAT_TEXTURE ( g )) )
+			if ( 0 == (tex = MAT_TEXTURE ( m )) )
 			{
-				CurrentShader->setTextureParam(g, 0, 0);
+				CurrentShader->setTextureParam(m, 0, 0);
 				continue;
 			}
 
-			lodLevel = s32_log2_f32 ( texelarea ( CurrentOut.data, g ) / dc_area );
-			CurrentShader->setTextureParam(g, tex, lodLevel);
-			select_polygon_mipmap ( CurrentOut.data, vOut, g, tex->getSize() );
+			lodLevel = s32_log2_f32 ( texelarea ( CurrentOut.data, m ) * dc_area );
+			CurrentShader->setTextureParam(m, tex, lodLevel );
+			select_polygon_mipmap ( CurrentOut.data, vOut, m, tex->getSize() );
 		}
 
+
 		// re-tesselate ( triangle-fan, 0-1-2,0-2-3.. )
 		for ( g = 0; g <= vOut - 6; g += 2 )
 		{
@@ -1517,7 +1943,9 @@ s32 CBurningVideoDriver::addDynamicLight(const SLight& dl)
 void CBurningVideoDriver::turnLightOn(s32 lightIndex, bool turnOn)
 {
 	if(lightIndex > -1 && lightIndex < (s32)LightSpace.Light.size())
-	LightSpace.Light[lightIndex].LightIsOn = turnOn;
+	{
+		LightSpace.Light[lightIndex].LightIsOn = turnOn;
+	}
 }
 
 //! deletes all dynamic lights there are
@@ -1586,6 +2014,28 @@ void CBurningVideoDriver::getCameraPosWorldSpace ()
 	LightSpace.campos.w = 1.f;
 }
 
+void CBurningVideoDriver::getLightPosObjectSpace ()
+{
+	if ( TransformationFlag[ETS_WORLD] & ETF_IDENTITY )
+	{
+		Transformation[ETS_WORLD_INVERSE] = Transformation[ETS_WORLD];
+		TransformationFlag[ETS_WORLD_INVERSE] |= ETF_IDENTITY;
+	}
+	else
+	{
+		Transformation[ETS_WORLD].getInverse ( Transformation[ETS_WORLD_INVERSE] );
+		TransformationFlag[ETS_WORLD_INVERSE] &= ~ETF_IDENTITY;
+	}
+
+	for ( u32 i = 0; i < 1 && i < LightSpace.Light.size(); ++i )
+	{
+		SBurningShaderLight &l = LightSpace.Light[i];
+
+		Transformation[ETS_WORLD_INVERSE].transformVec3 ( &l.pos_objectspace.x, &l.pos.x );
+	}
+}
+
+
 #ifdef SOFTWARE_DRIVER_2_LIGHTING
 
 //! Sets the fog mode.
@@ -1634,6 +2084,9 @@ void CBurningVideoDriver::lightVertex ( s4DVertex *dest, u32 vertexargb )
 	{
 		const SBurningShaderLight &light = LightSpace.Light[i];
 
+		if ( !light.LightIsOn )
+			continue;
+
 		// accumulate ambient
 		ambient.add ( light.AmbientColor );
 
@@ -1645,25 +2098,28 @@ void CBurningVideoDriver::lightVertex ( s4DVertex *dest, u32 vertexargb )
 				vp.x = light.pos.x - LightSpace.vertex.x;
 				vp.y = light.pos.y - LightSpace.vertex.y;
 				vp.z = light.pos.z - LightSpace.vertex.z;
+				//vp.x = light.pos_objectspace.x - LightSpace.vertex.x;
+				//vp.y = light.pos_objectspace.y - LightSpace.vertex.x;
+				//vp.z = light.pos_objectspace.z - LightSpace.vertex.x;
 
 				len = vp.get_length_xyz_square();
 				if ( light.radius < len )
 					continue;
 
-				len = core::squareroot ( len );
-
-				attenuation = light.constantAttenuation + ( 1.f - ( len * light.linearAttenuation ) );
+				len = core::reciprocal_squareroot ( len );
 
 				// build diffuse reflection
 
 				//angle between normal and light vector
-				vp.mulReciprocal ( len );
+				vp.mul ( len );
 				dot = LightSpace.normal.dot_xyz ( vp );
 				if ( dot < 0.f )
 					continue;
 
+				attenuation = light.constantAttenuation + ( 1.f - ( len * light.linearAttenuation ) );
+
 				// diffuse component
-				diffuse.mulAdd ( light.DiffuseColor, dot * attenuation );
+				diffuse.mulAdd ( light.DiffuseColor, 3.f * dot * attenuation );
 
 				if ( !(LightSpace.Flags & SPECULAR) )
 					continue;
@@ -1987,20 +2443,20 @@ void CBurningVideoDriver::draw3DLine(const core::vector3df& start,
 const wchar_t* CBurningVideoDriver::getName() const
 {
 #ifdef BURNINGVIDEO_RENDERER_BEAUTIFUL
-	return L"Burning's Video 0.44 beautiful";
+	return L"Burning's Video 0.46 beautiful";
 #elif defined ( BURNINGVIDEO_RENDERER_ULTRA_FAST )
-	return L"Burning's Video 0.44 ultra fast";
+	return L"Burning's Video 0.46 ultra fast";
 #elif defined ( BURNINGVIDEO_RENDERER_FAST )
-	return L"Burning's Video 0.44 fast";
+	return L"Burning's Video 0.46 fast";
 #else
-	return L"Burning's Video 0.44";
+	return L"Burning's Video 0.46";
 #endif
 }
 
 //! Returns the graphics card vendor name.
 core::stringc CBurningVideoDriver::getVendorInfo()
 {
-	return "Burning's Video: Ing. Thomas Alten (c) 2006-2009";
+	return "Burning's Video: Ing. Thomas Alten (c) 2006-2010";
 }
 
 
@@ -2084,82 +2540,135 @@ u32 CBurningVideoDriver::getMaximalPrimitiveCount() const
 
 //! Draws a shadow volume into the stencil buffer. To draw a stencil shadow, do
 //! this: First, draw all geometry. Then use this method, to draw the shadow
-//! volume. Then, use IVideoDriver::drawStencilShadow() to visualize the shadow.
+//! volume. Next use IVideoDriver::drawStencilShadow() to visualize the shadow.
 void CBurningVideoDriver::drawStencilShadowVolume(const core::vector3df* triangles, s32 count, bool zfail)
 {
-/*
+#if 0
 	if (!StencilBuffer || !count)
 		return;
 
-	setRenderStatesStencilShadowMode(zfail);
-
-	if (!zfail)
+	// unset last 3d material
+	if (CurrentRenderMode == ERM_3D &&
+		static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())
 	{
-		// ZPASS Method
-
-		// Draw front-side of shadow volume in stencil/z only
-		pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW );
-		pID3DDevice->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_INCRSAT);
-		pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles, sizeof(core::vector3df));
-
-		// Now reverse cull order so front sides of shadow volume are written.
-		pID3DDevice->SetRenderState( D3DRS_CULLMODE,   D3DCULL_CW );
-		pID3DDevice->SetRenderState( D3DRS_STENCILPASS, D3DSTENCILOP_DECRSAT);
-		pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles, sizeof(core::vector3df));
+		MaterialRenderers[Material.MaterialType].Renderer->OnUnsetMaterial();
+		ResetRenderStates = true;
 	}
-	else
+
+	// store current OpenGL state
+	glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT |
+		GL_POLYGON_BIT | GL_STENCIL_BUFFER_BIT);
+
+	glDisable(GL_LIGHTING);
+	glDisable(GL_FOG);
+	glDepthFunc(GL_LEQUAL);
+	glDepthMask(GL_FALSE); // no depth buffer writing
+	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // no color buffer drawing
+	glEnable(GL_STENCIL_TEST);
+	glEnable(GL_POLYGON_OFFSET_FILL);
+	glPolygonOffset(0.0f, 1.0f);
+
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glVertexPointer(3,GL_FLOAT,sizeof(core::vector3df),&triangles[0]);
+	glStencilMask(~0);
+	glStencilFunc(GL_ALWAYS, 0, ~0);
+
+	GLenum incr = GL_INCR;
+	GLenum decr = GL_DECR;
+	if (FeatureAvailable[IRR_EXT_stencil_wrap])
 	{
-		// ZFAIL Method
-
-		// Draw front-side of shadow volume in stencil/z only
-		pID3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW );
-		pID3DDevice->SetRenderState(D3DRS_STENCILZFAIL, D3DSTENCILOP_INCRSAT );
-		pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles, sizeof(core::vector3df));
-
-		// Now reverse cull order so front sides of shadow volume are written.
-		pID3DDevice->SetRenderState( D3DRS_CULLMODE,   D3DCULL_CCW );
-		pID3DDevice->SetRenderState( D3DRS_STENCILZFAIL,  D3DSTENCILOP_DECRSAT );
-		pID3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, count / 3, triangles, sizeof(core::vector3df));
+		incr = GL_INCR_WRAP_EXT;
+		decr = GL_DECR_WRAP_EXT;
 	}
-*/
+
+	{
+		glEnable(GL_CULL_FACE);
+		if (zfail)
+		{
+			glCullFace(GL_FRONT);
+			glStencilOp(GL_KEEP, incr, GL_KEEP);
+			glDrawArrays(GL_TRIANGLES,0,count);
+
+			glCullFace(GL_BACK);
+			glStencilOp(GL_KEEP, decr, GL_KEEP);
+			glDrawArrays(GL_TRIANGLES,0,count);
+		}
+		else // zpass
+		{
+			glCullFace(GL_BACK);
+			glStencilOp(GL_KEEP, GL_KEEP, incr);
+			glDrawArrays(GL_TRIANGLES,0,count);
+
+			glCullFace(GL_FRONT);
+			glStencilOp(GL_KEEP, GL_KEEP, decr);
+			glDrawArrays(GL_TRIANGLES,0,count);
+		}
+	}
+
+	glDisableClientState(GL_VERTEX_ARRAY); //not stored on stack
+	glPopAttrib();
+#endif
 }
 
 
-
-//! Fills the stencil shadow with color. After the shadow volume has been drawn
-//! into the stencil buffer using IVideoDriver::drawStencilShadowVolume(), use this
-//! to draw the color of the shadow.
 void CBurningVideoDriver::drawStencilShadow(bool clearStencilBuffer, video::SColor leftUpEdge,
-			video::SColor rightUpEdge, video::SColor leftDownEdge, video::SColor rightDownEdge)
+	video::SColor rightUpEdge, video::SColor leftDownEdge, video::SColor rightDownEdge)
 {
-/*
+#if 0
 	if (!StencilBuffer)
 		return;
 
-	S3DVertex vtx[4];
-	vtx[0] = S3DVertex(1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, leftUpEdge, 0.0f, 0.0f);
-	vtx[1] = S3DVertex(1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, rightUpEdge, 0.0f, 1.0f);
-	vtx[2] = S3DVertex(-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, leftDownEdge, 1.0f, 0.0f);
-	vtx[3] = S3DVertex(-1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, rightDownEdge, 1.0f, 1.0f);
+	disableTextures();
 
-	s16 indices[6] = {0,1,2,1,3,2};
+	// store attributes
+	glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT | GL_STENCIL_BUFFER_BIT);
 
-	setRenderStatesStencilFillMode(
-		leftUpEdge.getAlpha() < 255 ||
-		rightUpEdge.getAlpha() < 255 ||
-		leftDownEdge.getAlpha() < 255 ||
-		rightDownEdge.getAlpha() < 255);
+	glDisable(GL_LIGHTING);
+	glDisable(GL_FOG);
+	glDepthMask(GL_FALSE);
 
-	setTexture(0,0);
+	glShadeModel(GL_FLAT);
+	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
-	setVertexShader(EVT_STANDARD);
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	pID3DDevice->DrawIndexedPrimitiveUP(D3DPT_TRIANGLELIST, 0, 4, 2, &indices[0],
-		D3DFMT_INDEX16, &vtx[0], sizeof(S3DVertex));
+	glEnable(GL_STENCIL_TEST);
+	glStencilFunc(GL_NOTEQUAL, 0, ~0);
+	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 
-	if (clearStencilBuffer)
-		pID3DDevice->Clear( 0, NULL, D3DCLEAR_STENCIL,0, 1.0, 0);
-*/
+	// draw a shadow rectangle covering the entire screen using stencil buffer
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+
+	glBegin(GL_QUADS);
+
+	glColor4ub(leftDownEdge.getRed(), leftDownEdge.getGreen(), leftDownEdge.getBlue(), leftDownEdge.getAlpha());
+	glVertex3f(-1.f,-1.f,-0.9f);
+
+	glColor4ub(leftUpEdge.getRed(), leftUpEdge.getGreen(), leftUpEdge.getBlue(), leftUpEdge.getAlpha());
+	glVertex3f(-1.f, 1.f,-0.9f);
+
+	glColor4ub(rightUpEdge.getRed(), rightUpEdge.getGreen(), rightUpEdge.getBlue(), rightUpEdge.getAlpha());
+	glVertex3f(1.f, 1.f,-0.9f);
+
+	glColor4ub(rightDownEdge.getRed(), rightDownEdge.getGreen(), rightDownEdge.getBlue(), rightDownEdge.getAlpha());
+	glVertex3f(1.f,-1.f,-0.9f);
+
+	glEnd();
+
+	clearBuffers(false, false, clearStencilBuffer, 0x0);
+
+	// restore settings
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+	glPopAttrib();
+#endif
 }
 
 
@@ -2180,10 +2689,10 @@ namespace video
 {
 
 //! creates a video driver
-IVideoDriver* createSoftwareDriver2(const core::dimension2d<u32>& windowSize, bool fullscreen, io::IFileSystem* io, video::IImagePresenter* presenter)
+IVideoDriver* createBurningVideoDriver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, video::IImagePresenter* presenter)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CBurningVideoDriver(windowSize, fullscreen, io, presenter);
+	return new CBurningVideoDriver(params, io, presenter);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CSoftwareDriver2.h

@@ -11,6 +11,7 @@
 #include "CImage.h"
 #include "os.h"
 #include "irrString.h"
+#include "SIrrCreationParameters.h"
 
 namespace irr
 {
@@ -21,7 +22,7 @@ namespace video
 	public:
 
 		//! constructor
-		CBurningVideoDriver(const core::dimension2d<u32>& windowSize, bool fullscreen, io::IFileSystem* io, video::IImagePresenter* presenter);
+		CBurningVideoDriver(const irr::SIrrlichtCreationParameters& params, io::IFileSystem* io, video::IImagePresenter* presenter);
 
 		//! destructor
 		virtual ~CBurningVideoDriver();
@@ -157,6 +158,8 @@ namespace video
 		//! Returns the maximum texture size supported.
 		virtual core::dimension2du getMaxTextureSize() const;
 
+		virtual IDepthBuffer * getDepthBuffer () { return DepthBuffer; }
+
 	protected:
 
 
@@ -187,6 +190,7 @@ namespace video
 		IBurningShader* BurningShader[ETR2_COUNT];
 
 		IDepthBuffer* DepthBuffer;
+		IStencilBuffer* StencilBuffer;
 
 
 		/*
@@ -201,6 +205,7 @@ namespace video
 			ETS_CURRENT,
 			ETS_CLIPSCALE,
 			ETS_VIEW_INVERSE,
+			ETS_WORLD_INVERSE,
 
 			ETS_COUNT_BURNING
 		};
@@ -215,6 +220,7 @@ namespace video
 		core::matrix4 Transformation[ETS_COUNT_BURNING];
 
 		void getCameraPosWorldSpace ();
+		void getLightPosObjectSpace ();
 
 
 		// Vertex Cache
@@ -254,7 +260,7 @@ namespace video
 
 		void ndc_2_dc_and_project ( s4DVertex *dest,s4DVertex *source, u32 vIn ) const;
 		f32 screenarea ( const s4DVertex *v0 ) const;
-		void select_polygon_mipmap ( s4DVertex *source, u32 vIn, u32 tex, const core::dimension2du& texSize );
+		void select_polygon_mipmap ( s4DVertex *source, u32 vIn, u32 tex, const core::dimension2du& texSize ) const;
 		f32 texelarea ( const s4DVertex *v0, int tex ) const;
 
 

source/Irrlicht/CSoftwareTexture2.cpp

@@ -66,6 +66,8 @@ CSoftwareTexture2::CSoftwareTexture2(IImage* image, const io::path& name,
 			MipMap[0] = new CImage(BURNINGSHADER_COLOR_FORMAT, optSize);
 			image->copyToScalingBoxFilter ( MipMap[0],0, false );
 		}
+
+		OrigImageDataSizeInPixels = (f32) 0.3f * MipMap[0]->getImageDataSizeInPixels();
 	}
 
 	regenerateMipMapLevels(mipmapData);
@@ -139,6 +141,8 @@ void CSoftwareTexture2::regenerateMipMapLevels(void* mipmapData)
 		else
 		{
 			MipMap[i] = new CImage(BURNINGSHADER_COLOR_FORMAT, newSize);
+
+			//static u32 color[] = { 0, 0xFFFF0000, 0xFF00FF00,0xFF0000FF,0xFFFFFF00,0xFFFF00FF,0xFF00FFFF,0xFF0F0F0F };
 			MipMap[i]->fill ( 0 );
 			MipMap[0]->copyToScalingBoxFilter( MipMap[i], 0, false );
 		}

source/Irrlicht/CSoftwareTexture2.h

@@ -59,7 +59,8 @@ public:
 	//! Returns the size of the largest mipmap.
 	f32 getLODFactor( const f32 texArea ) const
 	{
-		return MipMap[0]->getImageDataSizeInPixels () * texArea;
+		return OrigImageDataSizeInPixels * texArea;
+		//return MipMap[0]->getImageDataSizeInPixels () * texArea;
 	}
 
 	//! Returns (=size) of the texture.
@@ -122,6 +123,7 @@ public:
 	}
 
 private:
+	f32 OrigImageDataSizeInPixels;
 	core::dimension2d<u32> OrigSize;
 
 	CImage * MipMap[SOFTWARE_DRIVER_2_MIPMAPPING_MAX];

source/Irrlicht/CTRGouraud2.cpp

@@ -80,7 +80,7 @@ class CTRGouraud2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRGouraud2(IDepthBuffer* zbuffer);
+	CTRGouraud2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRGouraud2::CTRGouraud2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRGouraud2::CTRGouraud2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRGouraud2");
@@ -631,10 +631,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererGouraud2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererGouraud2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRGouraud2(zbuffer);
+	return new CTRGouraud2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRGouraudAlpha2.cpp

@@ -81,7 +81,7 @@ class CTRGouraudAlpha2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRGouraudAlpha2(IDepthBuffer* zbuffer);
+	CTRGouraudAlpha2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -96,8 +96,8 @@ private:
 };
 
 //! constructor
-CTRGouraudAlpha2::CTRGouraudAlpha2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRGouraudAlpha2::CTRGouraudAlpha2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRGouraudAlpha2");
@@ -640,10 +640,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererGouraudAlpha2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererGouraudAlpha2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRGouraudAlpha2(zbuffer);
+	return new CTRGouraudAlpha2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRGouraudAlphaNoZ2.cpp

@@ -81,7 +81,7 @@ class CTRGouraudAlphaNoZ2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRGouraudAlphaNoZ2(IDepthBuffer* zbuffer);
+	CTRGouraudAlphaNoZ2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -95,8 +95,8 @@ private:
 };
 
 //! constructor
-CTRGouraudAlphaNoZ2::CTRGouraudAlphaNoZ2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRGouraudAlphaNoZ2::CTRGouraudAlphaNoZ2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRGouraudAlphaNoZ2");
@@ -641,10 +641,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTRGouraudAlphaNoZ2(IDepthBuffer* zbuffer)
+IBurningShader* createTRGouraudAlphaNoZ2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRGouraudAlphaNoZ2(zbuffer);
+	return new CTRGouraudAlphaNoZ2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRNormalMap.cpp

@@ -0,0 +1,878 @@
+// Copyright (C) 2002-2009 Nikolaus Gebhardt / Thomas Alten
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "IrrCompileConfig.h"
+#include "IBurningShader.h"
+
+#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
+
+// compile flag for this file
+#undef USE_ZBUFFER
+#undef IPOL_Z
+#undef CMP_Z
+#undef WRITE_Z
+
+#undef IPOL_W
+#undef CMP_W
+#undef WRITE_W
+
+#undef SUBTEXEL
+#undef INVERSE_W
+
+#undef IPOL_C0
+#undef IPOL_T0
+#undef IPOL_T1
+#undef IPOL_T2
+#undef IPOL_L0
+
+// define render case
+#define SUBTEXEL
+#define INVERSE_W
+
+#define USE_ZBUFFER
+#define IPOL_W
+#define CMP_W
+#define WRITE_W
+
+#define IPOL_C0
+#define IPOL_T0
+#define IPOL_T1
+#define IPOL_L0
+
+// apply global override
+#ifndef SOFTWARE_DRIVER_2_PERSPECTIVE_CORRECT
+	#undef INVERSE_W
+#endif
+
+#ifndef SOFTWARE_DRIVER_2_SUBTEXEL
+	#undef SUBTEXEL
+#endif
+
+#ifndef SOFTWARE_DRIVER_2_USE_VERTEX_COLOR
+	#undef IPOL_C0
+#endif
+
+#if !defined ( SOFTWARE_DRIVER_2_USE_WBUFFER ) && defined ( USE_ZBUFFER )
+	#ifndef SOFTWARE_DRIVER_2_PERSPECTIVE_CORRECT
+		#undef IPOL_W
+	#endif
+	#define IPOL_Z
+
+	#ifdef CMP_W
+		#undef CMP_W
+		#define CMP_Z
+	#endif
+
+	#ifdef WRITE_W
+		#undef WRITE_W
+		#define WRITE_Z
+	#endif
+
+#endif
+
+
+namespace irr
+{
+
+namespace video
+{
+
+#define iter1(N) trial = root + (1 << (N)); if (n >= trial << (N)) { n -= trial << (N); root |= 2 << (N); }
+
+tFixPoint fixsqrt (tFixPoint n)
+{
+    tFixPoint root = 0, trial;
+    iter1 (15);    iter1 (14);    iter1 (13);    iter1 (12);
+    iter1 (11);    iter1 (10);    iter1 ( 9);    iter1 ( 8);
+    iter1 ( 7);    iter1 ( 6);    iter1 ( 5);    iter1 ( 4);
+    iter1 ( 3);    iter1 ( 2);    iter1 ( 1);    iter1 ( 0);
+    return root >> 1;
+}
+
+
+
+class CTRNormalMap : public IBurningShader
+{
+public:
+
+	//! constructor
+	CTRNormalMap(CBurningVideoDriver* driver);
+
+	//! draws an indexed triangle list
+	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
+
+
+private:
+	void scanline_bilinear ();
+
+	sScanConvertData scan;
+	sScanLineData line;
+
+};
+
+#include <windows.h>
+
+//! constructor
+CTRNormalMap::CTRNormalMap(CBurningVideoDriver* driver)
+: IBurningShader(driver)
+{
+	#ifdef _DEBUG
+	setDebugName("CTRNormalMap");
+	#endif
+/*
+	char buf[256];
+	f32 f = 0.f;
+	tFixPoint a;
+	tFixPoint b;
+	for ( u32 i = 0; i < 100000; ++i )
+	{
+		f += 0.5f;
+		f32 r = sqrtf ( f );
+		a = tofix ( f );
+		b = fixsqrt ( a );
+		sprintf ( buf, "%.7f %.7f %.7f %.7f\n", f, r, a / FIX_POINT_F32_MUL, b / FIX_POINT_F32_MUL );
+		OutputDebugStringA ( buf );
+	}
+*/
+}
+
+
+
+/*!
+*/
+void CTRNormalMap::scanline_bilinear ()
+{
+	tVideoSample *dst;
+
+#ifdef USE_ZBUFFER
+	fp24 *z;
+#endif
+
+	s32 xStart;
+	s32 xEnd;
+	s32 dx;
+
+
+#ifdef SUBTEXEL
+	f32 subPixel;
+#endif
+
+#ifdef IPOL_Z
+	f32 slopeZ;
+#endif
+#ifdef IPOL_W
+	fp24 slopeW;
+#endif
+#ifdef IPOL_C0
+	sVec4 slopeC[MATERIAL_MAX_COLORS];
+#endif
+#ifdef IPOL_T0
+	sVec2 slopeT[BURNING_MATERIAL_MAX_TEXTURES];
+#endif
+#ifdef IPOL_L0
+	sVec3 slopeL[BURNING_MATERIAL_MAX_TANGENT];
+#endif
+
+	// apply top-left fill-convention, left
+	xStart = core::ceil32( line.x[0] );
+	xEnd = core::ceil32( line.x[1] ) - 1;
+
+	dx = xEnd - xStart;
+
+	if ( dx < 0 )
+		return;
+
+	// slopes
+	const f32 invDeltaX = core::reciprocal_approxim ( line.x[1] - line.x[0] );
+
+#ifdef IPOL_Z
+	slopeZ = (line.z[1] - line.z[0]) * invDeltaX;
+#endif
+#ifdef IPOL_W
+	slopeW = (line.w[1] - line.w[0]) * invDeltaX;
+#endif
+#ifdef IPOL_C0
+	slopeC[0] = (line.c[0][1] - line.c[0][0]) * invDeltaX;
+#endif
+#ifdef IPOL_T0
+	slopeT[0] = (line.t[0][1] - line.t[0][0]) * invDeltaX;
+#endif
+#ifdef IPOL_T1
+	slopeT[1] = (line.t[1][1] - line.t[1][0]) * invDeltaX;
+#endif
+#ifdef IPOL_T2
+	slopeT[2] = (line.t[2][1] - line.t[2][0]) * invDeltaX;
+#endif
+#ifdef IPOL_L0
+	slopeL[0] = (line.l[0][1] - line.l[0][0]) * invDeltaX;
+#endif
+
+#ifdef SUBTEXEL
+	subPixel = ( (f32) xStart ) - line.x[0];
+#ifdef IPOL_Z
+	line.z[0] += slopeZ * subPixel;
+#endif
+#ifdef IPOL_W
+	line.w[0] += slopeW * subPixel;
+#endif
+#ifdef IPOL_C0
+	line.c[0][0] += slopeC[0] * subPixel;
+#endif
+#ifdef IPOL_T0
+	line.t[0][0] += slopeT[0] * subPixel;
+#endif
+#ifdef IPOL_T1
+	line.t[1][0] += slopeT[1] * subPixel;
+#endif
+#ifdef IPOL_T2
+	line.t[2][0] += slopeT[2] * subPixel;
+#endif
+#ifdef IPOL_L0
+	line.l[0][0] += slopeL[0] * subPixel;
+#endif
+#endif
+
+	dst = (tVideoSample*)RenderTarget->lock() + ( line.y * RenderTarget->getDimension().Width ) + xStart;
+
+#ifdef USE_ZBUFFER
+	z = (fp24*) DepthBuffer->lock() + ( line.y * RenderTarget->getDimension().Width ) + xStart;
+#endif
+
+
+#ifdef INVERSE_W
+	f32 inversew;
+#endif
+
+	tFixPoint tx0, tx1;
+	tFixPoint ty0, ty1;
+
+	tFixPoint r0, g0, b0;
+	tFixPoint r1, g1, b1;
+	tFixPoint r2, g2, b2;
+
+	tFixPoint lx, ly, lz;
+	tFixPoint ndotl;
+
+	sVec3 light;
+
+
+#ifdef IPOL_C0
+	tFixPoint r3, g3, b3;
+#endif
+
+	for ( s32 i = 0; i <= dx; i++ )
+	{
+#ifdef CMP_Z
+		if ( line.z[0] < z[i] )
+#endif
+#ifdef CMP_W
+		if ( line.w[0] >= z[i] )
+#endif
+		{
+#ifdef INVERSE_W
+			inversew = fix_inverse32 ( line.w[0] );
+
+			tx0 = tofix ( line.t[0][0].x,inversew);
+			ty0 = tofix ( line.t[0][0].y,inversew);
+			tx1 = tofix ( line.t[1][0].x,inversew);
+			ty1 = tofix ( line.t[1][0].y,inversew);
+
+
+#ifdef IPOL_C0
+			r3 = tofix ( line.c[0][0].y ,inversew );
+			g3 = tofix ( line.c[0][0].z ,inversew );
+			b3 = tofix ( line.c[0][0].w ,inversew );
+#endif
+
+#else
+			tx0 = tofix ( line.t[0][0].x );
+			ty0 = tofix ( line.t[0][0].y );
+			tx1 = tofix ( line.t[1][0].x );
+			ty1 = tofix ( line.t[1][0].y );
+
+#ifdef IPOL_C0
+			r3 = tofix ( line.c[0][0].y );
+			g3 = tofix ( line.c[0][0].z );
+			b3 = tofix ( line.c[0][0].w );
+#endif
+
+#endif
+			getSample_texture ( r0, g0, b0, &IT[0], tx0, ty0 );
+
+			// normal map
+			getSample_texture ( r1, g1, b1, &IT[1], tx1, ty1 );
+
+			r1 = ( r1 - FIX_POINT_HALF_COLOR) >> (COLOR_MAX_LOG2-1);
+			g1 = ( g1 - FIX_POINT_HALF_COLOR) >> (COLOR_MAX_LOG2-1);
+			b1 = ( b1 - FIX_POINT_HALF_COLOR) >> (COLOR_MAX_LOG2-1);
+
+/*
+			sVec3 l = line.l[0][0] * inversew;
+			l.setLength( 2.f );
+
+			lx = tofix ( l.x - 0.5f );
+			ly = tofix ( l.y - 0.5f );
+			lz = tofix ( l.z - 0.5f );
+*/
+
+			lx = tofix ( line.l[0][0].x, inversew );
+			ly = tofix ( line.l[0][0].y, inversew );
+			lz = tofix ( line.l[0][0].z, inversew );
+
+			// DOT 3 Normal Map light in tangent space
+			ndotl = saturateFix ( FIX_POINT_HALF_COLOR +  (( imulFix ( r1, lx ) + imulFix ( g1, ly ) + imulFix ( b1, lz ) ) << (COLOR_MAX_LOG2-1)) );
+
+#ifdef IPOL_C0
+
+			// N . L
+			r2 = imulFix ( imulFix_tex1 ( r0, ndotl ), r3 );
+			g2 = imulFix ( imulFix_tex1 ( g0, ndotl ), g3 );
+			b2 = imulFix ( imulFix_tex1 ( b0, ndotl ), b3 );
+
+/*
+			// heightmap: (1 - neu ) + alt - 0.5, on_minus_srcalpha + add signed
+			// emboss bump map
+			a4 -= a1;
+			r2 = clampfix_maxcolor ( clampfix_mincolor ( imulFix ( r0 + a4, r3 ) ) );
+			g2 = clampfix_maxcolor ( clampfix_mincolor ( imulFix ( g0 + a4, g3 ) ) );
+			b2 = clampfix_maxcolor ( clampfix_mincolor ( imulFix ( b0 + a4, b3 ) ) );
+*/
+
+/*
+			r2 = clampfix_maxcolor ( imulFix_tex1 ( r2, r1 ) );
+			g2 = clampfix_maxcolor ( imulFix_tex1 ( g2, g1 ) );
+			b2 = clampfix_maxcolor ( imulFix_tex1 ( b2, b1 ) );
+*/
+#else
+			r2 = clampfix_maxcolor ( imulFix_tex4 ( r0, r1 ) );
+			g2 = clampfix_maxcolor ( imulFix_tex4 ( g0, g1 ) );
+			b2 = clampfix_maxcolor ( imulFix_tex4 ( b0, b1 ) );
+#endif
+
+
+			dst[i] = fix_to_color ( r2, g2, b2 );
+
+#ifdef WRITE_Z
+			z[i] = line.z[0];
+#endif
+#ifdef WRITE_W
+			z[i] = line.w[0];
+#endif
+		}
+
+#ifdef IPOL_Z
+		line.z[0] += slopeZ;
+#endif
+#ifdef IPOL_W
+		line.w[0] += slopeW;
+#endif
+#ifdef IPOL_C0
+		line.c[0][0] += slopeC[0];
+#endif
+#ifdef IPOL_T0
+		line.t[0][0] += slopeT[0];
+#endif
+#ifdef IPOL_T1
+		line.t[1][0] += slopeT[1];
+#endif
+#ifdef IPOL_T2
+		line.t[2][0] += slopeT[2];
+#endif
+#ifdef IPOL_L0
+		line.l[0][0] += slopeL[0];
+#endif
+	}
+
+}
+
+void CTRNormalMap::drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c )
+{
+	// sort on height, y
+	if ( F32_A_GREATER_B ( a->Pos.y , b->Pos.y ) ) swapVertexPointer(&a, &b);
+	if ( F32_A_GREATER_B ( b->Pos.y , c->Pos.y ) ) swapVertexPointer(&b, &c);
+	if ( F32_A_GREATER_B ( a->Pos.y , b->Pos.y ) ) swapVertexPointer(&a, &b);
+
+	const f32 ca = c->Pos.y - a->Pos.y;
+	const f32 ba = b->Pos.y - a->Pos.y;
+	const f32 cb = c->Pos.y - b->Pos.y;
+	// calculate delta y of the edges
+	scan.invDeltaY[0] = core::reciprocal( ca );
+	scan.invDeltaY[1] = core::reciprocal( ba );
+	scan.invDeltaY[2] = core::reciprocal( cb );
+
+	if ( F32_LOWER_EQUAL_0 ( scan.invDeltaY[0] )  )
+		return;
+
+	// find if the major edge is left or right aligned
+	f32 temp[4];
+
+	temp[0] = a->Pos.x - c->Pos.x;
+	temp[1] = -ca;
+	temp[2] = b->Pos.x - a->Pos.x;
+	temp[3] = ba;
+
+	scan.left = ( temp[0] * temp[3] - temp[1] * temp[2] ) > 0.f ? 0 : 1;
+	scan.right = 1 - scan.left;
+
+	// calculate slopes for the major edge
+	scan.slopeX[0] = (c->Pos.x - a->Pos.x) * scan.invDeltaY[0];
+	scan.x[0] = a->Pos.x;
+
+#ifdef IPOL_Z
+	scan.slopeZ[0] = (c->Pos.z - a->Pos.z) * scan.invDeltaY[0];
+	scan.z[0] = a->Pos.z;
+#endif
+
+#ifdef IPOL_W
+	scan.slopeW[0] = (c->Pos.w - a->Pos.w) * scan.invDeltaY[0];
+	scan.w[0] = a->Pos.w;
+#endif
+
+#ifdef IPOL_C0
+	scan.slopeC[0][0] = (c->Color[0] - a->Color[0]) * scan.invDeltaY[0];
+	scan.c[0][0] = a->Color[0];
+#endif
+
+#ifdef IPOL_T0
+	scan.slopeT[0][0] = (c->Tex[0] - a->Tex[0]) * scan.invDeltaY[0];
+	scan.t[0][0] = a->Tex[0];
+#endif
+
+#ifdef IPOL_T1
+	scan.slopeT[1][0] = (c->Tex[1] - a->Tex[1]) * scan.invDeltaY[0];
+	scan.t[1][0] = a->Tex[1];
+#endif
+
+#ifdef IPOL_T2
+	scan.slopeT[2][0] = (c->Tex[2] - a->Tex[2]) * scan.invDeltaY[0];
+	scan.t[2][0] = a->Tex[2];
+#endif
+
+#ifdef IPOL_L0
+	scan.slopeL[0][0] = (c->LightTangent[0] - a->LightTangent[0]) * scan.invDeltaY[0];
+	scan.l[0][0] = a->LightTangent[0];
+#endif
+
+	// top left fill convention y run
+	s32 yStart;
+	s32 yEnd;
+
+#ifdef SUBTEXEL
+	f32 subPixel;
+#endif
+
+
+	// rasterize upper sub-triangle
+	//if ( (f32) 0.0 != scan.invDeltaY[1]  )
+	if ( F32_GREATER_0 ( scan.invDeltaY[1] )  )
+	{
+		// calculate slopes for top edge
+		scan.slopeX[1] = (b->Pos.x - a->Pos.x) * scan.invDeltaY[1];
+		scan.x[1] = a->Pos.x;
+
+#ifdef IPOL_Z
+		scan.slopeZ[1] = (b->Pos.z - a->Pos.z) * scan.invDeltaY[1];
+		scan.z[1] = a->Pos.z;
+#endif
+
+#ifdef IPOL_W
+		scan.slopeW[1] = (b->Pos.w - a->Pos.w) * scan.invDeltaY[1];
+		scan.w[1] = a->Pos.w;
+#endif
+
+#ifdef IPOL_C0
+		scan.slopeC[0][1] = (b->Color[0] - a->Color[0]) * scan.invDeltaY[1];
+		scan.c[0][1] = a->Color[0];
+#endif
+
+#ifdef IPOL_T0
+		scan.slopeT[0][1] = (b->Tex[0] - a->Tex[0]) * scan.invDeltaY[1];
+		scan.t[0][1] = a->Tex[0];
+#endif
+
+#ifdef IPOL_T1
+		scan.slopeT[1][1] = (b->Tex[1] - a->Tex[1]) * scan.invDeltaY[1];
+		scan.t[1][1] = a->Tex[1];
+#endif
+
+#ifdef IPOL_T2
+		scan.slopeT[2][1] = (b->Tex[2] - a->Tex[2]) * scan.invDeltaY[1];
+		scan.t[2][1] = a->Tex[2];
+#endif
+
+#ifdef IPOL_L0
+		scan.slopeL[0][1] = (b->LightTangent[0] - a->LightTangent[0]) * scan.invDeltaY[1];
+		scan.l[0][1] = a->LightTangent[0];
+#endif
+
+		// apply top-left fill convention, top part
+		yStart = core::ceil32( a->Pos.y );
+		yEnd = core::ceil32( b->Pos.y ) - 1;
+
+#ifdef SUBTEXEL
+		subPixel = ( (f32) yStart ) - a->Pos.y;
+
+		// correct to pixel center
+		scan.x[0] += scan.slopeX[0] * subPixel;
+		scan.x[1] += scan.slopeX[1] * subPixel;		
+
+#ifdef IPOL_Z
+		scan.z[0] += scan.slopeZ[0] * subPixel;
+		scan.z[1] += scan.slopeZ[1] * subPixel;		
+#endif
+
+#ifdef IPOL_W
+		scan.w[0] += scan.slopeW[0] * subPixel;
+		scan.w[1] += scan.slopeW[1] * subPixel;		
+#endif
+
+#ifdef IPOL_C0
+		scan.c[0][0] += scan.slopeC[0][0] * subPixel;
+		scan.c[0][1] += scan.slopeC[0][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T0
+		scan.t[0][0] += scan.slopeT[0][0] * subPixel;
+		scan.t[0][1] += scan.slopeT[0][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T1
+		scan.t[1][0] += scan.slopeT[1][0] * subPixel;
+		scan.t[1][1] += scan.slopeT[1][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T2
+		scan.t[2][0] += scan.slopeT[2][0] * subPixel;
+		scan.t[2][1] += scan.slopeT[2][1] * subPixel;		
+#endif
+
+#ifdef IPOL_L0
+		scan.l[0][0] += scan.slopeL[0][0] * subPixel;
+		scan.l[0][1] += scan.slopeL[0][1] * subPixel;		
+#endif
+
+#endif
+
+		// rasterize the edge scanlines
+		for( line.y = yStart; line.y <= yEnd; ++line.y)
+		{
+			line.x[scan.left] = scan.x[0];
+			line.x[scan.right] = scan.x[1];
+
+#ifdef IPOL_Z
+			line.z[scan.left] = scan.z[0];
+			line.z[scan.right] = scan.z[1];
+#endif
+
+#ifdef IPOL_W
+			line.w[scan.left] = scan.w[0];
+			line.w[scan.right] = scan.w[1];
+#endif
+
+#ifdef IPOL_C0
+			line.c[0][scan.left] = scan.c[0][0];
+			line.c[0][scan.right] = scan.c[0][1];
+#endif
+
+#ifdef IPOL_T0
+			line.t[0][scan.left] = scan.t[0][0];
+			line.t[0][scan.right] = scan.t[0][1];
+#endif
+
+#ifdef IPOL_T1
+			line.t[1][scan.left] = scan.t[1][0];
+			line.t[1][scan.right] = scan.t[1][1];
+#endif
+
+#ifdef IPOL_T2
+			line.t[2][scan.left] = scan.t[2][0];
+			line.t[2][scan.right] = scan.t[2][1];
+#endif
+
+#ifdef IPOL_L0
+			line.l[0][scan.left] = scan.l[0][0];
+			line.l[0][scan.right] = scan.l[0][1];
+#endif
+
+			// render a scanline
+			scanline_bilinear ();
+
+			scan.x[0] += scan.slopeX[0];
+			scan.x[1] += scan.slopeX[1];
+
+#ifdef IPOL_Z
+			scan.z[0] += scan.slopeZ[0];
+			scan.z[1] += scan.slopeZ[1];
+#endif
+
+#ifdef IPOL_W
+			scan.w[0] += scan.slopeW[0];
+			scan.w[1] += scan.slopeW[1];
+#endif
+
+#ifdef IPOL_C0
+			scan.c[0][0] += scan.slopeC[0][0];
+			scan.c[0][1] += scan.slopeC[0][1];
+#endif
+
+#ifdef IPOL_T0
+			scan.t[0][0] += scan.slopeT[0][0];
+			scan.t[0][1] += scan.slopeT[0][1];
+#endif
+
+#ifdef IPOL_T1
+			scan.t[1][0] += scan.slopeT[1][0];
+			scan.t[1][1] += scan.slopeT[1][1];
+#endif
+
+#ifdef IPOL_T2
+			scan.t[2][0] += scan.slopeT[2][0];
+			scan.t[2][1] += scan.slopeT[2][1];
+#endif
+
+#ifdef IPOL_L0
+			scan.l[0][0] += scan.slopeL[0][0];
+			scan.l[0][1] += scan.slopeL[0][1];
+#endif
+
+		}
+	}
+
+	// rasterize lower sub-triangle
+	//if ( (f32) 0.0 != scan.invDeltaY[2] )
+	if ( F32_GREATER_0 ( scan.invDeltaY[2] )  )
+	{
+		// advance to middle point
+		//if( (f32) 0.0 != scan.invDeltaY[1] )
+		if ( F32_GREATER_0 ( scan.invDeltaY[1] )  )
+		{
+			temp[0] = b->Pos.y - a->Pos.y;	// dy
+
+			scan.x[0] = a->Pos.x + scan.slopeX[0] * temp[0];
+#ifdef IPOL_Z
+			scan.z[0] = a->Pos.z + scan.slopeZ[0] * temp[0];
+#endif
+#ifdef IPOL_W
+			scan.w[0] = a->Pos.w + scan.slopeW[0] * temp[0];
+#endif
+#ifdef IPOL_C0
+			scan.c[0][0] = a->Color[0] + scan.slopeC[0][0] * temp[0];
+#endif
+#ifdef IPOL_T0
+			scan.t[0][0] = a->Tex[0] + scan.slopeT[0][0] * temp[0];
+#endif
+#ifdef IPOL_T1
+			scan.t[1][0] = a->Tex[1] + scan.slopeT[1][0] * temp[0];
+#endif
+#ifdef IPOL_T2
+			scan.t[2][0] = a->Tex[2] + scan.slopeT[2][0] * temp[0];
+#endif
+#ifdef IPOL_L0
+			scan.l[0][0] = a->LightTangent[0] + scan.slopeL[0][0] * temp[0];
+#endif
+
+		}
+
+		// calculate slopes for bottom edge
+		scan.slopeX[1] = (c->Pos.x - b->Pos.x) * scan.invDeltaY[2];
+		scan.x[1] = b->Pos.x;
+
+#ifdef IPOL_Z
+		scan.slopeZ[1] = (c->Pos.z - b->Pos.z) * scan.invDeltaY[2];
+		scan.z[1] = b->Pos.z;
+#endif
+
+#ifdef IPOL_W
+		scan.slopeW[1] = (c->Pos.w - b->Pos.w) * scan.invDeltaY[2];
+		scan.w[1] = b->Pos.w;
+#endif
+
+#ifdef IPOL_C0
+		scan.slopeC[0][1] = (c->Color[0] - b->Color[0]) * scan.invDeltaY[2];
+		scan.c[0][1] = b->Color[0];
+#endif
+
+#ifdef IPOL_T0
+		scan.slopeT[0][1] = (c->Tex[0] - b->Tex[0]) * scan.invDeltaY[2];
+		scan.t[0][1] = b->Tex[0];
+#endif
+
+#ifdef IPOL_T1
+		scan.slopeT[1][1] = (c->Tex[1] - b->Tex[1]) * scan.invDeltaY[2];
+		scan.t[1][1] = b->Tex[1];
+#endif
+
+#ifdef IPOL_T2
+		scan.slopeT[2][1] = (c->Tex[2] - b->Tex[2]) * scan.invDeltaY[2];
+		scan.t[2][1] = b->Tex[2];
+#endif
+
+#ifdef IPOL_L0
+		scan.slopeL[0][1] = (c->LightTangent[0] - b->LightTangent[0]) * scan.invDeltaY[2];
+		scan.l[0][1] = b->LightTangent[0];
+#endif
+
+		// apply top-left fill convention, top part
+		yStart = core::ceil32( b->Pos.y );
+		yEnd = core::ceil32( c->Pos.y ) - 1;
+
+#ifdef SUBTEXEL
+
+		subPixel = ( (f32) yStart ) - b->Pos.y;
+
+		// correct to pixel center
+		scan.x[0] += scan.slopeX[0] * subPixel;
+		scan.x[1] += scan.slopeX[1] * subPixel;		
+
+#ifdef IPOL_Z
+		scan.z[0] += scan.slopeZ[0] * subPixel;
+		scan.z[1] += scan.slopeZ[1] * subPixel;		
+#endif
+
+#ifdef IPOL_W
+		scan.w[0] += scan.slopeW[0] * subPixel;
+		scan.w[1] += scan.slopeW[1] * subPixel;		
+#endif
+
+#ifdef IPOL_C0
+		scan.c[0][0] += scan.slopeC[0][0] * subPixel;
+		scan.c[0][1] += scan.slopeC[0][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T0
+		scan.t[0][0] += scan.slopeT[0][0] * subPixel;
+		scan.t[0][1] += scan.slopeT[0][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T1
+		scan.t[1][0] += scan.slopeT[1][0] * subPixel;
+		scan.t[1][1] += scan.slopeT[1][1] * subPixel;		
+#endif
+
+#ifdef IPOL_T2
+		scan.t[2][0] += scan.slopeT[2][0] * subPixel;
+		scan.t[2][1] += scan.slopeT[2][1] * subPixel;		
+#endif
+
+#ifdef IPOL_L0
+		scan.l[0][0] += scan.slopeL[0][0] * subPixel;
+		scan.l[0][1] += scan.slopeL[0][1] * subPixel;		
+#endif
+
+#endif
+
+		// rasterize the edge scanlines
+		for( line.y = yStart; line.y <= yEnd; ++line.y)
+		{
+			line.x[scan.left] = scan.x[0];
+			line.x[scan.right] = scan.x[1];
+
+#ifdef IPOL_Z
+			line.z[scan.left] = scan.z[0];
+			line.z[scan.right] = scan.z[1];
+#endif
+
+#ifdef IPOL_W
+			line.w[scan.left] = scan.w[0];
+			line.w[scan.right] = scan.w[1];
+#endif
+
+#ifdef IPOL_C0
+			line.c[0][scan.left] = scan.c[0][0];
+			line.c[0][scan.right] = scan.c[0][1];
+#endif
+
+#ifdef IPOL_T0
+			line.t[0][scan.left] = scan.t[0][0];
+			line.t[0][scan.right] = scan.t[0][1];
+#endif
+
+#ifdef IPOL_T1
+			line.t[1][scan.left] = scan.t[1][0];
+			line.t[1][scan.right] = scan.t[1][1];
+#endif
+
+#ifdef IPOL_T2
+			line.t[2][scan.left] = scan.t[2][0];
+			line.t[2][scan.right] = scan.t[2][1];
+#endif
+
+#ifdef IPOL_L0
+			line.l[0][scan.left] = scan.l[0][0];
+			line.l[0][scan.right] = scan.l[0][1];
+#endif
+
+			// render a scanline
+			scanline_bilinear ();
+
+			scan.x[0] += scan.slopeX[0];
+			scan.x[1] += scan.slopeX[1];
+
+#ifdef IPOL_Z
+			scan.z[0] += scan.slopeZ[0];
+			scan.z[1] += scan.slopeZ[1];
+#endif
+
+#ifdef IPOL_W
+			scan.w[0] += scan.slopeW[0];
+			scan.w[1] += scan.slopeW[1];
+#endif
+
+#ifdef IPOL_C0
+			scan.c[0][0] += scan.slopeC[0][0];
+			scan.c[0][1] += scan.slopeC[0][1];
+#endif
+
+#ifdef IPOL_T0
+			scan.t[0][0] += scan.slopeT[0][0];
+			scan.t[0][1] += scan.slopeT[0][1];
+#endif
+
+#ifdef IPOL_T1
+			scan.t[1][0] += scan.slopeT[1][0];
+			scan.t[1][1] += scan.slopeT[1][1];
+#endif
+#ifdef IPOL_T2
+			scan.t[2][0] += scan.slopeT[2][0];
+			scan.t[2][1] += scan.slopeT[2][1];
+#endif
+
+#ifdef IPOL_L0
+			scan.l[0][0] += scan.slopeL[0][0];
+			scan.l[0][1] += scan.slopeL[0][1];
+#endif
+
+		}
+	}
+
+}
+
+
+} // end namespace video
+} // end namespace irr
+
+#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_
+
+namespace irr
+{
+namespace video
+{
+
+
+//! creates a triangle renderer
+IBurningShader* createTRNormalMap(CBurningVideoDriver* driver)
+{
+	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
+	return new CTRNormalMap(driver);
+	#else
+	return 0;
+	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_
+}
+
+
+} // end namespace video
+} // end namespace irr
+
+
+

source/Irrlicht/CTRTextureBlend.cpp

@@ -81,7 +81,7 @@ class CTRTextureBlend : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureBlend(IDepthBuffer* zbuffer);
+	CTRTextureBlend(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -111,8 +111,8 @@ private:
 };
 
 //! constructor
-CTRTextureBlend::CTRTextureBlend(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureBlend::CTRTextureBlend(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureBlend");
@@ -334,7 +334,7 @@ void CTRTextureBlend::fragment_dst_color_src_alpha ()
 		iw = fix_inverse32 ( line.w[0] );
 #endif
 
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&)r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0,r0,g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x,iw),
 							tofix ( line.t[0][0].y,iw)
@@ -377,7 +377,7 @@ void CTRTextureBlend::fragment_dst_color_src_alpha ()
 		iw = fix_inverse32 ( line.w[0] );
 #endif
 
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&)r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0,r0,g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x,iw),
 							tofix ( line.t[0][0].y,iw)
@@ -494,7 +494,7 @@ void CTRTextureBlend::fragment_src_color_src_alpha ()
 
 	f32 iw = 	FIX_POINT_F32_MUL;
 
-	tFixPointu a0, r0, g0, b0;
+	tFixPoint a0, r0, g0, b0;
 	tFixPoint     r1, g1, b1;
 
 	s32 i;
@@ -557,7 +557,7 @@ void CTRTextureBlend::fragment_src_color_src_alpha ()
 		iw = fix_inverse32 ( line.w[0] );
 #endif
 
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&)r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0,r0,g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x,iw),
 							tofix ( line.t[0][0].y,iw)
@@ -674,7 +674,7 @@ void CTRTextureBlend::fragment_one_one_minus_src_alpha()
 
 	f32 iw = FIX_POINT_F32_MUL;
 
-	tFixPointu a0,r0, g0, b0;
+	tFixPoint a0,r0, g0, b0;
 	tFixPoint	 r1, g1, b1;
 	tFixPoint	 r2, g2, b2;
 
@@ -1067,7 +1067,7 @@ void CTRTextureBlend::fragment_src_alpha_one ()
 
 	f32 iw = FIX_POINT_F32_MUL;
 
-	tFixPointu a0, r0, g0, b0;
+	tFixPoint a0, r0, g0, b0;
 	tFixPoint r1, g1, b1;
 	tFixPoint r2, g2, b2;
 
@@ -2369,10 +2369,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureBlend(IDepthBuffer* zbuffer)
+IBurningShader* createTRTextureBlend(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureBlend(zbuffer);
+	return new CTRTextureBlend(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureDetailMap2.cpp

@@ -81,7 +81,7 @@ class CTRTextureDetailMap2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureDetailMap2(IDepthBuffer* zbuffer);
+	CTRTextureDetailMap2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -95,8 +95,8 @@ private:
 };
 
 //! constructor
-CTRTextureDetailMap2::CTRTextureDetailMap2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureDetailMap2::CTRTextureDetailMap2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureDetailMap2");
@@ -230,8 +230,6 @@ void CTRTextureDetailMap2::scanline_bilinear ()
 			getSample_texture ( r0, g0, b0, &IT[0], tx0,ty0 );
 			getSample_texture ( r1, g1, b1, &IT[1], tx1,ty1 );
 
-#define FIX_POINT_HALF_COLOR ( (tFixPoint) ( ((f32) COLOR_MAX / 2.f * FIX_POINT_F32_MUL ) ) )
-
 			// bias half color
 			r1 += -FIX_POINT_HALF_COLOR;
 			g1 += -FIX_POINT_HALF_COLOR;
@@ -645,10 +643,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureDetailMap2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureDetailMap2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureDetailMap2(zbuffer);
+	return new CTRTextureDetailMap2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraud2.cpp

@@ -80,7 +80,7 @@ class CTRTextureGouraud2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraud2(IDepthBuffer* zbuffer);
+	CTRTextureGouraud2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraud2::CTRTextureGouraud2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureGouraud2::CTRTextureGouraud2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraud2");
@@ -657,10 +657,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureGouraud2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureGouraud2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraud2(zbuffer);
+	return new CTRTextureGouraud2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudAdd2.cpp

@@ -81,7 +81,7 @@ class CTRTextureGouraudAdd2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraudAdd2(IDepthBuffer* zbuffer);
+	CTRTextureGouraudAdd2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraudAdd2::CTRTextureGouraudAdd2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureGouraudAdd2::CTRTextureGouraudAdd2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraudAdd2");
@@ -663,10 +663,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureGouraudAdd2(IDepthBuffer* zbuffer)
+IBurningShader* createTRTextureGouraudAdd2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraudAdd2(zbuffer);
+	return new CTRTextureGouraudAdd2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudAddNoZ2.cpp

@@ -80,7 +80,7 @@ class CTRTextureGouraudAddNoZ2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraudAddNoZ2(IDepthBuffer* zbuffer);
+	CTRTextureGouraudAddNoZ2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraudAddNoZ2::CTRTextureGouraudAddNoZ2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureGouraudAddNoZ2::CTRTextureGouraudAddNoZ2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraudAddNoZ2");
@@ -199,8 +199,6 @@ void CTRTextureGouraudAddNoZ2::scanline_bilinear ()
 
 	tFixPoint r0, g0, b0;
 	tFixPoint r1, g1, b1;
-	tFixPoint r2, g2, b2;
-
 
 	for ( s32 i = 0; i <= dx; ++i )
 	{
@@ -225,12 +223,10 @@ void CTRTextureGouraudAddNoZ2::scanline_bilinear ()
 
 			color_to_fix ( r1, g1, b1, dst[i] );
 
-			r2 = clampfix_maxcolor ( r1 + r0 );
-			g2 = clampfix_maxcolor ( g1 + g0 );
-			b2 = clampfix_maxcolor ( b1 + b0 );
-
-
-			dst[i] = fix_to_color ( r2, g2, b2 );
+			dst[i] = fix_to_color ( clampfix_maxcolor ( r1 + (r0 >> 1 ) ),
+									clampfix_maxcolor ( g1 + (g0 >> 1 ) ),
+									clampfix_maxcolor ( b1 + (b0 >> 1) )
+								);
 
 #ifdef WRITE_Z
 			z[i] = line.z[0];
@@ -633,10 +629,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureGouraudAddNoZ2(IDepthBuffer* zbuffer)
+IBurningShader* createTRTextureGouraudAddNoZ2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraudAddNoZ2(zbuffer);
+	return new CTRTextureGouraudAddNoZ2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudAlpha.cpp

@@ -81,7 +81,7 @@ class CTRTextureGouraudAlpha2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraudAlpha2(IDepthBuffer* zbuffer);
+	CTRTextureGouraudAlpha2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -99,8 +99,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraudAlpha2::CTRTextureGouraudAlpha2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureGouraudAlpha2::CTRTextureGouraudAlpha2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraudAlpha2");
@@ -273,13 +273,13 @@ void CTRTextureGouraudAlpha2::scanline_bilinear ()
 
 #ifdef INVERSE_W
 		inversew = fix_inverse32 ( line.w[0] );
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&) r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0,r0,g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x,inversew),
 							tofix ( line.t[0][0].y,inversew)
 						);
 #else
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&) r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0,r0,g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x),
 							tofix ( line.t[0][0].y)
@@ -728,10 +728,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureGouraudAlpha(IDepthBuffer* zbuffer)
+IBurningShader* createTRTextureGouraudAlpha(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraudAlpha2(zbuffer);
+	return new CTRTextureGouraudAlpha2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudAlphaNoZ.cpp

@@ -81,7 +81,7 @@ class CTRTextureGouraudAlphaNoZ : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraudAlphaNoZ(IDepthBuffer* zbuffer);
+	CTRTextureGouraudAlphaNoZ(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -99,8 +99,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraudAlphaNoZ::CTRTextureGouraudAlphaNoZ(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureGouraudAlphaNoZ::CTRTextureGouraudAlphaNoZ(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraudAlphaNoZ");
@@ -273,13 +273,13 @@ void CTRTextureGouraudAlphaNoZ::scanline_bilinear ()
 
 #ifdef INVERSE_W
 		inversew = fix_inverse32 ( line.w[0] );
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&) r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0, r0, g0, b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x,inversew),
 							tofix ( line.t[0][0].y,inversew)
 						);
 #else
-		getSample_texture ( (tFixPointu&) a0, (tFixPointu&) r0, (tFixPointu&)g0, (tFixPointu&)b0, 
+		getSample_texture ( a0, r0, g0,b0, 
 							&IT[0],
 							tofix ( line.t[0][0].x),
 							tofix ( line.t[0][0].y)
@@ -729,10 +729,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureGouraudAlphaNoZ(IDepthBuffer* zbuffer)
+IBurningShader* createTRTextureGouraudAlphaNoZ(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraudAlphaNoZ(zbuffer);
+	return new CTRTextureGouraudAlphaNoZ(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudNoZ2.cpp

@@ -85,7 +85,7 @@ class CTRTextureGouraudNoZ2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureGouraudNoZ2(IDepthBuffer* zbuffer);
+	CTRTextureGouraudNoZ2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -99,8 +99,8 @@ private:
 };
 
 //! constructor
-CTRTextureGouraudNoZ2::CTRTextureGouraudNoZ2(IDepthBuffer* zbuffer)
-: IBurningShader(0)
+CTRTextureGouraudNoZ2::CTRTextureGouraudNoZ2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureGouraudNoZ2");
@@ -630,10 +630,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTRTextureGouraudNoZ2()
+IBurningShader* createTRTextureGouraudNoZ2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureGouraudNoZ2( 0 );
+	return new CTRTextureGouraudNoZ2( driver );
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureGouraudVertexAlpha2.cpp

@@ -79,7 +79,7 @@ class CTRTextureVertexAlpha2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureVertexAlpha2(IDepthBuffer* zbuffer);
+	CTRTextureVertexAlpha2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -93,8 +93,8 @@ private:
 };
 
 //! constructor
-CTRTextureVertexAlpha2::CTRTextureVertexAlpha2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureVertexAlpha2::CTRTextureVertexAlpha2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureVertexAlpha2");
@@ -673,10 +673,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureVertexAlpha2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureVertexAlpha2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureVertexAlpha2(zbuffer);
+	return new CTRTextureVertexAlpha2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureLightMap2_Add.cpp

@@ -79,7 +79,7 @@ class CTRTextureLightMap2_Add : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureLightMap2_Add(IDepthBuffer* zbuffer);
+	CTRTextureLightMap2_Add(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRTextureLightMap2_Add::CTRTextureLightMap2_Add(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureLightMap2_Add::CTRTextureLightMap2_Add(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureLightMap2_Add");
@@ -655,10 +655,10 @@ namespace video
 {
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureLightMap2_Add(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureLightMap2_Add(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureLightMap2_Add(zbuffer);
+	return new CTRTextureLightMap2_Add(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureLightMap2_M1.cpp

@@ -79,7 +79,7 @@ class CTRTextureLightMap2_M1 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureLightMap2_M1(IDepthBuffer* zbuffer);
+	CTRTextureLightMap2_M1(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -93,8 +93,8 @@ private:
 };
 
 //! constructor
-CTRTextureLightMap2_M1::CTRTextureLightMap2_M1(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureLightMap2_M1::CTRTextureLightMap2_M1(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureLightMap2_M1");
@@ -627,10 +627,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureLightMap2_M1(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureLightMap2_M1(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureLightMap2_M1(zbuffer);
+	return new CTRTextureLightMap2_M1(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureLightMap2_M2.cpp

@@ -79,7 +79,7 @@ class CTRTextureLightMap2_M2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureLightMap2_M2(IDepthBuffer* zbuffer);
+	CTRTextureLightMap2_M2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -93,8 +93,8 @@ private:
 };
 
 //! constructor
-CTRTextureLightMap2_M2::CTRTextureLightMap2_M2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureLightMap2_M2::CTRTextureLightMap2_M2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureLightMap2_M2");
@@ -627,10 +627,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureLightMap2_M2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureLightMap2_M2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureLightMap2_M2(zbuffer);
+	return new CTRTextureLightMap2_M2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureLightMap2_M4.cpp

@@ -79,7 +79,7 @@ class CTRTextureLightMap2_M4 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureLightMap2_M4(IDepthBuffer* zbuffer);
+	CTRTextureLightMap2_M4(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -99,8 +99,8 @@ private:
 };
 
 //! constructor
-CTRTextureLightMap2_M4::CTRTextureLightMap2_M4(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureLightMap2_M4::CTRTextureLightMap2_M4(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureLightMap2_M4");
@@ -1327,10 +1327,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureLightMap2_M4(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureLightMap2_M4(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureLightMap2_M4(zbuffer);
+	return new CTRTextureLightMap2_M4(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureLightMapGouraud2_M4.cpp

@@ -79,7 +79,7 @@ class CTRGTextureLightMap2_M4 : public IBurningShader
 public:
 
 	//! constructor
-	CTRGTextureLightMap2_M4(IDepthBuffer* zbuffer);
+	CTRGTextureLightMap2_M4(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -94,8 +94,8 @@ private:
 };
 
 //! constructor
-CTRGTextureLightMap2_M4::CTRGTextureLightMap2_M4(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRGTextureLightMap2_M4::CTRGTextureLightMap2_M4(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRGTextureLightMap2_M4");
@@ -673,10 +673,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererGTextureLightMap2_M4(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererGTextureLightMap2_M4(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRGTextureLightMap2_M4(zbuffer);
+	return new CTRGTextureLightMap2_M4(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/CTRTextureWire2.cpp

@@ -77,7 +77,7 @@ class CTRTextureWire2 : public IBurningShader
 public:
 
 	//! constructor
-	CTRTextureWire2(IDepthBuffer* zbuffer);
+	CTRTextureWire2(CBurningVideoDriver* driver);
 
 	//! draws an indexed triangle list
 	virtual void drawTriangle ( const s4DVertex *a,const s4DVertex *b,const s4DVertex *c );
@@ -92,8 +92,8 @@ private:
 };
 
 //! constructor
-CTRTextureWire2::CTRTextureWire2(IDepthBuffer* zbuffer)
-: IBurningShader(zbuffer)
+CTRTextureWire2::CTRTextureWire2(CBurningVideoDriver* driver)
+: IBurningShader(driver)
 {
 	#ifdef _DEBUG
 	setDebugName("CTRTextureWire2");
@@ -282,10 +282,10 @@ namespace video
 
 
 //! creates a flat triangle renderer
-IBurningShader* createTriangleRendererTextureGouraudWire2(IDepthBuffer* zbuffer)
+IBurningShader* createTriangleRendererTextureGouraudWire2(CBurningVideoDriver* driver)
 {
 	#ifdef _IRR_COMPILE_WITH_BURNINGSVIDEO_
-	return new CTRTextureWire2(zbuffer);
+	return new CTRTextureWire2(driver);
 	#else
 	return 0;
 	#endif // _IRR_COMPILE_WITH_BURNINGSVIDEO_

source/Irrlicht/IBurningShader.cpp

@@ -7,6 +7,7 @@
 
 #include "SoftwareDriver2_compile_config.h"
 #include "IBurningShader.h"
+#include "CSoftwareDriver2.h"
 
 namespace irr
 {
@@ -21,8 +22,7 @@ namespace video
 		0xf0,0x70,0xd0,0x50
 	};
 
-	IBurningShader::IBurningShader(IDepthBuffer* zbuffer)
-		: RenderTarget(0),DepthBuffer(zbuffer)
+	IBurningShader::IBurningShader(CBurningVideoDriver* driver)
 	{
 		#ifdef _DEBUG
 		setDebugName("IBurningShader");
@@ -33,6 +33,10 @@ namespace video
 			IT[i].Texture = 0;
 		}
 
+		Driver = driver;
+		RenderTarget = 0;
+		ColorMask = COLOR_BRIGHT_WHITE;
+		DepthBuffer = (CDepthBuffer*) driver->getDepthBuffer ();
 		if ( DepthBuffer )
 			DepthBuffer->grab();
 	}

source/Irrlicht/IBurningShader.h

@@ -11,7 +11,7 @@
 #include "IImage.h"
 #include "S2DVertex.h"
 #include "rect.h"
-#include "IDepthBuffer.h"
+#include "CDepthBuffer.h"
 #include "S4DVertex.h"
 #include "irrArray.h"
 #include "SLight.h"
@@ -40,6 +40,7 @@ namespace video
 		sVec3 AmbientColor;
 		sVec3 DiffuseColor;
 		sVec3 SpecularColor;
+		sVec4 pos_objectspace;
 	};
 
 	enum eLightFlags
@@ -110,6 +111,8 @@ namespace video
 		ETR_TEXTURE_GOURAUD_ALPHA,
 		ETR_TEXTURE_GOURAUD_ALPHA_NOZ,
 
+		ETR_NORMAL_MAP_SOLID,
+
 		ETR_TEXTURE_BLEND,
 		ETR_REFERENCE,
 		ETR_INVALID,
@@ -118,10 +121,11 @@ namespace video
 	};
 
 
+	class CBurningVideoDriver;
 	class IBurningShader : public virtual IReferenceCounted
 	{
 	public:
-		IBurningShader(IDepthBuffer* zbuffer);
+		IBurningShader(CBurningVideoDriver* driver);
 
 		//! destructor
 		virtual ~IBurningShader();
@@ -141,8 +145,12 @@ namespace video
 
 	protected:
 
+		CBurningVideoDriver *Driver;
+
 		video::CImage* RenderTarget;
-		IDepthBuffer* DepthBuffer;
+		CDepthBuffer* DepthBuffer;
+		CStencilBuffer * Stencil;
+		tVideoSample ColorMask;
 
 		sInternalTexture IT[ BURNING_MATERIAL_MAX_TEXTURES ];
 
@@ -150,35 +158,37 @@ namespace video
 	};
 
 
-	IBurningShader* createTriangleRendererTextureGouraud2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureLightMap2_M1(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureLightMap2_M2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureLightMap2_M4(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererGTextureLightMap2_M4(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureLightMap2_Add(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureDetailMap2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureVertexAlpha2(IDepthBuffer* zbuffer);
+	IBurningShader* createTriangleRendererTextureGouraud2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureLightMap2_M1(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureLightMap2_M2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureLightMap2_M4(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererGTextureLightMap2_M4(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureLightMap2_Add(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureDetailMap2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureVertexAlpha2(CBurningVideoDriver* driver);
 
 
-	IBurningShader* createTriangleRendererTextureGouraudWire2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererGouraud2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererGouraudAlpha2(IDepthBuffer* zbuffer);
-	IBurningShader* createTRGouraudAlphaNoZ2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererGouraudWire2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureFlat2(IDepthBuffer* zbuffer);
-	IBurningShader* createTriangleRendererTextureFlatWire2(IDepthBuffer* zbuffer);
-	IBurningShader* createTRFlat2(IDepthBuffer* zbuffer);
-	IBurningShader* createTRFlatWire2(IDepthBuffer* zbuffer);
-	IBurningShader* createTRTextureGouraudNoZ2();
-	IBurningShader* createTRTextureGouraudAdd2(IDepthBuffer* zbuffer);
-	IBurningShader* createTRTextureGouraudAddNoZ2(IDepthBuffer* zbuffer);
+	IBurningShader* createTriangleRendererTextureGouraudWire2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererGouraud2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererGouraudAlpha2(CBurningVideoDriver* driver);
+	IBurningShader* createTRGouraudAlphaNoZ2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererGouraudWire2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureFlat2(CBurningVideoDriver* driver);
+	IBurningShader* createTriangleRendererTextureFlatWire2(CBurningVideoDriver* driver);
+	IBurningShader* createTRFlat2(CBurningVideoDriver* driver);
+	IBurningShader* createTRFlatWire2(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureGouraudNoZ2(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureGouraudAdd2(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureGouraudAddNoZ2(CBurningVideoDriver* driver);
 
-	IBurningShader* createTRTextureGouraudAlpha(IDepthBuffer* zbuffer);
-	IBurningShader* createTRTextureGouraudAlphaNoZ(IDepthBuffer* zbuffer);
-	IBurningShader* createTRTextureBlend(IDepthBuffer* zbuffer);
-	IBurningShader* createTRTextureInverseAlphaBlend(IDepthBuffer* zbuffer);
+	IBurningShader* createTRTextureGouraudAlpha(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureGouraudAlphaNoZ(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureBlend(CBurningVideoDriver* driver);
+	IBurningShader* createTRTextureInverseAlphaBlend(CBurningVideoDriver* driver);
 
-	IBurningShader* createTriangleRendererReference(IDepthBuffer* zbuffer);
+	IBurningShader* createTRNormalMap(CBurningVideoDriver* driver);
+
+	IBurningShader* createTriangleRendererReference(CBurningVideoDriver* driver);
 
 
 

source/Irrlicht/IDepthBuffer.h

@@ -44,6 +44,37 @@ namespace video
 	//! creates a ZBuffer
 	IDepthBuffer* createDepthBuffer(const core::dimension2d<u32>& size);
 
+	class IStencilBuffer : public virtual IReferenceCounted
+	{
+	public:
+
+		//! destructor
+		virtual ~IStencilBuffer() {};
+
+		//! clears the zbuffer
+		virtual void clear() = 0;
+
+		//! sets the new size of the zbuffer
+		virtual void setSize(const core::dimension2d<u32>& size) = 0;
+
+		//! returns the size of the zbuffer
+		virtual const core::dimension2d<u32>& getSize() const = 0;
+
+		//! locks the zbuffer
+		virtual void* lock() = 0;
+
+		//! unlocks the zbuffer
+		virtual void unlock() = 0;
+
+		//! returns pitch of depthbuffer (in bytes)
+		virtual u32 getPitch() const = 0;
+
+	};
+
+
+	//! creates a Stencil Buffer
+	IStencilBuffer* createStencilBuffer(const core::dimension2d<u32>& size);
+
 } // end namespace video
 } // end namespace irr
 

source/Irrlicht/Irrlicht9.0.vcproj

@@ -255,8 +255,9 @@
 				StringPooling="true"
 				ExceptionHandling="0"
 				RuntimeLibrary="0"
+				StructMemberAlignment="0"
 				BufferSecurityCheck="false"
-				EnableFunctionLevelLinking="true"
+				EnableFunctionLevelLinking="false"
 				EnableEnhancedInstructionSet="2"
 				FloatingPointModel="2"
 				RuntimeTypeInfo="false"
@@ -268,7 +269,6 @@
 				WarnAsError="false"
 				SuppressStartupBanner="true"
 				DebugInformationFormat="0"
-				CallingConvention="1"
 				CompileAs="0"
 			/>
 			<Tool
@@ -2511,6 +2511,10 @@
 						RelativePath="CTRGouraudAlphaNoZ2.cpp"
 						>
 					</File>
+					<File
+						RelativePath=".\CTRNormalMap.cpp"
+						>
+					</File>
 					<File
 						RelativePath="CTRTextureBlend.cpp"
 						>

source/Irrlicht/S4DVertex.h

@@ -23,6 +23,7 @@ struct sVec2
 
 	sVec2 () {}
 
+	sVec2 ( f32 s) : x ( s ), y ( s ) {}
 	sVec2 ( f32 _x, f32 _y )
 		: x ( _x ), y ( _y ) {}
 
@@ -107,10 +108,19 @@ struct sCompressedVec4
 
 struct sVec4
 {
-	f32 x, y, z, w;
+	union
+	{
+		struct { f32 x, y, z, w; };
+		struct { f32 a, r, g, b; };
+		struct { sVec2 xy, zw; };
+	};
+
+	
 
 	sVec4 () {}
 
+	sVec4 ( f32 s) : x ( s ), y ( s ), z ( s ), w ( s ) {}
+
 	sVec4 ( f32 _x, f32 _y, f32 _z, f32 _w )
 		: x ( _x ), y ( _y ), z( _z ), w ( _w ){}
 
@@ -205,7 +215,7 @@ struct sVec4
 		w += other.w;
 	}
 
-	sVec4 operator*(f32 s) const
+	sVec4 operator*(const f32 s) const
 	{
 		return sVec4(x * s , y * s, z * s,w * s);
 	}
@@ -223,6 +233,15 @@ struct sVec4
 		z = (f32) ( z * i );
 		w = (f32) ( w * i );
 	}
+
+	void mul ( const f32 s )
+	{
+		x *= s;
+		y *= s;
+		z *= s;
+		w *= s;
+	}
+
 /*
 	void operator*=(f32 s)
 	{
@@ -251,7 +270,19 @@ struct sVec4
 
 struct sVec3
 {
-	f32 r, g, b;
+	union
+	{
+		struct { f32 r, g, b; };
+		struct { f32 x, y, z; };
+	};
+
+
+	sVec3 () {}
+	sVec3 ( f32 _x, f32 _y, f32 _z )
+		: r ( _x ), g ( _y ), b( _z ) {}
+
+	sVec3 ( const sVec4 &v )
+		: r ( v.x ), g ( v.y ), b( v.z ) {}
 
 	void set ( f32 _r, f32 _g, f32 _b )
 	{
@@ -303,6 +334,56 @@ struct sVec3
 		dest.w = core::min_ ( b, 1.f );
 	}
 
+	// f = a * t + b * ( 1 - t )
+	void interpolate(const sVec3& v0, const sVec3& v1, const f32 t)
+	{
+		r = v1.r + ( ( v0.r - v1.r ) * t );
+		g = v1.g + ( ( v0.g - v1.g ) * t );
+		b = v1.b + ( ( v0.b - v1.b ) * t );
+	}
+
+	sVec3 operator-(const sVec3& other) const
+	{
+		return sVec3(r - other.r, b - other.b, g - other.g);
+	}
+
+	sVec3 operator+(const sVec3& other) const
+	{
+		return sVec3(r + other.r, g + other.g, b + other.b);
+	}
+
+	sVec3 operator*(const f32 s) const
+	{
+		return sVec3(r * s , g * s, b * s);
+	}
+
+	sVec3 operator/(const f32 s) const
+	{
+		f32 inv = 1.f / s;
+		return sVec3(r * inv , g * inv, b * inv);
+	}
+
+	sVec3 operator*(const sVec3 &other) const
+	{
+		return sVec3(r * other.r , b * other.b, g * other.g);
+	}
+
+	void operator+=(const sVec3& other)
+	{
+		r += other.r;
+		g += other.g;
+		b += other.b;
+	}
+
+	void setLength ( f32 len )
+	{
+		const f32 l = len * core::reciprocal_squareroot ( r * r + g * g + b * b );
+
+		r *= l;
+		g *= l;
+		b *= l;
+	}
+
 };
 
 
@@ -332,24 +413,30 @@ enum e4DVertexFlag
 
 	VERTEX4D_FORMAT_MASK_COLOR		= 0x00F00000,
 	VERTEX4D_FORMAT_COLOR_1			= 0x00100000,
-	VERTEX4D_FORMAT_COLOR_2			= 0x00200000
+	VERTEX4D_FORMAT_COLOR_2			= 0x00200000,
+
+	VERTEX4D_FORMAT_MASK_BUMP		= 0x0F000000,
+	VERTEX4D_FORMAT_BUMP_DOT3		= 0x01000000,
 
 };
 
 const u32 MATERIAL_MAX_COLORS = 1;
 const u32 BURNING_MATERIAL_MAX_TEXTURES = 2;
+const u32 BURNING_MATERIAL_MAX_TANGENT = 1;
 
 // dummy Vertex. used for calculation vertex memory size
 struct s4DVertex_proxy
 {
+	u32 flag;
 	sVec4 Pos;
+	sVec2 Tex[BURNING_MATERIAL_MAX_TEXTURES];
 
 #ifdef SOFTWARE_DRIVER_2_USE_VERTEX_COLOR
 	sVec4 Color[MATERIAL_MAX_COLORS];
 #endif
 
-	sVec2 Tex[BURNING_MATERIAL_MAX_TEXTURES];
-	u32 flag;
+	sVec3 LightTangent[BURNING_MATERIAL_MAX_TANGENT];
+
 };
 
 #define SIZEOF_SVERTEX	64
@@ -360,17 +447,18 @@ struct s4DVertex_proxy
 */
 struct s4DVertex
 {
+	u32 flag;
+
 	sVec4 Pos;
+	sVec2 Tex[ BURNING_MATERIAL_MAX_TEXTURES ];
 
 #ifdef SOFTWARE_DRIVER_2_USE_VERTEX_COLOR
 	sVec4 Color[ MATERIAL_MAX_COLORS ];
 #endif
 
-	sVec2 Tex[ BURNING_MATERIAL_MAX_TEXTURES ];
+	sVec3 LightTangent[BURNING_MATERIAL_MAX_TANGENT];
 
-	u32 flag;
-
-	u8 fill [ SIZEOF_SVERTEX - sizeof (s4DVertex_proxy) ];
+	//u8 fill [ SIZEOF_SVERTEX - sizeof (s4DVertex_proxy) ];
 
 	// f = a * t + b * ( 1 - t )
 	void interpolate(const s4DVertex& b, const s4DVertex& a, const f32 t)
@@ -394,6 +482,12 @@ struct s4DVertex
 			Tex[i].interpolate ( a.Tex[i], b.Tex[i], t );
 		}
 
+		size = (flag & VERTEX4D_FORMAT_MASK_BUMP) >> 24;
+		for ( i = 0; i!= size; ++i )
+		{
+			LightTangent[i].interpolate ( a.LightTangent[i], b.LightTangent[i], t );
+		}
+
 	}
 };
 
@@ -507,6 +601,8 @@ struct sScanConvertData
 	sVec2 t[BURNING_MATERIAL_MAX_TEXTURES][2];		// texture
 	sVec2 slopeT[BURNING_MATERIAL_MAX_TEXTURES][2];	// texture slope along edges
 
+	sVec3 l[BURNING_MATERIAL_MAX_TANGENT][2];		// Light Tangent
+	sVec3 slopeL[BURNING_MATERIAL_MAX_TEXTURES][2];	// tanget slope along edges
 };
 
 // passed to scan Line
@@ -526,6 +622,7 @@ struct sScanLineData
 #endif
 
 	sVec2 t[BURNING_MATERIAL_MAX_TEXTURES][2];		// texture start, texture end of scanline
+	sVec3 l[BURNING_MATERIAL_MAX_TANGENT][2];		// Light Tangent start, end
 };
 
 // passed to pixel Shader

source/Irrlicht/SoftwareDriver2_compile_config.h

@@ -78,7 +78,7 @@
 #if defined ( SOFTWARE_DRIVER_2_MIPMAPPING )
 	#if defined( BURNINGVIDEO_RENDERER_BEAUTIFUL )
 		#define SOFTWARE_DRIVER_2_MIPMAPPING_MAX		8
-		#define SOFTWARE_DRIVER_2_MIPMAPPING_LOD_BIAS	-1
+		#define SOFTWARE_DRIVER_2_MIPMAPPING_LOD_BIAS	0
 	#elif defined ( BURNINGVIDEO_RENDERER_CE )
 		#define SOFTWARE_DRIVER_2_MIPMAPPING_MAX		4
 		#define SOFTWARE_DRIVER_2_MIPMAPPING_LOD_BIAS	0

source/Irrlicht/SoftwareDriver2_helper.h

@@ -358,8 +358,30 @@ inline u32 PixelBlend32 ( const u32 c2, const u32 c1 )
 typedef s32 tFixPoint;
 typedef u32 tFixPointu;
 
-// Fix Point 9
+// Fix Point 12
+#if 0
+	#define FIX_POINT_PRE			12
+	#define FIX_POINT_FRACT_MASK	0xFFF
+	#define FIX_POINT_SIGNED_MASK	0xFFFFF000
+	#define FIX_POINT_UNSIGNED_MASK	0x7FFFF000
+	#define FIX_POINT_ONE			0x1000
+	#define FIX_POINT_ZERO_DOT_FIVE	0x0800
+	#define FIX_POINT_F32_MUL		4096.f
+#endif
+
+// Fix Point 10
 #if 1
+	#define FIX_POINT_PRE			10
+	#define FIX_POINT_FRACT_MASK	0x3FF
+	#define FIX_POINT_SIGNED_MASK	0xFFFFFC00
+	#define FIX_POINT_UNSIGNED_MASK	0x7FFFFE00
+	#define FIX_POINT_ONE			0x400
+	#define FIX_POINT_ZERO_DOT_FIVE	0x200
+	#define FIX_POINT_F32_MUL		1024.f
+#endif
+
+// Fix Point 9
+#if 0
 	#define FIX_POINT_PRE			9
 	#define FIX_POINT_FRACT_MASK	0x1FF
 	#define FIX_POINT_SIGNED_MASK	0xFFFFFE00
@@ -381,6 +403,7 @@ typedef u32 tFixPointu;
 #endif
 
 #define	FIXPOINT_COLOR_MAX		( COLOR_MAX << FIX_POINT_PRE )
+#define FIX_POINT_HALF_COLOR ( (tFixPoint) ( ((f32) COLOR_MAX / 2.f * FIX_POINT_F32_MUL ) ) )
 
 
 /*
@@ -496,11 +519,16 @@ REALINLINE tFixPoint clampfix_maxcolor ( const tFixPoint a)
 /*!
 	clamp FixPoint to 0 in FixPoint, max(a,0)
 */
-inline tFixPoint clampfix_mincolor ( const tFixPoint a)
+REALINLINE tFixPoint clampfix_mincolor ( const tFixPoint a)
 {
 	return a - ( a & ( a >> 31 ) );
 }
 
+REALINLINE tFixPoint saturateFix ( const tFixPoint a)
+{
+	return clampfix_mincolor ( clampfix_maxcolor ( a ) );
+}
+
 
 // rount fixpoint to int
 inline s32 roundFix ( const tFixPoint x )
@@ -685,6 +713,23 @@ inline void getTexel_fix ( tFixPoint &r, tFixPoint &g, tFixPoint &b,
 
 }
 
+// get video sample to fixpoint
+REALINLINE void getTexel_fix ( tFixPoint &a, 
+								const sInternalTexture * t, const tFixPointu tx, const tFixPointu ty
+								)
+{
+	u32 ofs;
+
+	ofs = ( ( ty & t->textureYMask ) >> FIX_POINT_PRE ) << t->pitchlog2;
+	ofs |= ( tx & t->textureXMask ) >> ( FIX_POINT_PRE - VIDEO_SAMPLE_GRANULARITY );
+
+	// texel
+	tVideoSample t00;
+	t00 = *((tVideoSample*)( (u8*) t->data + ofs ));
+
+	a	 =	(t00 & MASK_A) >> ( SHIFT_A - FIX_POINT_PRE);
+}
+
 
 inline void getSample_texture_dither (	tFixPoint &r, tFixPoint &g, tFixPoint &b,
 										const sInternalTexture * t, const tFixPointu tx, const tFixPointu ty,
@@ -762,6 +807,7 @@ inline void getSample_texture ( tFixPointu &a, tFixPointu &r, tFixPointu &g, tFi
 
 #else
 
+
 // get sample linear
 REALINLINE void getSample_linear ( tFixPointu &r, tFixPointu &g, tFixPointu &b,
 								const sInternalTexture * t, const tFixPointu tx, const tFixPointu ty
@@ -792,10 +838,33 @@ REALINLINE void getSample_texture ( tFixPoint &r, tFixPoint &g, tFixPoint &b,
 	tFixPointu r10,g10,b10;
 	tFixPointu r11,g11,b11;
 
+#if 0
 	getSample_linear ( r00, g00, b00, t, tx,ty );
 	getSample_linear ( r10, g10, b10, t, tx + FIX_POINT_ONE,ty );
 	getSample_linear ( r01, g01, b01, t, tx,ty + FIX_POINT_ONE );
 	getSample_linear ( r11, g11, b11, t, tx + FIX_POINT_ONE,ty + FIX_POINT_ONE );
+#else
+	u32 o0, o1,o2,o3;
+	tVideoSample t00;
+
+	o0 = ( ( (ty) & t->textureYMask ) >> FIX_POINT_PRE ) << t->pitchlog2;
+	o1 = ( ( (ty+FIX_POINT_ONE) & t->textureYMask ) >> FIX_POINT_PRE ) << t->pitchlog2;
+	o2 =   ( (tx) & t->textureXMask ) >> ( FIX_POINT_PRE - VIDEO_SAMPLE_GRANULARITY );
+	o3 =   ( (tx+FIX_POINT_ONE) & t->textureXMask ) >> ( FIX_POINT_PRE - VIDEO_SAMPLE_GRANULARITY );
+
+	t00 = *((tVideoSample*)( (u8*) t->data + (o0 | o2 ) ));
+	r00	 =	(t00 & MASK_R) >> SHIFT_R; g00  =	(t00 & MASK_G) >> SHIFT_G; b00	 =	(t00 & MASK_B);
+
+	t00 = *((tVideoSample*)( (u8*) t->data + (o0 | o3 ) ));
+	r10	 =	(t00 & MASK_R) >> SHIFT_R; g10  =	(t00 & MASK_G) >> SHIFT_G; b10	 =	(t00 & MASK_B);
+
+	t00 = *((tVideoSample*)( (u8*) t->data + (o1 | o2 ) ));
+	r01	 =	(t00 & MASK_R) >> SHIFT_R; g01  =	(t00 & MASK_G) >> SHIFT_G; b01	 =	(t00 & MASK_B);
+
+	t00 = *((tVideoSample*)( (u8*) t->data + (o1 | o3 ) ));
+	r11	 =	(t00 & MASK_R) >> SHIFT_R; g11  =	(t00 & MASK_G) >> SHIFT_G; b11	 =	(t00 & MASK_B);
+
+#endif
 
 	const tFixPointu txFract = tx & FIX_POINT_FRACT_MASK;
 	const tFixPointu txFractInv = FIX_POINT_ONE - txFract;
@@ -847,7 +916,7 @@ REALINLINE void getSample_linear ( tFixPointu &a, tFixPointu &r, tFixPointu &g,
 }
 
 // get Sample bilinear
-REALINLINE void getSample_texture ( tFixPointu &a, tFixPointu &r, tFixPointu &g, tFixPointu &b,
+REALINLINE void getSample_texture ( tFixPoint &a, tFixPoint &r, tFixPoint &g, tFixPoint &b,
 								const sInternalTexture * t, const tFixPointu tx, const tFixPointu ty
 								)
 {