 |
Nirtcpp 2.1.0
Nirtcpp is a high-performance c++ graphics engine.
|
|
Nirtcpp 2.1.0
Nirtcpp is a high-performance c++ graphics engine.
|
The video namespace contains classes for accessing the video driver. All 2d and 3d rendering is done here. More...
Classes | |
| class | IContextManager |
| class | IGPUProgrammingServices |
| Interface making it possible to create and use programs running on the GPU. More... | |
| class | IImage |
| Interface for software image data. More... | |
| class | IImageLoader |
| Class which is able to create a image from a file. More... | |
| class | IImageWriter |
| Interface for writing software image data. More... | |
| class | IMaterialRenderer |
| Interface for material rendering. More... | |
| class | IMaterialRendererServices |
| Interface providing some methods for changing advanced, internal states of a IVideoDriver. More... | |
| class | IRenderTarget |
| Interface of a Render Target. More... | |
| class | IShaderConstantSetCallBack |
| Interface making it possible to set constants for gpu programs every frame. More... | |
| class | ITexture |
| Interface of a Video Driver dependent Texture. More... | |
| class | IVideoDriver |
| Interface to driver which is able to perform 2d and 3d graphics functions. More... | |
| class | IVideoModeList |
| A list of all available video modes. More... | |
| class | S3DVertex |
| standard vertex used by the Nirtcpp engine. More... | |
| class | S3DVertex2TCoords |
| Vertex with two texture coordinates. More... | |
| class | S3DVertexTangents |
| Vertex with a tangent and binormal vector. More... | |
| class | SColor |
| Class representing a 32 bit ARGB color. More... | |
| class | SColorf |
| Class representing a color with four floats. More... | |
| class | SColorHSL |
| Class representing a color in HSL format. More... | |
| class | SExposedVideoData |
| structure for holding data describing a driver and operating system specific data. More... | |
| class | SLight |
| structure for holding data describing a dynamic point light. More... | |
| class | SMaterial |
| Struct for holding parameters for a material renderer. More... | |
| class | SMaterialLayer |
| Struct for holding material parameters which exist per texture layer. More... | |
| class | SOverrideMaterial |
Functions | |
| f32 | pack_textureBlendFunc (const E_BLEND_FACTOR srcFact, const E_BLEND_FACTOR dstFact, const E_MODULATE_FUNC modulate=EMFN_MODULATE_1X, const u32 alphaSource=EAS_TEXTURE) |
| Pack srcFact, dstFact, Modulate and alpha source to MaterialTypeParam or BlendFactor. | |
| f32 | pack_textureBlendFuncSeparate (const E_BLEND_FACTOR srcRGBFact, const E_BLEND_FACTOR dstRGBFact, const E_BLEND_FACTOR srcAlphaFact, const E_BLEND_FACTOR dstAlphaFact, const E_MODULATE_FUNC modulate=EMFN_MODULATE_1X, const u32 alphaSource=EAS_TEXTURE) |
| Pack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, Modulate and alpha source to MaterialTypeParam or BlendFactor. | |
| void | unpack_textureBlendFunc (E_BLEND_FACTOR &srcFact, E_BLEND_FACTOR &dstFact, E_MODULATE_FUNC &modulo, u32 &alphaSource, const f32 param) |
| Unpack srcFact, dstFact, modulo and alphaSource factors. | |
| void | unpack_textureBlendFuncSeparate (E_BLEND_FACTOR &srcRGBFact, E_BLEND_FACTOR &dstRGBFact, E_BLEND_FACTOR &srcAlphaFact, E_BLEND_FACTOR &dstAlphaFact, E_MODULATE_FUNC &modulo, u32 &alphaSource, const f32 param) |
| Unpack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo and alphaSource factors. | |
| bool | textureBlendFunc_hasAlpha (const E_BLEND_FACTOR factor) |
| has blend factor alphablending | |
| u16 | RGBA16 (u32 r, u32 g, u32 b, u32 a=0xFF) |
| Creates a 16 bit A1R5G5B5 color. | |
| u16 | RGB16 (u32 r, u32 g, u32 b) |
| Creates a 16 bit A1R5G5B5 color. | |
| u16 | RGB16from16 (u16 r, u16 g, u16 b) |
| Creates a 16bit A1R5G5B5 color, based on 16bit input values. | |
| u16 | X8R8G8B8toA1R5G5B5 (u32 color) |
| Converts a 32bit (X8R8G8B8) color to a 16bit A1R5G5B5 color. | |
| u16 | A8R8G8B8toA1R5G5B5 (u32 color) |
| Converts a 32bit (A8R8G8B8) color to a 16bit A1R5G5B5 color. | |
| u16 | A8R8G8B8toR5G6B5 (u32 color) |
| Converts a 32bit (A8R8G8B8) color to a 16bit R5G6B5 color. | |
| u32 | A1R5G5B5toA8R8G8B8 (u16 color) |
| Convert A8R8G8B8 Color from A1R5G5B5 color. | |
| u32 | R5G6B5toA8R8G8B8 (u16 color) |
| Returns A8R8G8B8 Color from R5G6B5 color. | |
| u16 | R5G6B5toA1R5G5B5 (u16 color) |
| Returns A1R5G5B5 Color from R5G6B5 color. | |
| u16 | A1R5G5B5toR5G6B5 (u16 color) |
| Returns R5G6B5 Color from A1R5G5B5 color. | |
| u32 | getAlpha (u16 color) |
| Returns the alpha component from A1R5G5B5 color. | |
| u32 | getRed (u16 color) |
| Returns the red component from A1R5G5B5 color. | |
| u32 | getGreen (u16 color) |
| Returns the green component from A1R5G5B5 color. | |
| u32 | getBlue (u16 color) |
| Returns the blue component from A1R5G5B5 color. | |
| s32 | getAverage (s16 color) |
| Returns the average from a 16 bit A1R5G5B5 color. | |
| u32 | getVertexPitchFromType (E_VERTEX_TYPE vertexType) |
Variables | |
| const c8 *const | PolygonOffsetDirectionNames [] |
| Names for polygon offset direction. | |
| const c8 *const | ZWriteNames [] |
| Names for E_ZWRITE. | |
| const u32 | MATERIAL_MAX_TEXTURES = _NIRT_MATERIAL_MAX_TEXTURES_ |
| Maximum number of texture an SMaterial can have. | |
| NIRTCPP_API u32 | MATERIAL_MAX_TEXTURES_USED |
| By default this is identical to MATERIAL_MAX_TEXTURES. | |
| NIRTCPP_API SMaterial | IdentityMaterial |
| global const identity Material | |
| const c8 *const | LightTypeNames [] |
| Names for light types. | |
| const c8 *const | ColorFormatNames [ECF_UNKNOWN+2] |
| Names for ECOLOR_FORMAT types. | |
| const char *const | sBuiltInVertexTypeNames [] |
| Array holding the built in vertex type names. | |
| const c8 *const | FogTypeNames [] |
| const c8 *const | VERTEX_SHADER_TYPE_NAMES [] |
| Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry. | |
| const c8 *const | PIXEL_SHADER_TYPE_NAMES [] |
| Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry. | |
| const c8 *const | GEOMETRY_SHADER_TYPE_NAMES [] |
| String names for supported geometry shader types. | |
| const char *const | sBuiltInMaterialTypeNames [] |
| Array holding the built in material type names. | |
| const c8 *const | DRIVER_TYPE_NAMES [] |
| const c8 *const | DRIVER_TYPE_NAMES_SHORT [] |
The video namespace contains classes for accessing the video driver. All 2d and 3d rendering is done here.
Source of the alpha value to take.
This is currently only supported in EMT_ONETEXTURE_BLEND. You can use an or'ed combination of values. Alpha values are modulated (multiplied).
| Enumerator | |
|---|---|
| EAS_NONE | Use no alpha, somewhat redundant with other settings. |
| EAS_VERTEX_COLOR | Use vertex color alpha. |
| EAS_TEXTURE | Use texture alpha channel. |
These flags are used to specify the anti-aliasing and smoothing modes.
Techniques supported are multisampling, geometry smoothing, and alpha to coverage. Some drivers don't support a per-material setting of the anti-aliasing modes. In those cases, FSAA/multisampling is defined by the device mode chosen upon creation via nirt::SIrrCreationParameters.
Flag for MaterialTypeParam (in combination with EMT_ONETEXTURE_BLEND) or for BlendFactor BlendFunc = source * sourceFactor + dest * destFactor
Values defining the blend operation.
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.
Comparison function, e.g. for depth buffer test.
An enum for all types of drivers the Nirtcpp Engine supports.
Enumeration for different types of lights.
Material flags.
Abstracted and easy to use fixed function/programmable pipeline material modes.
| Enumerator | |
|---|---|
| EMT_SOLID | Standard solid material. Only first texture is used, which is supposed to be the diffuse material. |
| EMT_SOLID_2_LAYER | 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_LIGHTMAP | 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_ADD | Material type with lightmap technique like EMT_LIGHTMAP. But lightmap and diffuse texture are added instead of modulated. |
| 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 multiplied by 2 for brightening. Like known in DirectX as D3DTOP_MODULATE2X. |
| EMT_LIGHTMAP_M4 | 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 4 for brightening. Like known in DirectX as D3DTOP_MODULATE4X. |
| EMT_LIGHTMAP_LIGHTING | Like EMT_LIGHTMAP, but also supports dynamic lighting. |
| EMT_LIGHTMAP_LIGHTING_M2 | Like EMT_LIGHTMAP_M2, but also supports dynamic lighting. |
| EMT_LIGHTMAP_LIGHTING_M4 | Like EMT_LIGHTMAP_M4, but also supports dynamic lighting. |
| EMT_DETAIL_MAP | 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 subtract 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_SPHERE_MAP | Look like a reflection of the environment around it. To make this possible, a texture called 'sphere map' is used, which must be set as the first texture. |
| EMT_REFLECTION_2_LAYER | A reflecting material with an optional non reflecting texture layer. The reflection map should be set as second texture. |
| EMT_TRANSPARENT_ADD_COLOR | 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_ALPHA_CHANNEL | 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. This value controls how sharp the edges become when going from a transparent to a solid spot on the texture. |
| EMT_TRANSPARENT_ALPHA_CHANNEL_REF | 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 leaves 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_VERTEX_ALPHA | Makes the material transparent based on the vertex alpha value. |
| EMT_TRANSPARENT_REFLECTION_2_LAYER | 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. |
| EMT_NORMAL_MAP_SOLID | 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_TRANSPARENT_ADD_COLOR | 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_VERTEX_ALPHA | 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_PARALLAX_MAP_SOLID | Just like EMT_NORMAL_MAP_SOLID, but uses parallax mapping. 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_TRANSPARENT_ADD_COLOR | A material like EMT_PARALLAX_MAP_SOLID, but transparent. Using EMT_TRANSPARENT_ADD_COLOR as base material. |
| EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA | A material like EMT_PARALLAX_MAP_SOLID, but transparent. Using EMT_TRANSPARENT_VERTEX_ALPHA as base material. |
| EMT_ONETEXTURE_BLEND | BlendFunc = source * sourceFactor + dest * destFactor ( E_BLEND_FUNC ) Using only first texture. Generic blending method. The blend function is set to SMaterial::MaterialTypeParam with pack_textureBlendFunc (for 2D) or pack_textureBlendFuncSeparate (for 3D). |
| EMT_FORCE_32BIT | This value is not used. It only forces this enumeration to compile to 32 bit. |
DEPRECATED. Will be removed after Nirtcpp 1.9.
Flags for the definition of the polygon offset feature. These flags define whether the offset should be into the screen, or towards the eye.
Special render targets, which usually map to dedicated hardware.
These render targets (besides 0 and 1) need not be supported by gfx cards
Texture coord clamp mode outside [0.0, 1.0].
Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created.
| Enumerator | |
|---|---|
| ETCF_ALWAYS_16_BIT | Forces the driver to create 16 bit textures always, independent of which format the file on disk has. When choosing this you may lose some color detail, but gain much speed and memory. 16 bit textures can be transferred twice as fast as 32 bit textures and only use half of the space in memory. When using this flag, it does not make sense to use the flags ETCF_ALWAYS_32_BIT, ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED at the same time. Not all texture formats are affected (usually those up to ECF_A8R8G8B8). |
| ETCF_ALWAYS_32_BIT | Forces the driver to create 32 bit textures always, independent of which format the file on disk has. Please note that some drivers (like the software device) will ignore this, because they are only able to create and use 16 bit textures. Default is true. When using this flag, it does not make sense to use the flags ETCF_ALWAYS_16_BIT, ETCF_OPTIMIZED_FOR_QUALITY, or ETCF_OPTIMIZED_FOR_SPEED at the same time. Not all texture formats are affected (usually those up to ECF_A8R8G8B8). |
| ETCF_OPTIMIZED_FOR_QUALITY | Lets the driver decide in which format the textures are created and tries to make the textures look as good as possible. Usually it simply chooses the format in which the texture was stored on disk. When using this flag, it does not make sense to use the flags ETCF_ALWAYS_16_BIT, ETCF_ALWAYS_32_BIT, or ETCF_OPTIMIZED_FOR_SPEED at the same time. Not all texture formats are affected (usually those up to ECF_A8R8G8B8). |
| ETCF_OPTIMIZED_FOR_SPEED | Lets the driver decide in which format the textures are created and tries to create them maximizing render speed. When using this flag, it does not make sense to use the flags ETCF_ALWAYS_16_BIT, ETCF_ALWAYS_32_BIT, or ETCF_OPTIMIZED_FOR_QUALITY, at the same time. Not all texture formats are affected (usually those up to ECF_A8R8G8B8). |
| ETCF_CREATE_MIP_MAPS | Creates textures with mipmap levels. If disabled textures can not have mipmaps. Default is true. |
| ETCF_NO_ALPHA_CHANNEL | Discard any alpha layer and use non-alpha color format. Warning: This may lead to getting 24-bit texture formats which are often badly supported by drivers. So it's generally not recommended to enable this flag. |
| ETCF_ALLOW_NON_POWER_2 | Allow the Driver to use Non-Power-2-Textures. BurningVideo can handle Non-Power-2 Textures in 2D (GUI), but not in 3D. |
| ETCF_ALLOW_MEMORY_COPY | Allow the driver to keep a copy of the texture in memory. Enabling this makes calls to ITexture::lock a lot faster, but costs main memory. Currently only used in combination with OpenGL drivers. NOTE: Disabling this does not yet work correctly with alpha-textures. So the default is on for now (but might change with Nirtcpp 1.9 if we get the alpha-troubles fixed). |
| ETCF_AUTO_GENERATE_MIP_MAPS | Enable automatic updating mip maps when the base texture changes. Default is true. This flag is only used when ETCF_CREATE_MIP_MAPS is also enabled and if the driver supports it. Please note:
|
| ETCF_SUPPORT_VERTEXT_TEXTURE | Enable support for vertex shader texture sampling on some drivers. Default is false. This adds a small costs to all texture switches. Currently only affects D3D9. On OpenGL vertex shaders use the same texture unit as pixel shaders, so support there only depends on GL version and not on this flag |
| ETCF_FORCE_32_BIT_DO_NOT_USE | This flag is never used, it only forces the compiler to compile these enumeration values to 32 bit. |
Additional bitflags for ITexture::lock() call.
Enum for the mode for texture locking. Read-Only, write-only or read/write.
Where did the last IVideoDriver::getTexture call find this texture.
| Enumerator | |
|---|---|
| ETS_UNKNOWN | IVideoDriver::getTexture was never called (texture created otherwise) |
| ETS_FROM_CACHE | Texture has been found in cache. |
| ETS_FROM_FILE | Texture had to be loaded. |
Enumeration describing the type of ITexture.
| Enumerator | |
|---|---|
| ETT_2D | 2D texture. |
| ETT_CUBEMAP | Cubemap texture. |
enumeration for geometry transformation states
Enumeration for all vertex types there are.
| Enumerator | |
|---|---|
| EVT_STANDARD | Standard vertex type used by the Nirtcpp engine, video::S3DVertex. |
| EVT_2TCOORDS | Vertex with two texture coordinates, video::S3DVertex2TCoords. Usually used for geometry with lightmaps or other special materials. |
| EVT_TANGENTS | Vertex with a tangent and binormal vector, video::S3DVertexTangents. Usually used for tangent space normal mapping. Usually tangent and binormal get send to shaders as texture coordinate sets 1 and 2. |
enumeration for querying features of the video driver.
| Enumerator | |
|---|---|
| EZW_OFF | zwrite always disabled for this material |
| EZW_AUTO | This is the default setting for SMaterial and tries to handle things automatically. This is also the value which is set when SMaterial::setFlag(EMF_ZWRITE_ENABLE) is enabled. Usually zwriting is enabled non-transparent materials - as far as Nirtcpp can recognize those. Basically Nirtcpp tries to handle the zwriting for you and assumes transparent materials don't need it. This is addionally affected by IVideoDriver::setAllowZWriteOnTransparent |
| EZW_ON | zwrite always enabled for this material |
An enum for the color format of textures used by the Nirtcpp Engine.
A color format specifies how color information is stored. NOTE: Byte order in memory is usually flipped (it's probably correct in bitmap files, but flipped on reading). So for example ECF_A8R8G8B8 is BGRA in memory same as in DX9's D3DFMT_A8R8G8B8 format.
Convert A8R8G8B8 Color from A1R5G5B5 color.
build a nicer 32bit Color by extending dest lower bits with source high bits.
Returns the alpha component from A1R5G5B5 color.
In Nirtcpp, alpha refers to opacity.
Returns the blue component from A1R5G5B5 color.
Shift left by 3 to get 8 bit value.
Returns the green component from A1R5G5B5 color.
Shift left by 3 to get 8 bit value.
Returns the red component from A1R5G5B5 color.
Shift left by 3 to get 8 bit value.
|
inline |
Pack srcFact, dstFact, Modulate and alpha source to MaterialTypeParam or BlendFactor.
alpha source can be an OR'ed combination of E_ALPHA_SOURCE values.
|
inline |
Pack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, Modulate and alpha source to MaterialTypeParam or BlendFactor.
alpha source can be an OR'ed combination of E_ALPHA_SOURCE values.
|
inline |
Unpack srcFact, dstFact, modulo and alphaSource factors.
The fields don't use the full byte range, so we could pack even more...
|
inline |
Unpack srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo and alphaSource factors.
The fields don't use the full byte range, so we could pack even more...
| const c8* const nirt::video::DRIVER_TYPE_NAMES[] |
| const c8* const nirt::video::DRIVER_TYPE_NAMES_SHORT[] |
| const c8* const nirt::video::FogTypeNames[] |
| const c8* const nirt::video::GEOMETRY_SHADER_TYPE_NAMES[] |
String names for supported geometry shader types.
| const c8* const nirt::video::LightTypeNames[] |
Names for light types.
| const u32 nirt::video::MATERIAL_MAX_TEXTURES = _NIRT_MATERIAL_MAX_TEXTURES_ |
|
extern |
By default this is identical to MATERIAL_MAX_TEXTURES.
Users can modify this value if they are certain they don't need all available textures per material in their application. For example if you never need more than 2 textures per material you can set this to 2.
We (mostly) avoid dynamic memory in SMaterial, so the extra memory will still be allocated. But by lowering MATERIAL_MAX_TEXTURES_USED the material comparisons can be faster. Also several other places in the engine can be faster when reducing this value to the limit you need.
NOTE: This should only be changed once and before any call to createDevice. NOTE: Do not set it below 1 or above the value of NIRT_MATERIAL_MAX_TEXTURES. NOTE: Going below 4 is usually not worth it.
| const c8* const nirt::video::PIXEL_SHADER_TYPE_NAMES[] |
Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry.
| const c8* const nirt::video::PolygonOffsetDirectionNames[] |
Names for polygon offset direction.
| const char* const nirt::video::sBuiltInMaterialTypeNames[] |
Array holding the built in material type names.
| const char* const nirt::video::sBuiltInVertexTypeNames[] |
Array holding the built in vertex type names.
| const c8* const nirt::video::VERTEX_SHADER_TYPE_NAMES[] |
Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry.
| const c8* const nirt::video::ZWriteNames[] |
Names for E_ZWRITE.