Add implementations for polygon offset in hw drivers.

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

source/Irrlicht/CD3D8Driver.cpp

@@ -1562,6 +1562,14 @@ void CD3D8Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 		pID3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, flag);
 	}
 
+	// Polygon offset
+	if (queryFeature(EVDF_POLYGON_OFFSET) && (resetAllRenderstates ||
+		lastmaterial.PolygonOffsetDirection != material.PolygonOffsetDirection ||
+		lastmaterial.PolygonOffsetFactor != material.PolygonOffsetFactor))
+	{
+		pID3DDevice->SetRenderState(D3DRS_ZBIAS, material.PolygonOffsetFactor);
+	}
+
 	// thickness
 	if (resetAllRenderstates || lastmaterial.Thickness != material.Thickness)
 	{

source/Irrlicht/CD3D9Driver.cpp

@@ -22,6 +22,11 @@ namespace irr
 namespace video
 {
 
+namespace
+{
+	inline DWORD F2DW( FLOAT f ) { return *((DWORD*)&f); }
+}
+
 //! constructor
 CD3D9Driver::CD3D9Driver(const core::dimension2d<u32>& screenSize, HWND window,
 				bool fullscreen, bool stencilbuffer,
@@ -659,6 +664,8 @@ bool CD3D9Driver::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
 		return (Caps.PrimitiveMiscCaps & D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING) != 0;
 	case EVDF_OCCLUSION_QUERY:
 		return OcclusionQuerySupport;
+	case EVDF_POLYGON_OFFSET:
+		return (Caps.RasterCaps & (D3DPRASTERCAPS_DEPTHBIAS|D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS)) != 0;
 	default:
 		return false;
 	};
@@ -1446,13 +1453,13 @@ void CD3D9Driver::draw2D3DVertexPrimitiveList(const void* vertices,
 			if (pType==scene::EPT_POINT_SPRITES)
 				pID3DDevice->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
 			pID3DDevice->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
-			pID3DDevice->SetRenderState(D3DRS_POINTSIZE, *(DWORD*)(&tmp));
+			pID3DDevice->SetRenderState(D3DRS_POINTSIZE, F2DW(tmp));
 			tmp=1.0f;
-			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_A, *(DWORD*)(&tmp));
-			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_B, *(DWORD*)(&tmp));
-			pID3DDevice->SetRenderState(D3DRS_POINTSIZE_MIN, *(DWORD*)(&tmp));
+			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_A, F2DW(tmp));
+			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_B, F2DW(tmp));
+			pID3DDevice->SetRenderState(D3DRS_POINTSIZE_MIN, F2DW(tmp));
 			tmp=0.0f;
-			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_C, *(DWORD*)(&tmp));
+			pID3DDevice->SetRenderState(D3DRS_POINTSCALE_C, F2DW(tmp));
 
 			if (!vertices)
 			{
@@ -2246,6 +2253,31 @@ void CD3D9Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 		pID3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, flag);
 	}
 
+	// Polygon offset
+	if (queryFeature(EVDF_POLYGON_OFFSET) && (resetAllRenderstates ||
+		lastmaterial.PolygonOffsetDirection != material.PolygonOffsetDirection ||
+		lastmaterial.PolygonOffsetFactor != material.PolygonOffsetFactor))
+	{
+		if (material.PolygonOffsetFactor)
+		{
+			if (material.PolygonOffsetDirection==EPO_BACK)
+			{
+				pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(1.f));
+				pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW((FLOAT)material.PolygonOffsetFactor));
+			}
+			else
+			{
+				pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, F2DW(-1.f));
+				pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, F2DW((FLOAT)-material.PolygonOffsetFactor));
+			}
+		}
+		else
+		{
+			pID3DDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
+			pID3DDevice->SetRenderState(D3DRS_DEPTHBIAS, 0);
+		}
+	}
+
 	// Anti Aliasing
 	if (resetAllRenderstates || lastmaterial.AntiAliasing != material.AntiAliasing)
 	{
@@ -2282,7 +2314,7 @@ void CD3D9Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 	// thickness
 	if (resetAllRenderstates || lastmaterial.Thickness != material.Thickness)
 	{
-		pID3DDevice->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&material.Thickness));
+		pID3DDevice->SetRenderState(D3DRS_POINTSIZE, F2DW(material.Thickness));
 	}
 
 	// texture address mode
@@ -2291,7 +2323,7 @@ void CD3D9Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 		if (resetAllRenderstates || lastmaterial.TextureLayer[st].LODBias != material.TextureLayer[st].LODBias)
 		{
 			const float tmp = material.TextureLayer[st].LODBias * 0.125f;
-			pID3DDevice->SetSamplerState(st, D3DSAMP_MIPMAPLODBIAS, *(DWORD*)(&tmp));
+			pID3DDevice->SetSamplerState(st, D3DSAMP_MIPMAPLODBIAS, F2DW(tmp));
 		}
 
 		if (resetAllRenderstates || lastmaterial.TextureLayer[st].TextureWrapU != material.TextureLayer[st].TextureWrapU)
@@ -2796,11 +2828,11 @@ void CD3D9Driver::setFog(SColor color, E_FOG_TYPE fogType, f32 start,
 
 	if (fogType==EFT_FOG_LINEAR)
 	{
-		pID3DDevice->SetRenderState(D3DRS_FOGSTART, *(DWORD*)(&start));
-		pID3DDevice->SetRenderState(D3DRS_FOGEND, *(DWORD*)(&end));
+		pID3DDevice->SetRenderState(D3DRS_FOGSTART, F2DW(start));
+		pID3DDevice->SetRenderState(D3DRS_FOGEND, F2DW(end));
 	}
 	else
-		pID3DDevice->SetRenderState(D3DRS_FOGDENSITY, *(DWORD*)(&density));
+		pID3DDevice->SetRenderState(D3DRS_FOGDENSITY, F2DW(density));
 
 	if(!pixelFog)
 		pID3DDevice->SetRenderState(D3DRS_RANGEFOGENABLE, rangeFog);

source/Irrlicht/COpenGLDriver.cpp

@@ -2913,6 +2913,23 @@ void COpenGLDriver::setBasicRenderStates(const SMaterial& material, const SMater
 			(material.ColorMask & ECP_ALPHA)?GL_TRUE:GL_FALSE);
 	}
 
+	// Polygon Offset
+	if (queryFeature(EVDF_POLYGON_OFFSET) && (resetAllRenderStates ||
+		lastmaterial.PolygonOffsetDirection != material.PolygonOffsetDirection ||
+		lastmaterial.PolygonOffsetFactor != material.PolygonOffsetFactor))
+	{
+		glDisable(lastmaterial.Wireframe?GL_POLYGON_OFFSET_LINE:lastmaterial.PointCloud?GL_POLYGON_OFFSET_POINT:GL_POLYGON_OFFSET_FILL);
+		if (material.PolygonOffsetFactor)
+		{
+			glDisable(material.Wireframe?GL_POLYGON_OFFSET_LINE:material.PointCloud?GL_POLYGON_OFFSET_POINT:GL_POLYGON_OFFSET_FILL);
+			glEnable(material.Wireframe?GL_POLYGON_OFFSET_LINE:material.PointCloud?GL_POLYGON_OFFSET_POINT:GL_POLYGON_OFFSET_FILL);
+		}
+		if (material.PolygonOffsetDirection==EPO_BACK)
+			glPolygonOffset(1.0f, (GLfloat)material.PolygonOffsetFactor);
+		else
+			glPolygonOffset(-1.0f, (GLfloat)-material.PolygonOffsetFactor);
+	}
+
 	// thickness
 	if (resetAllRenderStates || lastmaterial.Thickness != material.Thickness)
 	{
@@ -3372,13 +3389,13 @@ void COpenGLDriver::drawStencilShadowVolume(const core::vector3df* triangles, s3
 	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);
+	glPolygonOffset(1.f,1.f);
+	glEnable(GL_POLYGON_OFFSET_FILL);
 
 	GLenum incr = GL_INCR;
 	GLenum decr = GL_DECR;
@@ -3475,6 +3492,7 @@ void COpenGLDriver::drawStencilShadowVolume(const core::vector3df* triangles, s3
 		glDisable(GL_DEPTH_CLAMP_NV);
 #endif
 
+	glDisable(GL_POLYGON_OFFSET_FILL);
 	glDisableClientState(GL_VERTEX_ARRAY); //not stored on stack
 	glPopAttrib();
 }

source/Irrlicht/COpenGLExtensionHandler.cpp

@@ -821,6 +821,9 @@ bool COpenGLExtensionHandler::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
 		return FeatureAvailable[IRR_ARB_draw_buffers_blend] || FeatureAvailable[IRR_AMD_draw_buffers_blend];
 	case EVDF_OCCLUSION_QUERY:
 		return FeatureAvailable[IRR_ARB_occlusion_query] && OcclusionQuerySupport;
+	case EVDF_POLYGON_OFFSET:
+		// both features supported with OpenGL 1.1
+		return Version>=110;
 	default:
 		return false;
 	};