// Copyright (C) 2002-2006 Nikolaus Gebhardt // This file is part of the "Irrlicht Engine". // For conditions of distribution and use, see copyright notice in irrlicht.h #pragma once #include "ITexture.h" #include "Color.h" namespace Irrlicht { namespace Video { /// /// Abstracted and easy to use standard material modes. /// public __value enum MaterialType { /// Standard solid material. Only first texture is used, which is /// supposed to be the diffuse material. 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, but it /// works with DirectX. 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. Vertex light is ignored. LIGHTMAP, /// Material type with lightmap technique like EMT_LIGHTMAP, but /// lightmap and diffuse texture are not modulated, but added instead. 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. Vertex light is ignored. /// The texture colors are effectively multiplyied by 2 for brightening. /// like known in DirectX as D3DTOP_MODULATE2X. 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. Vertex light is ignored. /// The texture colors are effectively multiplyied by 4 for brightening. /// like known in DirectX as D3DTOP_MODULATE4X. LIGHTMAP_M4, /// Like EMT_LIGHTMAP, but also supports dynamic lighting. LIGHTMAP_LIGHTING, /// Like EMT_LIGHTMAP_M2, but also supports dynamic lighting. LIGHTMAP_LIGHTING_M2, /// Like EMT_LIGHTMAP_4, but also supports dynamic lighting. 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. 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 Texture1. SPHERE_MAP, /// A reflecting material with an /// optional additional non reflecting texture layer. The reflection /// map should be set as Texture 1. /// Please note that this material type is currently not 100% implemented /// in OpenGL. It works in DirectX8. 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 drawed 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 e.g. particle effects. 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 and 3d object, it is a good idea to load the texture in 32 bit /// mode (video::IVideoDriver::setTextureCreationFlag()). 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. TRANSPARENT_VERTEX_ALPHA, /// A transparent reflecting material with an /// optional additional non reflecting texture layer. The reflection /// map should be set as Texture 1. The transparency depends on the /// alpha value in the vertex colors. A texture which will not reflect /// can be set als Texture 2. /// Please note that this material type is currently not 100% implemented /// in OpenGL. It works in DirectX8. 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 /// (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 on 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. Currently, this shader is only implemented for the D3D8 and D3D9 renderers. 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 /// (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 on 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. Currently, this shader is only implemented for the D3D8 and D3D9 renderers. 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 on 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. Currently, this shader is only implemented for the D3D8 and D3D9 renderers. 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 automaticly 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. PARALLAX_MAP_SOLID, /// A material just like EMT_PARALLAX_MAP_SOLID, but it is transparent, using /// EMT_TRANSPARENT_ADD_COLOR as base material. 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. PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA, /// This value is not used. It only forces this enumeration to compile in 32 bit. FORCE_32BIT_DO_NOT_USE = 0x7fffffff }; /// /// Material flags /// public __value enum MaterialFlag { /// Draw as wireframe or filled triangles? Default: false WIREFRAME = 0, /// Draw as point cloud or filled triangles? Default: false POINTCLOUD, /// Flat or Gouraud shading? Default: true GOURAUD_SHADING, /// Will this material be lighted? Default: true LIGHTING, /// Is the ZBuffer enabled? Default: true ZBUFFER, /// May be written to the zbuffer or is it readonly. Default: true /// This flag is ignored, if the material type is a transparent type. ZWRITE_ENABLE, /// Is backfaceculling enabled? Default: true BACK_FACE_CULLING, /// Is bilinear filtering enabled? Default: true BILINEAR_FILTER, /// Is trilinear filtering enabled? Default: false /// If the trilinear filter flag is enabled, /// the bilinear filtering flag is ignored. TRILINEAR_FILTER, //! Is anisotropic filtering? Default: false //! In Irrlicht you can use anisotropic texture filtering in conjunction with bilinear or trilinear //! texture filtering to improve rendering results. Primitives will look less blurry with this //! flag switched on. ANISOTROPIC_FILTER, /// Is fog enabled? Default: false FOG_ENABLE, /// Normalizes normals.You can enable this if you need /// to scale a dynamic lighted model. Usually, its normals will get scaled /// too then and it will get darker. If you enable the EMF_NORMALIZE_NORMALS flag, /// the normals will be normalized again, and the model will look as bright as it should. NORMALIZE_NORMALS, /// This is not a flag, but a value indicating how much flags there are. MATERIAL_FLAG_COUNT }; const System::Int32 MATERIAL_MAX_TEXTURES = 2; /// /// Class describing material parameters /// public __value class Material { public: /// default constructor, creates a solid material with standard colors Material() : AmbientColor(255,255,255,255), DiffuseColor(255,255,255,255), EmissiveColor(0,0,0,0), SpecularColor(0,0,0,0), Texture1(0), Texture2(0), Type(SOLID), Shininess(0.0f) { Flags[MaterialFlag::WIREFRAME] = false; Flags[MaterialFlag::POINTCLOUD] = false; Flags[MaterialFlag::LIGHTING] = true; Flags[MaterialFlag::ZBUFFER] = true; Flags[MaterialFlag::ZWRITE_ENABLE] = true; Flags[MaterialFlag::BACK_FACE_CULLING] = true; Flags[MaterialFlag::GOURAUD_SHADING] = true; Flags[MaterialFlag::BILINEAR_FILTER] = true; Flags[MaterialFlag::TRILINEAR_FILTER] = false; Flags[MaterialFlag::ANISOTROPIC_FILTER] = false; Flags[MaterialFlag::FOG_ENABLE] = false; Flags[MaterialFlag::NORMALIZE_NORMALS] = false; } /// /// Type of the material. Specifies how everything is blended together /// MaterialType Type; /// /// How much ambient light (a global light) is reflected by this material. /// The default is full white, meaning objects are completely globally illuminated. /// Reduce this if you want to see diffuse or specular light effects, or change /// the blend of colors to make the object have a base color other than white. /// Color AmbientColor; /// /// How much diffuse light coming from a light source is reflected by this material. /// The default is full white. /// Color DiffuseColor; /// /// Light emitted by this material. Default is to emitt no light. /// Color EmissiveColor; /// /// How much specular light (highlights from a light) is reflected. /// The default is to reflect no specular light. /// Color SpecularColor; /// /// Value affecting the size of specular highlights. /// float Shininess; /// /// Free parameter dependend on the material type. /// Mostly ignored, used for example in PARALLAX_MAP_SOLID. /// float MaterialTypeParam; /// /// Primary texture layer. /// ITexture* Texture1; /// /// Secondary texture layer. /// ITexture* Texture2; /// /// 3rd texture layer. /// ITexture* Texture3; /// /// 4th texture layer. /// ITexture* Texture4; /// /// Material flags, can also be set by all the properties of this class /// bool Flags __nogc [MATERIAL_FLAG_COUNT]; /// /// Draw as wireframe or filled triangles? Default: false /// __property bool get_Wireframe() { return Flags[WIREFRAME]; } /// /// Draw as pointcloud? Default: false /// __property bool get_PointClound() { return Flags[POINTCLOUD]; } /// /// Flat or Gouraud shading? Default: true /// __property bool get_GouraudShading() { return Flags[GOURAUD_SHADING]; } /// /// Will this material be lighted? Default: true /// __property bool get_Lighting() { return Flags[LIGHTING]; } /// /// Is the ZBuffer enabled? Default: true /// __property bool get_ZBuffer() { return Flags[ZBUFFER]; } /// /// May be written to the zbuffer or is it readonly. Default: true /// This flag is ignored, if the MaterialType is a transparent type. /// __property bool get_ZWriteEnable() { return Flags[ZWRITE_ENABLE]; } /// /// Is backfaceculling enabled? Default: true /// __property bool get_BackfaceCulling() { return Flags[BACK_FACE_CULLING]; } /// /// Is bilinear filtering enabled? Default: true /// __property bool get_BilinearFilter() { return Flags[BILINEAR_FILTER]; } /// /// Is trilinear filtering enabled? Default: false /// If the trilinear filter flag is enabled, /// the bilinear filtering flag is ignored. /// __property bool get_TrilinearFilter() { return Flags[TRILINEAR_FILTER]; } /// /// Is fog enabled? Default: false /// __property bool get_FogEnable() { return Flags[FOG_ENABLE]; } /// /// Normalizes normals? Default: false /// __property bool get_NormalizeNormals() { return Flags[NORMALIZE_NORMALS]; } /// /// Draw as wireframe or filled triangles? Default: false /// __property void set_Wireframe(bool f) { Flags[WIREFRAME] = f; } /// /// Draw as point cloud? Default: false /// __property void set_PointCloud(bool f) { Flags[POINTCLOUD] = f; } /// /// Flat or Gouraud shading? Default: true /// __property void set_GouraudShading(bool f) { Flags[GOURAUD_SHADING] = f; } /// /// Will this material be lighted? Default: true /// __property void set_Lighting(bool f) { Flags[LIGHTING] = f; } /// /// Is the ZBuffer enabled? Default: true /// __property void set_ZBuffer(bool f) { Flags[ZBUFFER] = f; } /// /// May be written to the zbuffer or is it readonly. Default: true /// This flag is ignored, if the MaterialType is a transparent type. /// __property void set_ZWriteEnable(bool f) { Flags[ZWRITE_ENABLE] = f; } /// /// Is backfaceculling enabled? Default: true /// __property void set_BackfaceCulling(bool f) { Flags[BACK_FACE_CULLING] = f; } /// /// Is bilinear filtering enabled? Default: true /// __property void set_BilinearFilter(bool f) { Flags[BILINEAR_FILTER] = f; } /// /// Is trilinear filtering enabled? Default: false /// If the trilinear filter flag is enabled, /// the bilinear filtering flag is ignored. /// __property void set_TrilinearFilter(bool f) { Flags[TRILINEAR_FILTER] = f; } /// /// Is anisotropic filtering enabled? Default: false /// __property void set_AnisotropicFilter(bool f) { Flags[ANISOTROPIC_FILTER] = f; } /// /// Is fog enabled? Default: false /// __property void set_FogEnable(bool f) { Flags[FOG_ENABLE] = f; } /// /// Normalizes normals? Default: false /// __property void set_NormalizeNormals(bool f) { Flags[NORMALIZE_NORMALS] = f; } }; } // end namespace video } // end namespace irr