Add new Material flag ColorMaterial which defines how to interpret the vertex...

Add new Material flag ColorMaterial which defines how to interpret the vertex color when lighting is enabled. It's possible to use the color for diffuse, ambient, specular, or emissive modulation. Also combined diffuse and ambient is possible. This change finally unifies the behavior of non-textured meshes in OpenGL and D3D to a large extent.

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

include/EMaterialFlags.h

@@ -72,7 +72,10 @@ namespace video
 		EMF_ANTI_ALIASING = 0x4000,
 
 		//! ColorMask bits, for enabling the color planes
-		EMF_COLOR_MASK = 0x8000
+		EMF_COLOR_MASK = 0x8000,
+
+		//! ColorMaterial enum for vertex color interpretation
+		EMF_COLOR_MATERIAL = 0x10000
 	};
 
 } // end namespace video

include/SMaterial.h

@@ -141,6 +141,29 @@ namespace video
 		EAAM_ALPHA_TO_COVERAGE=16
 	};
 
+	//! These flags allow to define the interpretation of vertex color when lighting is enabled
+	/** Without lighting being enabled the vertex color is the only value defining the fragment color.
+	Once lighting is enabled, the four values for diffuse, ambient, emissive, and specular take over.
+	With these flags it is possible to define which lighting factor shall be defined by the vertex color
+	instead of the lighting factor which is the same for all faces of that material.
+	The default is to use vertex color for the diffuse value, another pretty common value is to use
+	vertex color for both diffuse and ambient factor. */
+	enum E_COLOR_MATERIAL
+	{
+		//! Don't use vertex color for lighting
+		ECM_NONE=0,
+		//! Use vertex color for diffuse light, this is default
+		ECM_DIFFUSE,
+		//! Use vertex color for ambient light
+		ECM_AMBIENT,
+		//! Use vertex color for emissive light
+		ECM_EMISSIVE,
+		//! Use vertex color for specular light
+		ECM_SPECULAR,
+		//! Use vertex color for both diffuse and ambient light
+		ECM_DIFFUSE_AND_AMBIENT
+	};
+
 	//! Maximum number of texture an SMaterial can have.
 	const u32 MATERIAL_MAX_TEXTURES = 4;
 
@@ -154,6 +177,7 @@ namespace video
 			EmissiveColor(0,0,0,0), SpecularColor(255,255,255,255),
 			Shininess(0.0f), MaterialTypeParam(0.0f), MaterialTypeParam2(0.0f), Thickness(1.0f),
 			ZBuffer(ECFN_LESSEQUAL), AntiAliasing(EAAM_SIMPLE|EAAM_LINE_SMOOTH), ColorMask(ECP_ALL),
+			ColorMaterial(ECM_DIFFUSE),
 			Wireframe(false), PointCloud(false), GouraudShading(true), Lighting(true), ZWriteEnable(true),
 			BackfaceCulling(true), FrontfaceCulling(false), FogEnable(false), NormalizeNormals(false)
 		{ }
@@ -203,6 +227,7 @@ namespace video
 			ZBuffer = other.ZBuffer;
 			AntiAliasing = other.AntiAliasing;
 			ColorMask = other.ColorMask;
+			ColorMaterial = other.ColorMaterial;
 
 			return *this;
 		}
@@ -291,6 +316,14 @@ namespace video
 		depth or stencil buffer, or using Red and Green for Stereo rendering. */
 		u8 ColorMask;
 
+		//! Defines the interpretation of vertex color in the lighting equation
+		/** Values should be chosen from E_COLOR_MATERIAL.
+		When lighting is enabled, vertex color can be used instead of the 
+		material values for light modulation. This allows to easily change e.g. the
+		diffuse light behavior of each face. The default, ECM_DIFFUSE, will result in
+		a very similar rendering as with lighting turned off, just with light shading. */
+		u8 ColorMaterial;
+
 		//! Draw as wireframe or filled triangles? Default: false
 		/** The user can access a material flag using
 		\code material.Wireframe=true \endcode
@@ -432,6 +465,9 @@ namespace video
 				case EMF_COLOR_MASK:
 					ColorMask = value?ECP_ALL:ECP_NONE;
 					break;
+				case EMF_COLOR_MATERIAL:
+					ColorMaterial = value?ECM_DIFFUSE:ECM_NONE;
+					break;
 				default:
 					break;
 			}
@@ -479,6 +515,8 @@ namespace video
 					return (AntiAliasing==1);
 				case EMF_COLOR_MASK:
 					return (ColorMask!=ECP_NONE);
+				case EMF_COLOR_MATERIAL:
+					return (ColorMaterial != ECM_NONE);
 			}
 
 			return false;
@@ -510,7 +548,8 @@ namespace video
 				FogEnable != b.FogEnable ||
 				NormalizeNormals != b.NormalizeNormals ||
 				AntiAliasing != b.AntiAliasing ||
-				ColorMask != b.ColorMask;
+				ColorMask != b.ColorMask ||
+				ColorMaterial != b.ColorMaterial;
 			for (u32 i=0; (i<MATERIAL_MAX_TEXTURES) && !different; ++i)
 			{
 				different |= (TextureLayer[i] != b.TextureLayer[i]);

source/Irrlicht/CBurningShader_Raster_Reference.cpp

@@ -622,7 +622,7 @@ void CBurningShader_Raster_Reference::setMaterial ( const SBurningShaderMaterial
 	enable = F32_LOWER_EQUAL_0 ( m.Shininess );
 	ShaderParam.SetRenderState( BD3DRS_SPECULARENABLE, enable);
 	ShaderParam.SetRenderState( BD3DRS_NORMALIZENORMALS, enable);
-	ShaderParam.SetRenderState( BD3DRS_SPECULARMATERIALSOURCE, BD3DMCS_MATERIAL);
+	ShaderParam.SetRenderState( BD3DRS_SPECULARMATERIALSOURCE, (m.ColorMaterial==ECM_SPECULAR)?BD3DMCS_COLOR1:BD3DMCS_MATERIAL);
 
 	// depth buffer enable and compare
 	ShaderParam.SetRenderState( BD3DRS_ZENABLE, (material.org.ZBuffer==video::ECFN_NEVER) ? BD3DZB_FALSE : BD3DZB_USEW);

source/Irrlicht/CD3D8Driver.cpp

@@ -1310,6 +1310,21 @@ void CD3D8Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 		pID3DDevice->SetMaterial(&mat);
 	}
 
+	if (lastmaterial.ColorMaterial != material.ColorMaterial)
+	{
+		pID3DDevice->SetRenderState(D3DRS_COLORVERTEX, (material.ColorMaterial != ECM_NONE));
+		pID3DDevice->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE,
+			((material.ColorMaterial == ECM_DIFFUSE)||
+			(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE,
+			((material.ColorMaterial == ECM_AMBIENT)||
+			(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE,
+			(material.ColorMaterial == ECM_EMISSIVE)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_SPECULARMATERIALSOURCE,
+			(material.ColorMaterial == ECM_SPECULAR)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+	}
+
 	// fillmode
 	if (resetAllRenderstates || lastmaterial.Wireframe != material.Wireframe || lastmaterial.PointCloud != material.PointCloud)
 	{

source/Irrlicht/CD3D9Driver.cpp

@@ -1624,6 +1624,21 @@ void CD3D9Driver::setBasicRenderStates(const SMaterial& material, const SMateria
 		pID3DDevice->SetMaterial(&mat);
 	}
 
+	if (lastmaterial.ColorMaterial != material.ColorMaterial)
+	{
+		pID3DDevice->SetRenderState(D3DRS_COLORVERTEX, (material.ColorMaterial != ECM_NONE));
+		pID3DDevice->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE,
+			((material.ColorMaterial == ECM_DIFFUSE)||
+			(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE,
+			((material.ColorMaterial == ECM_AMBIENT)||
+			(material.ColorMaterial == ECM_DIFFUSE_AND_AMBIENT))?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_EMISSIVEMATERIALSOURCE,
+			(material.ColorMaterial == ECM_EMISSIVE)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+		pID3DDevice->SetRenderState(D3DRS_SPECULARMATERIALSOURCE,
+			(material.ColorMaterial == ECM_SPECULAR)?D3DMCS_COLOR1:D3DMCS_MATERIAL);
+	}
+
 	// fillmode
 	if (resetAllRenderstates || lastmaterial.Wireframe != material.Wireframe || lastmaterial.PointCloud != material.PointCloud)
 	{

source/Irrlicht/COpenGLDriver.cpp

@@ -1957,44 +1957,86 @@ void COpenGLDriver::setWrapMode(const SMaterial& material)
 void COpenGLDriver::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial,
 	bool resetAllRenderStates)
 {
+	if (resetAllRenderStates ||
+		lastmaterial.ColorMaterial != material.ColorMaterial)
+	{
+		if (material.ColorMaterial != ECM_NONE)
+			glEnable(GL_COLOR_MATERIAL);
+		switch (material.ColorMaterial)
+		{
+		case ECM_NONE:
+			glDisable(GL_COLOR_MATERIAL);
+			break;
+		case ECM_DIFFUSE:
+			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
+			break;
+		case ECM_AMBIENT:
+			glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
+			break;
+		case ECM_EMISSIVE:
+			glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION);
+			break;
+		case ECM_SPECULAR:
+			glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
+			break;
+		case ECM_DIFFUSE_AND_AMBIENT:
+			glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
+			break;
+		}
+	}
+
 	if (resetAllRenderStates ||
 		lastmaterial.AmbientColor != material.AmbientColor ||
 		lastmaterial.DiffuseColor != material.DiffuseColor ||
-		lastmaterial.EmissiveColor != material.EmissiveColor)
+		lastmaterial.EmissiveColor != material.EmissiveColor ||
+		lastmaterial.ColorMaterial != material.ColorMaterial)
 	{
 		GLfloat color[4];
 
 		const f32 inv = 1.0f / 255.0f;
 
+		if ((material.ColorMaterial != video::ECM_AMBIENT) &&
+			(material.ColorMaterial != video::ECM_DIFFUSE_AND_AMBIENT))
+		{
 			color[0] = material.AmbientColor.getRed() * inv;
 			color[1] = material.AmbientColor.getGreen() * inv;
 			color[2] = material.AmbientColor.getBlue() * inv;
 			color[3] = material.AmbientColor.getAlpha() * inv;
 			glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
+		}
 
+		if ((material.ColorMaterial != video::ECM_DIFFUSE) &&
+			(material.ColorMaterial != video::ECM_DIFFUSE_AND_AMBIENT))
+		{
 			color[0] = material.DiffuseColor.getRed() * inv;
 			color[1] = material.DiffuseColor.getGreen() * inv;
 			color[2] = material.DiffuseColor.getBlue() * inv;
 			color[3] = material.DiffuseColor.getAlpha() * inv;
 			glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
+		}
 
+		if (material.ColorMaterial != video::ECM_EMISSIVE)
+		{
 			color[0] = material.EmissiveColor.getRed() * inv;
 			color[1] = material.EmissiveColor.getGreen() * inv;
 			color[2] = material.EmissiveColor.getBlue() * inv;
 			color[3] = material.EmissiveColor.getAlpha() * inv;
 			glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, color);
 		}
+	}
 
 	if (resetAllRenderStates ||
 		lastmaterial.SpecularColor != material.SpecularColor ||
-		lastmaterial.Shininess != material.Shininess)
+		lastmaterial.Shininess != material.Shininess ||
+		lastmaterial.ColorMaterial != material.ColorMaterial)
 	{
 		GLfloat color[4]={0.f,0.f,0.f,1.f};
 		const f32 inv = 1.0f / 255.0f;
 
 		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material.Shininess);
 		// disable Specular colors if no shininess is set
-		if (material.Shininess != 0.0f)
+		if ((material.Shininess != 0.0f) &&
+			(material.ColorMaterial != video::ECM_SPECULAR))
 		{
 #ifdef GL_EXT_separate_specular_color
 			if (FeatureAvailable[IRR_EXT_separate_specular_color])