// Copyright (C) 2002-2008 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __E_MATERIAL_TYPES_H_INCLUDED__
#define __E_MATERIAL_TYPES_H_INCLUDED__

namespace irr
{
namespace video
{

	//! Abstracted and easy to use fixed function/programmable pipeline material modes.
	enum E_MATERIAL_TYPE
	{
		//! Standard solid material. Only first texture is used, which
		//! is supposed to be the diffuse material.
		EMT_SOLID = 0,

		//! Solid material with 2 texture layers. The second is blended
		//! onto the first using the alpha value of the vertex colors.
		//! This material is currently not implemented in OpenGL.
		EMT_SOLID_2_LAYER,

		//! Material type with standard lightmap technique:
		//! There should be 2 textures: The first texture layer is a
		//! diffuse map, the second is a light map. Dynamic light is
		//! ignored.
		EMT_LIGHTMAP,

		//! Material type with lightmap technique like EMT_LIGHTMAP. But
		//! lightmap and diffuse texture are added instead of modulated.
		EMT_LIGHTMAP_ADD,

		//! Material type with standard lightmap technique:
		//! There should be 2 textures: The first texture layer is a
		//! diffuse map, the second is a light map. Dynamic light is
		//! ignored. The texture colors are effectively multiplied by 2
		//! for brightening. Like known in DirectX as D3DTOP_MODULATE2X.
		EMT_LIGHTMAP_M2,

		//! Material type with standard lightmap technique:
		//! There should be 2 textures: The first texture layer is a
		//! diffuse map, the second is a light map. Dynamic light is
		//! ignored. The texture colors are effectively multiplyied by 4
		//! for brightening. Like known in DirectX as D3DTOP_MODULATE4X.
		EMT_LIGHTMAP_M4,

		//! Like EMT_LIGHTMAP, but also supports dynamic lighting.
		EMT_LIGHTMAP_LIGHTING,

		//! Like EMT_LIGHTMAP_M2, but also supports dynamic lighting.
		EMT_LIGHTMAP_LIGHTING_M2,

		//! Like EMT_LIGHTMAP_4, but also supports dynamic lighting.
		EMT_LIGHTMAP_LIGHTING_M4,

		//! Detail mapped material. The first texture is diffuse color
		//! map, the second is added to this and usually displayed with
		//! a bigger scale value so that it adds more detail. The
		//! detail map is added to the diffuse map using ADD_SIGNED, so
		//! that it is possible to add and substract color from the
		//! diffuse map. For example a value of (127,127,127) will not
		//! change the appearance of the diffuse map at all. Often used
		//! for terrain rendering.
		EMT_DETAIL_MAP,

		//! Makes the material look like it was reflection the
		//! environment around it. To make this possible, a texture
		//! called 'sphere map' is used, which must be set as the first
		//! texture.
		EMT_SPHERE_MAP,

		//! A reflecting material with an optional additional non
		//! reflecting texture layer. The reflection map should be set
		//! as first texture.
		EMT_REFLECTION_2_LAYER,

		//! A transparent material. Only the first texture is used.
		//! The new color is calculated by simply adding the source
		//! color and the dest color. This means if for example a
		//! billboard using a texture with black background and a red
		//! circle on it is drawn with this material, the result is
		//! that only the red circle will be drawn a little bit
		//! transparent, and everything which was black is 100%
		//! transparent and not visible. This material type is useful
		//! for particle effects.
		EMT_TRANSPARENT_ADD_COLOR,

		//! Makes the material transparent based on the texture alpha
		//! channel. The final color is blended together from the
		//! destination color and the texture color, using the alpha
		//! channel value as blend factor. Only first texture is used.
		//! If you are using this material with small textures, it is a
		//! good idea to load the texture in 32 bit mode
		//! (video::IVideoDriver::setTextureCreationFlag()). Also, an
		//! alpha ref is used, which can be manipulated using
		//! SMaterial::MaterialTypeParam. If set to 0, the alpha ref
		//! gets its default value which is 0.5f and means that
		//! pixels with an alpha value >127 will be written, others not.
		//! In other, simple words: this value controls how sharp the
		//! edges become when going from a transparent to a solid spot
		//! on the texture.
		EMT_TRANSPARENT_ALPHA_CHANNEL,

		//! Makes the material transparent based on the texture alpha
		//! channel. If the alpha channel value is greater than 127, a
		//! pixel is written to the target, otherwise not. This
		//! material does not use alpha blending and is a lot faster
		//! than EMT_TRANSPARENT_ALPHA_CHANNEL. It is ideal for drawing
		//! stuff like leafes of plants, because the borders are not
		//! blurry but sharp. Only first texture is used. If you are
		//! using this material with small textures and 3d object, it
		//! is a good idea to load the texture in 32 bit mode
		//! (video::IVideoDriver::setTextureCreationFlag()).
		EMT_TRANSPARENT_ALPHA_CHANNEL_REF,

		//! Makes the material transparent based on the vertex alpha
		//! value.
		EMT_TRANSPARENT_VERTEX_ALPHA,

		//! A transparent reflecting material with an optional
		//! additional non reflecting texture layer. The reflection map
		//! should be set as first texture. The transparency depends on
		//! the alpha value in the vertex colors. A texture which will
		//! not reflect can be set as second texture. Please note that
		//! this material type is currently not 100% implemented in
		//! OpenGL.
		EMT_TRANSPARENT_REFLECTION_2_LAYER,

		//! A solid normal map renderer. First texture is the color
		//! map, the second should be the normal map. Note that you
		//! should use this material only when drawing geometry
		//! consisting of vertices of type S3DVertexTangents
		//! (EVT_TANGENTS). You can convert any mesh into this format
		//! using IMeshManipulator::createMeshWithTangents() (See
		//! SpecialFX2 Tutorial). This shader runs on vertex shader
		//! 1.1 and pixel shader 1.1 capable hardware and falls back to
		//! a fixed function lighted material if this hardware is not
		//! available. Only two lights are supported by this shader,
		//! if there are more, the nearest two are chosen.
		EMT_NORMAL_MAP_SOLID,

		//! A transparent normal map renderer. First texture is the
		//! color map, the second should be the normal map. Note that
		//! you should use this material only when drawing geometry
		//! consisting of vertices of type S3DVertexTangents
		//! (EVT_TANGENTS). You can convert any mesh into this format
		//! using IMeshManipulator::createMeshWithTangents() (See
		//! SpecialFX2 Tutorial). This shader runs on vertex shader
		//! 1.1 and pixel shader 1.1 capable hardware and falls back to
		//! a fixed function lighted material if this hardware is not
		//! available. Only two lights are supported by this shader,
		//! if there are more, the nearest two are chosen.
		EMT_NORMAL_MAP_TRANSPARENT_ADD_COLOR,

		//! A transparent (based on the vertex alpha value) normal map
		//! renderer. First texture is the color map, the second
		//! should be the normal map. Note that you should use this
		//! material only when drawing geometry consisting of vertices
		//! of type S3DVertexTangents (EVT_TANGENTS). You can convert
		//! any mesh into this format using
		//! IMeshManipulator::createMeshWithTangents() (See SpecialFX2
		//! Tutorial). This shader runs on vertex shader 1.1 and pixel
		//! shader 1.1 capable hardware and falls back to a fixed
		//! function lighted material if this hardware is not available.
		//! Only two lights are supported by this shader, if there are
		//! more, the nearest two are chosen.
		EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA,

		//! Just like EMT_NORMAL_MAP_SOLID, but uses parallax mapping
		//! too, which looks a lot more realistic. This only works when
		//! the hardware supports at least vertex shader 1.1 and pixel
		//! shader 1.4. First texture is the color map, the second
		//! should be the normal map. The normal map texture should
		//! contain the height value in the alpha component. The
		//! IVideoDriver::makeNormalMapTexture() method writes this
		//! value automatically when creating normal maps from a
		//! heightmap when using a 32 bit texture. The height scale of
		//! the material (affecting the bumpiness) is being controlled
		//! by the SMaterial::MaterialTypeParam member. If set to
		//! zero, the default value (0.02f) will be applied. Otherwise
		//! the value set in SMaterial::MaterialTypeParam is taken. This
		//! value depends on with which scale the texture is mapped on
		//! the material. Too high or low values of MaterialTypeParam
		//! can result in strange artifacts.
		EMT_PARALLAX_MAP_SOLID,

		//! A material just like EMT_PARALLAX_MAP_SOLID, but it is
		//! transparent, using EMT_TRANSPARENT_ADD_COLOR as base
		//! material.
		EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR,

		//! A material just like EMT_PARALLAX_MAP_SOLID, but it is
		//! transparent, using EMT_TRANSPARENT_VERTEX_ALPHA as base
		//! material.
		EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA,

		//! BlendFunc = source * sourceFactor + dest * destFactor ( E_BLEND_FUNC )
		//! Using only first texture. Generic blending method.
		EMT_ONETEXTURE_BLEND,

		//! This value is not used. It only forces this enumeration to
		//! compile in 32 bit.
		EMT_FORCE_32BIT = 0x7fffffff
	};

	//! Array holding the built in material type names
	const char* const sBuiltInMaterialTypeNames[] =
	{
		"solid",
		"solid_2layer",
		"lightmap",
		"lightmap_add",
		"lightmap_m2",
		"lightmap_m4",
		"lightmap_light",
		"lightmap_light_m2",
		"lightmap_light_m4",
		"detail_map",
		"sphere_map",
		"reflection_2layer",
		"trans_add",
		"trans_alphach",
		"trans_alphach_ref",
		"trans_vertex_alpha",
		"trans_reflection_2layer",
		"normalmap_solid",
		"normalmap_trans_add",
		"normalmap_trans_vertexalpha",
		"parallaxmap_solid",
		"parallaxmap_trans_add",
		"parallaxmap_trans_vertexalpha",
		"onetexture_blend",
		0
	};

} // end namespace video
} // end namespace irr


#endif // __E_MATERIAL_TYPES_H_INCLUDED__

