Nirtcpp 2.0.0
Nirtcpp is a high-performance c++ graphics engine.
nirt::video Namespace Reference

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...
 
struct  S3DVertex
 standard vertex used by the Nirtcpp engine. More...
 
struct  S3DVertex2TCoords
 Vertex with two texture coordinates. More...
 
struct  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...
 
struct  SExposedVideoData
 structure for holding data describing a driver and operating system specific data. More...
 
struct  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...
 
struct  SOverrideMaterial
 

Enumerations

enum  E_INDEX_TYPE { EIT_16BIT = 0 , EIT_32BIT }
 
enum  E_TEXTURE_CLAMP {
  ETC_REPEAT = 0 , ETC_CLAMP , ETC_CLAMP_TO_EDGE , ETC_CLAMP_TO_BORDER ,
  ETC_MIRROR , ETC_MIRROR_CLAMP , ETC_MIRROR_CLAMP_TO_EDGE , ETC_MIRROR_CLAMP_TO_BORDER
}
 Texture coord clamp mode outside [0.0, 1.0]. More...
 
enum  E_BLEND_FACTOR {
  EBF_ZERO = 0 , EBF_ONE , EBF_DST_COLOR , EBF_ONE_MINUS_DST_COLOR ,
  EBF_SRC_COLOR , EBF_ONE_MINUS_SRC_COLOR , EBF_SRC_ALPHA , EBF_ONE_MINUS_SRC_ALPHA ,
  EBF_DST_ALPHA , EBF_ONE_MINUS_DST_ALPHA , EBF_SRC_ALPHA_SATURATE
}
 
enum  E_BLEND_OPERATION {
  EBO_NONE = 0 , EBO_ADD , EBO_SUBTRACT , EBO_REVSUBTRACT ,
  EBO_MIN , EBO_MAX , EBO_MIN_FACTOR , EBO_MAX_FACTOR ,
  EBO_MIN_ALPHA , EBO_MAX_ALPHA
}
 Values defining the blend operation. More...
 
enum  E_MODULATE_FUNC { EMFN_MODULATE_1X = 1 , EMFN_MODULATE_2X = 2 , EMFN_MODULATE_4X = 4 }
 MaterialTypeParam: e.g. DirectX: D3DTOP_MODULATE, D3DTOP_MODULATE2X, D3DTOP_MODULATE4X.
 
enum  E_COMPARISON_FUNC {
  ECFN_DISABLED =0 , ECFN_LESSEQUAL =1 , ECFN_EQUAL =2 , ECFN_LESS ,
  ECFN_NOTEQUAL , ECFN_GREATEREQUAL , ECFN_GREATER , ECFN_ALWAYS ,
  ECFN_NEVER
}
 Comparison function, e.g. for depth buffer test. More...
 
enum  E_COLOR_PLANE {
  ECP_NONE =0 , ECP_ALPHA =1 , ECP_RED =2 , ECP_GREEN =4 ,
  ECP_BLUE =8 , ECP_RGB =14 , ECP_ALL =15
}
 Enum values for enabling/disabling color planes for rendering. More...
 
enum  E_ALPHA_SOURCE { EAS_NONE =0 , EAS_VERTEX_COLOR , EAS_TEXTURE }
 Source of the alpha value to take. More...
 
enum  E_ANTI_ALIASING_MODE {
  EAAM_OFF =0 , EAAM_SIMPLE =1 , EAAM_QUALITY =3 , EAAM_LINE_SMOOTH =4 ,
  EAAM_POINT_SMOOTH =8 , EAAM_FULL_BASIC =15 , EAAM_ALPHA_TO_COVERAGE =16
}
 These flags are used to specify the anti-aliasing and smoothing modes. More...
 
enum  E_COLOR_MATERIAL {
  ECM_NONE =0 , ECM_DIFFUSE , ECM_AMBIENT , ECM_EMISSIVE ,
  ECM_SPECULAR , ECM_DIFFUSE_AND_AMBIENT
}
 These flags allow to define the interpretation of vertex color when lighting is enabled. More...
 
enum  E_POLYGON_OFFSET { EPO_BACK =0 , EPO_FRONT =1 }
 DEPRECATED. Will be removed after Nirtcpp 1.9. More...
 
enum  E_ZWRITE { EZW_OFF = 0 , EZW_AUTO , EZW_ON }
 For SMaterial.ZWriteEnable. More...
 
enum  E_LIGHT_TYPE { ELT_POINT , ELT_SPOT , ELT_DIRECTIONAL , ELT_COUNT }
 Enumeration for different types of lights. More...
 
enum  ECOLOR_FORMAT {
  ECF_A1R5G5B5 = 0 , ECF_R5G6B5 , ECF_R8G8B8 , ECF_A8R8G8B8 ,
  ECF_DXT1 , ECF_DXT2 , ECF_DXT3 , ECF_DXT4 ,
  ECF_DXT5 , ECF_PVRTC_RGB2 , ECF_PVRTC_ARGB2 , ECF_PVRTC_RGB4 ,
  ECF_PVRTC_ARGB4 , ECF_PVRTC2_ARGB2 , ECF_PVRTC2_ARGB4 , ECF_ETC1 ,
  ECF_ETC2_RGB , ECF_ETC2_ARGB , ECF_R16F , ECF_G16R16F ,
  ECF_A16B16G16R16F , ECF_R32F , ECF_G32R32F , ECF_A32B32G32R32F ,
  ECF_R8 , ECF_R8G8 , ECF_R16 , ECF_R16G16 ,
  ECF_D16 , ECF_D32 , ECF_D24S8 , ECF_UNKNOWN
}
 An enum for the color format of textures used by the Nirtcpp Engine. More...
 
enum  E_VERTEX_TYPE { EVT_STANDARD = 0 , EVT_2TCOORDS , EVT_TANGENTS }
 Enumeration for all vertex types there are. More...
 
enum  E_TRANSFORMATION_STATE {
  ETS_VIEW = 0 , ETS_WORLD , ETS_PROJECTION , ETS_TEXTURE_0 ,
  ETS_TEXTURE_1 , ETS_TEXTURE_2 , ETS_TEXTURE_3 , ETS_COUNT = ETS_TEXTURE_0 + _NIRT_MATERIAL_MAX_TEXTURES_
}
 enumeration for geometry transformation states More...
 
enum  E_RENDER_TARGET {
  ERT_FRAME_BUFFER =0 , ERT_RENDER_TEXTURE , ERT_MULTI_RENDER_TEXTURES , ERT_STEREO_LEFT_BUFFER ,
  ERT_STEREO_RIGHT_BUFFER , ERT_STEREO_BOTH_BUFFERS , ERT_AUX_BUFFER0 , ERT_AUX_BUFFER1 ,
  ERT_AUX_BUFFER2 , ERT_AUX_BUFFER3 , ERT_AUX_BUFFER4
}
 Special render targets, which usually map to dedicated hardware. More...
 
enum  E_CLEAR_BUFFER_FLAG {
  ECBF_NONE = 0 , ECBF_COLOR = 1 , ECBF_DEPTH = 2 , ECBF_STENCIL = 4 ,
  ECBF_ALL = ECBF_COLOR|ECBF_DEPTH|ECBF_STENCIL
}
 Enum for the flags of clear buffer.
 
enum  E_FOG_TYPE { EFT_FOG_EXP =0 , EFT_FOG_LINEAR , EFT_FOG_EXP2 }
 Enum for the types of fog distributions to choose from.
 
enum  E_TEXTURE_CREATION_FLAG {
  ETCF_ALWAYS_16_BIT = 0x00000001 , ETCF_ALWAYS_32_BIT = 0x00000002 , ETCF_OPTIMIZED_FOR_QUALITY = 0x00000004 , ETCF_OPTIMIZED_FOR_SPEED = 0x00000008 ,
  ETCF_CREATE_MIP_MAPS = 0x00000010 , ETCF_NO_ALPHA_CHANNEL = 0x00000020 , ETCF_ALLOW_NON_POWER_2 = 0x00000040 , ETCF_ALLOW_MEMORY_COPY = 0x00000080 ,
  ETCF_AUTO_GENERATE_MIP_MAPS = 0x00000100 , ETCF_SUPPORT_VERTEXT_TEXTURE = 0x00000200 , ETCF_FORCE_32_BIT_DO_NOT_USE = 0x7fffffff
}
 Enumeration flags used to tell the video driver with setTextureCreationFlag in which format textures should be created. More...
 
enum  E_TEXTURE_LOCK_MODE { ETLM_READ_WRITE = 0 , ETLM_READ_ONLY , ETLM_WRITE_ONLY }
 Enum for the mode for texture locking. Read-Only, write-only or read/write. More...
 
enum  E_TEXTURE_LOCK_FLAGS { ETLF_NONE = 0 , ETLF_FLIP_Y_UP_RTT = 1 }
 Additional bitflags for ITexture::lock() call. More...
 
enum  E_TEXTURE_SOURCE { ETS_UNKNOWN , ETS_FROM_CACHE , ETS_FROM_FILE }
 Where did the last IVideoDriver::getTexture call find this texture. More...
 
enum  E_TEXTURE_TYPE { ETT_2D , ETT_CUBEMAP }
 Enumeration describing the type of ITexture. More...
 
enum  E_CUBE_SURFACE {
  ECS_POSX = 0 , ECS_NEGX , ECS_POSY , ECS_NEGY ,
  ECS_POSZ , ECS_NEGZ
}
 Enumeration of cube texture surfaces.
 
enum  E_VERTEX_SHADER_TYPE {
  EVST_VS_1_1 = 0 , EVST_VS_2_0 , EVST_VS_2_a , EVST_VS_3_0 ,
  EVST_VS_4_0 , EVST_VS_4_1 , EVST_VS_5_0 , EVST_COUNT
}
 Compile target enumeration for the addHighLevelShaderMaterial() method. More...
 
enum  E_PIXEL_SHADER_TYPE {
  EPST_PS_1_1 = 0 , EPST_PS_1_2 , EPST_PS_1_3 , EPST_PS_1_4 ,
  EPST_PS_2_0 , EPST_PS_2_a , EPST_PS_2_b , EPST_PS_3_0 ,
  EPST_PS_4_0 , EPST_PS_4_1 , EPST_PS_5_0 , EPST_COUNT
}
 Compile target enumeration for the addHighLevelShaderMaterial() method. More...
 
enum  E_GEOMETRY_SHADER_TYPE { EGST_GS_4_0 = 0 , EGST_COUNT }
 Enum for supported geometry shader types. More...
 
enum  E_MATERIAL_TYPE {
  EMT_SOLID = 0 , EMT_SOLID_2_LAYER , EMT_LIGHTMAP , EMT_LIGHTMAP_ADD ,
  EMT_LIGHTMAP_M2 , EMT_LIGHTMAP_M4 , EMT_LIGHTMAP_LIGHTING , EMT_LIGHTMAP_LIGHTING_M2 ,
  EMT_LIGHTMAP_LIGHTING_M4 , EMT_DETAIL_MAP , EMT_SPHERE_MAP , EMT_REFLECTION_2_LAYER ,
  EMT_TRANSPARENT_ADD_COLOR , EMT_TRANSPARENT_ALPHA_CHANNEL , EMT_TRANSPARENT_ALPHA_CHANNEL_REF , EMT_TRANSPARENT_VERTEX_ALPHA ,
  EMT_TRANSPARENT_REFLECTION_2_LAYER , EMT_NORMAL_MAP_SOLID , EMT_NORMAL_MAP_TRANSPARENT_ADD_COLOR , EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA ,
  EMT_PARALLAX_MAP_SOLID , EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR , EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA , EMT_ONETEXTURE_BLEND ,
  EMT_FORCE_32BIT = 0x7fffffff
}
 Abstracted and easy to use fixed function/programmable pipeline material modes. More...
 
enum  E_MATERIAL_FLAG {
  EMF_WIREFRAME = 0x1 , EMF_POINTCLOUD = 0x2 , EMF_GOURAUD_SHADING = 0x4 , EMF_LIGHTING = 0x8 ,
  EMF_ZBUFFER = 0x10 , EMF_ZWRITE_ENABLE = 0x20 , EMF_BACK_FACE_CULLING = 0x40 , EMF_FRONT_FACE_CULLING = 0x80 ,
  EMF_BILINEAR_FILTER = 0x100 , EMF_TRILINEAR_FILTER = 0x200 , EMF_ANISOTROPIC_FILTER = 0x400 , EMF_FOG_ENABLE = 0x800 ,
  EMF_NORMALIZE_NORMALS = 0x1000 , EMF_TEXTURE_WRAP = 0x2000 , EMF_ANTI_ALIASING = 0x4000 , EMF_COLOR_MASK = 0x8000 ,
  EMF_COLOR_MATERIAL = 0x10000 , EMF_USE_MIP_MAPS = 0x20000 , EMF_BLEND_OPERATION = 0x40000 , EMF_POLYGON_OFFSET = 0x80000 ,
  EMF_BLEND_FACTOR = 0x160000
}
 Material flags. More...
 
enum  E_DRIVER_TYPE {
  EDT_NULL , EDT_SOFTWARE , EDT_BURNINGSVIDEO , DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS ,
  EDT_DIRECT3D9 , EDT_OPENGL , EDT_COUNT
}
 An enum for all types of drivers the Nirtcpp Engine supports. More...
 
enum  E_VIDEO_DRIVER_FEATURE {
  EVDF_RENDER_TO_TARGET = 0 , EVDF_HARDWARE_TL , EVDF_MULTITEXTURE , EVDF_BILINEAR_FILTER ,
  EVDF_MIP_MAP , EVDF_MIP_MAP_AUTO_UPDATE , EVDF_STENCIL_BUFFER , EVDF_VERTEX_SHADER_1_1 ,
  EVDF_VERTEX_SHADER_2_0 , EVDF_VERTEX_SHADER_3_0 , EVDF_PIXEL_SHADER_1_1 , EVDF_PIXEL_SHADER_1_2 ,
  EVDF_PIXEL_SHADER_1_3 , EVDF_PIXEL_SHADER_1_4 , EVDF_PIXEL_SHADER_2_0 , EVDF_PIXEL_SHADER_3_0 ,
  EVDF_ARB_VERTEX_PROGRAM_1 , EVDF_ARB_FRAGMENT_PROGRAM_1 , EVDF_ARB_GLSL , EVDF_HLSL ,
  EVDF_TEXTURE_NSQUARE , EVDF_TEXTURE_NPOT , EVDF_FRAMEBUFFER_OBJECT , EVDF_VERTEX_BUFFER_OBJECT ,
  EVDF_ALPHA_TO_COVERAGE , EVDF_COLOR_MASK , EVDF_MULTIPLE_RENDER_TARGETS , EVDF_MRT_BLEND ,
  EVDF_MRT_COLOR_MASK , EVDF_MRT_BLEND_FUNC , EVDF_GEOMETRY_SHADER , EVDF_OCCLUSION_QUERY ,
  EVDF_POLYGON_OFFSET , EVDF_BLEND_OPERATIONS , EVDF_BLEND_SEPARATE , EVDF_TEXTURE_MATRIX ,
  EVDF_TEXTURE_COMPRESSED_DXT , EVDF_TEXTURE_COMPRESSED_PVRTC , EVDF_TEXTURE_COMPRESSED_PVRTC2 , EVDF_TEXTURE_COMPRESSED_ETC1 ,
  EVDF_TEXTURE_COMPRESSED_ETC2 , EVDF_TEXTURE_CUBEMAP , EVDF_TEXTURE_CUBEMAP_SEAMLESS , EVDF_DEPTH_CLAMP ,
  EVDF_COUNT
}
 enumeration for querying features of the video driver. More...
 

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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
u32 getRed (u16 color)
 Returns the red component from A1R5G5B5 color. More...
 
u32 getGreen (u16 color)
 Returns the green component from A1R5G5B5 color. More...
 
u32 getBlue (u16 color)
 Returns the blue component from A1R5G5B5 color. More...
 
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. More...
 
const c8 *const ZWriteNames []
 Names for E_ZWRITE. More...
 
const u32 MATERIAL_MAX_TEXTURES = _NIRT_MATERIAL_MAX_TEXTURES_
 Maximum number of texture an SMaterial can have. More...
 
NIRTCPP_API u32 MATERIAL_MAX_TEXTURES_USED
 By default this is identical to MATERIAL_MAX_TEXTURES. More...
 
NIRTCPP_API SMaterial IdentityMaterial
 global const identity Material
 
const c8 *const LightTypeNames []
 Names for light types. More...
 
const c8 *const ColorFormatNames [ECF_UNKNOWN+2]
 Names for ECOLOR_FORMAT types.
 
const char *const sBuiltInVertexTypeNames []
 Array holding the built in vertex type names. More...
 
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. More...
 
const c8 *const PIXEL_SHADER_TYPE_NAMES []
 Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry. More...
 
const c8 *const GEOMETRY_SHADER_TYPE_NAMES []
 String names for supported geometry shader types. More...
 
const char *const sBuiltInMaterialTypeNames []
 Array holding the built in material type names. More...
 
const c8 *const DRIVER_TYPE_NAMES []
 
const c8 *const DRIVER_TYPE_NAMES_SHORT []
 

Detailed Description

The video namespace contains classes for accessing the video driver. All 2d and 3d rendering is done here.

Enumeration Type Documentation

◆ E_ALPHA_SOURCE

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.

◆ E_ANTI_ALIASING_MODE

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.

Enumerator
EAAM_OFF 

Use to turn off anti-aliasing for this material.

EAAM_SIMPLE 

Default anti-aliasing mode.

EAAM_QUALITY 

High-quality anti-aliasing, not always supported, automatically enables SIMPLE mode.

EAAM_LINE_SMOOTH 

Line smoothing Careful, enabling this can lead to software emulation under OpenGL

EAAM_POINT_SMOOTH 

point smoothing, often in software and slow, only with OpenGL

EAAM_FULL_BASIC 

All typical anti-alias and smooth modes.

EAAM_ALPHA_TO_COVERAGE 

Enhanced anti-aliasing for transparent materials.

Usually used with EMT_TRANSPARENT_ALPHA_CHANNEL_REF and multisampling.

◆ E_BLEND_FACTOR

Flag for MaterialTypeParam (in combination with EMT_ONETEXTURE_BLEND) or for BlendFactor BlendFunc = source * sourceFactor + dest * destFactor

Enumerator
EBF_ZERO 

src & dest (0, 0, 0, 0)

EBF_ONE 

src & dest (1, 1, 1, 1)

EBF_DST_COLOR 

src (destR, destG, destB, destA)

EBF_ONE_MINUS_DST_COLOR 

src (1-destR, 1-destG, 1-destB, 1-destA)

EBF_SRC_COLOR 

dest (srcR, srcG, srcB, srcA)

EBF_ONE_MINUS_SRC_COLOR 

dest (1-srcR, 1-srcG, 1-srcB, 1-srcA)

EBF_SRC_ALPHA 

src & dest (srcA, srcA, srcA, srcA)

EBF_ONE_MINUS_SRC_ALPHA 

src & dest (1-srcA, 1-srcA, 1-srcA, 1-srcA)

EBF_DST_ALPHA 

src & dest (destA, destA, destA, destA)

EBF_ONE_MINUS_DST_ALPHA 

src & dest (1-destA, 1-destA, 1-destA, 1-destA)

EBF_SRC_ALPHA_SATURATE 

src (min(srcA, 1-destA), idem, ...)

◆ E_BLEND_OPERATION

Values defining the blend operation.

Enumerator
EBO_NONE 

No blending happens.

EBO_ADD 

Default blending adds the color values.

EBO_SUBTRACT 

This mode subtracts the color values.

EBO_REVSUBTRACT 

This modes subtracts destination from source.

EBO_MIN 

Choose minimum value of each color channel.

EBO_MAX 

Choose maximum value of each color channel.

EBO_MIN_FACTOR 

Choose minimum value of each color channel after applying blend factors, not widely supported.

EBO_MAX_FACTOR 

Choose maximum value of each color channel after applying blend factors, not widely supported.

EBO_MIN_ALPHA 

Choose minimum value of each color channel based on alpha value, not widely supported.

EBO_MAX_ALPHA 

Choose maximum value of each color channel based on alpha value, not widely supported.

◆ E_COLOR_MATERIAL

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.

Enumerator
ECM_NONE 

Don't use vertex color for lighting.

ECM_DIFFUSE 

Use vertex color for diffuse light, this is default.

ECM_AMBIENT 

Use vertex color for ambient light.

ECM_EMISSIVE 

Use vertex color for emissive light.

ECM_SPECULAR 

Use vertex color for specular light.

ECM_DIFFUSE_AND_AMBIENT 

Use vertex color for both diffuse and ambient light.

◆ E_COLOR_PLANE

Enum values for enabling/disabling color planes for rendering.

Enumerator
ECP_NONE 

No color enabled.

ECP_ALPHA 

Alpha enabled.

ECP_RED 

Red enabled.

ECP_GREEN 

Green enabled.

ECP_BLUE 

Blue enabled.

ECP_RGB 

All colors, no alpha.

ECP_ALL 

All planes enabled.

◆ E_COMPARISON_FUNC

Comparison function, e.g. for depth buffer test.

Enumerator
ECFN_DISABLED 

Depth test disabled (disable also write to depth buffer)

ECFN_LESSEQUAL 

<= test, default for e.g. depth test

ECFN_EQUAL 

Exact equality.

ECFN_LESS 

exclusive less comparison, i.e. <

ECFN_NOTEQUAL 

Succeeds almost always, except for exact equality.

ECFN_GREATEREQUAL 

>= test

ECFN_GREATER 

inverse of <=

ECFN_ALWAYS 

test succeeds always

ECFN_NEVER 

Test never succeeds.

◆ E_DRIVER_TYPE

An enum for all types of drivers the Nirtcpp Engine supports.

Enumerator
EDT_NULL 

Null driver, useful for applications to run the engine without visualization.

The null device is able to load textures, but does not render and display any graphics.

EDT_SOFTWARE 

The Nirtcpp Engine Software renderer.

Runs on all platforms, with every hardware. It should only be used for 2d graphics, but it can also perform some primitive 3d functions. These 3d drawing functions are quite fast, but very inaccurate, and don't even support clipping in 3D mode.

EDT_BURNINGSVIDEO 

The Burning's Software Renderer, an alternative software renderer.

Basically it can be described as the Nirtcpp Software renderer on steroids. It rasterizes 3D geometry perfectly: It is able to perform correct 3d clipping, perspective correct texture mapping, perspective correct color mapping, and renders sub pixel correct, sub texel correct primitives. In addition, it does bilinear texel filtering and supports more materials than the EDT_SOFTWARE driver. This renderer has been written entirely by Thomas Alten, thanks a lot for this huge contribution.

DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS 

Direct3D8 device is longer supported in Nirtcpp. You have to go back to Nirtcpp 1.8 if you still need that.

EDT_DIRECT3D9 

Direct3D 9 device, only available on Win32 platforms.

Performs hardware accelerated rendering of 3D and 2D primitives.

EDT_OPENGL 

OpenGL device, available on most platforms.

Performs hardware accelerated rendering of 3D and 2D primitives.

EDT_COUNT 

No driver, just for counting the elements.

◆ E_GEOMETRY_SHADER_TYPE

Enum for supported geometry shader types.

Enumerator
EGST_COUNT 

This is not a type, but a value indicating how much types there are.

◆ E_LIGHT_TYPE

Enumeration for different types of lights.

Enumerator
ELT_POINT 

point light, it has a position in space and radiates light in all directions

ELT_SPOT 

spot light, it has a position in space, a direction, and a limited cone of influence

ELT_DIRECTIONAL 

directional light, coming from a direction from an infinite distance

ELT_COUNT 

Only used for counting the elements of this enum.

◆ E_MATERIAL_FLAG

Material flags.

Enumerator
EMF_WIREFRAME 

Draw as wireframe or filled triangles? Default: false.

EMF_POINTCLOUD 

Draw as point cloud or filled triangles? Default: false.

EMF_GOURAUD_SHADING 

Flat or Gouraud shading? Default: true.

EMF_LIGHTING 

Will this material be lighted? Default: true.

EMF_ZBUFFER 

Is the ZBuffer enabled? Default: true.

EMF_ZWRITE_ENABLE 

May be written to the zbuffer or is it readonly. Default: true.

This flag is ignored, if the material type is a transparent type.

EMF_BACK_FACE_CULLING 

Is backface culling enabled? Default: true.

EMF_FRONT_FACE_CULLING 

Is frontface culling enabled? Default: false.

Overrides EMF_BACK_FACE_CULLING if both are enabled.

EMF_BILINEAR_FILTER 

Is bilinear filtering enabled? Default: true.

EMF_TRILINEAR_FILTER 

Is trilinear filtering enabled? Default: false.

If the trilinear filter flag is enabled, the bilinear filtering flag is ignored.

EMF_ANISOTROPIC_FILTER 

Is anisotropic filtering? Default: false.

In Nirtcpp 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.

EMF_FOG_ENABLE 

Is fog enabled? Default: false.

EMF_NORMALIZE_NORMALS 

Normalizes normals. Default: false.

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.

EMF_TEXTURE_WRAP 

Access to all layers texture wrap settings. Overwrites separate layer settings.

Note that if you want to change TextureWrapU, TextureWrapV, TextureWrapW independently, then you can't work with this flag, but will have to set the variables directly.

EMF_ANTI_ALIASING 

AntiAliasing mode.

EMF_COLOR_MASK 

ColorMask bits, for enabling the color planes.

EMF_COLOR_MATERIAL 

ColorMaterial enum for vertex color interpretation.

EMF_USE_MIP_MAPS 

Flag for enabling/disabling mipmap usage.

EMF_BLEND_OPERATION 

Flag for blend operation.

EMF_POLYGON_OFFSET 

Flag for polygon offset.

EMF_BLEND_FACTOR 

Flag for blend factor.

◆ E_MATERIAL_TYPE

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.

◆ E_PIXEL_SHADER_TYPE

Compile target enumeration for the addHighLevelShaderMaterial() method.

Enumerator
EPST_COUNT 

This is not a type, but a value indicating how much types there are.

◆ E_POLYGON_OFFSET

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.

Enumerator
EPO_BACK 

Push pixel towards the far plane, away from the eye.

This is typically used for rendering inner areas.

EPO_FRONT 

Pull pixels towards the camera.

This is typically used for polygons which should appear on top of other elements, such as decals.

◆ E_RENDER_TARGET

Special render targets, which usually map to dedicated hardware.

These render targets (besides 0 and 1) need not be supported by gfx cards

Enumerator
ERT_FRAME_BUFFER 

Render target is the main color frame buffer.

ERT_RENDER_TEXTURE 

Render target is a render texture.

ERT_MULTI_RENDER_TEXTURES 

Multi-Render target textures.

ERT_STEREO_LEFT_BUFFER 

Render target is the main color frame buffer.

ERT_STEREO_RIGHT_BUFFER 

Render target is the right color buffer (left is the main buffer)

ERT_STEREO_BOTH_BUFFERS 

Render to both stereo buffers at once.

ERT_AUX_BUFFER0 

Auxiliary buffer 0.

ERT_AUX_BUFFER1 

Auxiliary buffer 1.

ERT_AUX_BUFFER2 

Auxiliary buffer 2.

ERT_AUX_BUFFER3 

Auxiliary buffer 3.

ERT_AUX_BUFFER4 

Auxiliary buffer 4.

◆ E_TEXTURE_CLAMP

Texture coord clamp mode outside [0.0, 1.0].

Enumerator
ETC_REPEAT 

Texture repeats.

ETC_CLAMP 

Texture is clamped to the last pixel.

ETC_CLAMP_TO_EDGE 

Texture is clamped to the edge pixel.

ETC_CLAMP_TO_BORDER 

Texture is clamped to the border pixel (if exists)

ETC_MIRROR 

Texture is alternatingly mirrored (0..1..0..1..0..)

ETC_MIRROR_CLAMP 

Texture is mirrored once and then clamped (0..1..0)

ETC_MIRROR_CLAMP_TO_EDGE 

Texture is mirrored once and then clamped to edge.

ETC_MIRROR_CLAMP_TO_BORDER 

Texture is mirrored once and then clamped to border.

◆ E_TEXTURE_CREATION_FLAG

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:

  • On D3D (and maybe older OGL?) you can no longer manually set mipmap data when enabled (for example mips from image loading will be ignored).
  • On D3D (and maybe older OGL?) texture locking for mipmap levels usually won't work anymore.
  • On new OGL this flag is ignored.
  • When disabled you do not get hardware mipmaps on D3D, so mipmap generation can be slower.
  • When disabled you can still update your mipmaps when the texture changed by manually calling regenerateMipMapLevels.
  • You can still call regenerateMipMapLevels when this flag is enabled (it will be a hint on d3d to update mips immediately)
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.

◆ E_TEXTURE_LOCK_FLAGS

Additional bitflags for ITexture::lock() call.

Enumerator
ETLF_FLIP_Y_UP_RTT 

Flip left-bottom origin rendertarget textures upside-down.

Nirtcpp usually has all textures with left-top as origin. And for drivers with a left-bottom origin coordinate system (OpenGL) Nirtcpp modifies the texture-matrix in the fixed function pipeline to make the textures show up correctly (shader coders have to handle upside down textures themselves). But rendertarget textures (RTT's) are written by drivers the way the coordinate system of that driver works. So on OpenGL images tend to look upside down (aka Y coordinate going up) on lock() when this flag isn't set. When the flag is set it will flip such textures on lock() to make them look like non-rtt textures (origin left-top). Note that this also means the texture will be uploaded flipped on unlock. So mostly you want to have this flag set when you want to look at the texture or save it, but unset if you want to upload it again to the card. If you disable this flag you get the memory just as it is on the graphic card. For backward compatibility reasons this flag is enabled by default.

◆ E_TEXTURE_LOCK_MODE

Enum for the mode for texture locking. Read-Only, write-only or read/write.

Enumerator
ETLM_READ_WRITE 

The default mode. Texture can be read and written to.

ETLM_READ_ONLY 

Read only. The texture is downloaded, but not uploaded again.

Often used to read back shader generated textures.

ETLM_WRITE_ONLY 

Write only. The texture is not downloaded and might be uninitialized.

The updated texture is uploaded to the GPU. Used for initializing the shader from the CPU.

◆ E_TEXTURE_SOURCE

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.

◆ E_TEXTURE_TYPE

Enumeration describing the type of ITexture.

Enumerator
ETT_2D 

2D texture.

ETT_CUBEMAP 

Cubemap texture.

◆ E_TRANSFORMATION_STATE

enumeration for geometry transformation states

Enumerator
ETS_VIEW 

View transformation.

ETS_WORLD 

World transformation.

ETS_PROJECTION 

Projection transformation.

ETS_TEXTURE_0 

Texture transformation.

ETS_TEXTURE_1 

Texture transformation.

ETS_TEXTURE_2 

Texture transformation.

ETS_TEXTURE_3 

Texture transformation.

ETS_COUNT 

Only used internally.

◆ E_VERTEX_SHADER_TYPE

Compile target enumeration for the addHighLevelShaderMaterial() method.

Enumerator
EVST_COUNT 

This is not a type, but a value indicating how much types there are.

◆ E_VERTEX_TYPE

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.

◆ E_VIDEO_DRIVER_FEATURE

enumeration for querying features of the video driver.

Enumerator
EVDF_RENDER_TO_TARGET 

Is driver able to render to a surface?

EVDF_HARDWARE_TL 

Is hardware transform and lighting supported?

EVDF_MULTITEXTURE 

Are multiple textures per material possible?

EVDF_BILINEAR_FILTER 

Is driver able to render with a bilinear filter applied?

EVDF_MIP_MAP 

Can the driver handle mip maps?

EVDF_MIP_MAP_AUTO_UPDATE 

Can the driver update mip maps automatically?

EVDF_STENCIL_BUFFER 

Are stencilbuffers switched on and does the device support stencil buffers?

EVDF_VERTEX_SHADER_1_1 

Is Vertex Shader 1.1 supported?

EVDF_VERTEX_SHADER_2_0 

Is Vertex Shader 2.0 supported?

EVDF_VERTEX_SHADER_3_0 

Is Vertex Shader 3.0 supported?

EVDF_PIXEL_SHADER_1_1 

Is Pixel Shader 1.1 supported?

EVDF_PIXEL_SHADER_1_2 

Is Pixel Shader 1.2 supported?

EVDF_PIXEL_SHADER_1_3 

Is Pixel Shader 1.3 supported?

EVDF_PIXEL_SHADER_1_4 

Is Pixel Shader 1.4 supported?

EVDF_PIXEL_SHADER_2_0 

Is Pixel Shader 2.0 supported?

EVDF_PIXEL_SHADER_3_0 

Is Pixel Shader 3.0 supported?

EVDF_ARB_VERTEX_PROGRAM_1 

Are ARB vertex programs v1.0 supported?

EVDF_ARB_FRAGMENT_PROGRAM_1 

Are ARB fragment programs v1.0 supported?

EVDF_ARB_GLSL 

Is GLSL supported?

EVDF_HLSL 

Is HLSL supported?

EVDF_TEXTURE_NSQUARE 

Are non-square textures supported?

EVDF_TEXTURE_NPOT 

Are non-power-of-two textures supported?

EVDF_FRAMEBUFFER_OBJECT 

Are framebuffer objects supported?

EVDF_VERTEX_BUFFER_OBJECT 

Are vertex buffer objects supported?

EVDF_ALPHA_TO_COVERAGE 

Supports Alpha To Coverage.

EVDF_COLOR_MASK 

Supports Color masks (disabling color planes in output)

EVDF_MULTIPLE_RENDER_TARGETS 

Supports multiple render targets at once.

EVDF_MRT_BLEND 

Supports separate blend settings for multiple render targets.

EVDF_MRT_COLOR_MASK 

Supports separate color masks for multiple render targets.

EVDF_MRT_BLEND_FUNC 

Supports separate blend functions for multiple render targets.

EVDF_GEOMETRY_SHADER 

Supports geometry shaders.

EVDF_OCCLUSION_QUERY 

Supports occlusion queries.

EVDF_POLYGON_OFFSET 

Supports polygon offset/depth bias for avoiding z-fighting.

EVDF_BLEND_OPERATIONS 

Support for different blend functions. Without, only ADD is available.

EVDF_BLEND_SEPARATE 

Support for separate blending for RGB and Alpha.

EVDF_TEXTURE_MATRIX 

Support for texture coord transformation via texture matrix.

EVDF_TEXTURE_COMPRESSED_DXT 

Support for DXTn compressed textures.

EVDF_TEXTURE_COMPRESSED_PVRTC 

Support for PVRTC compressed textures.

EVDF_TEXTURE_COMPRESSED_PVRTC2 

Support for PVRTC2 compressed textures.

EVDF_TEXTURE_COMPRESSED_ETC1 

Support for ETC1 compressed textures.

EVDF_TEXTURE_COMPRESSED_ETC2 

Support for ETC2 compressed textures.

EVDF_TEXTURE_CUBEMAP 

Support for cube map textures.

EVDF_TEXTURE_CUBEMAP_SEAMLESS 

Support for filtering across different faces of the cubemap.

EVDF_DEPTH_CLAMP 

Support for clamping vertices beyond far-plane to depth instead of capping them.

EVDF_COUNT 

Only used for counting the elements of this enum.

◆ E_ZWRITE

For SMaterial.ZWriteEnable.

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

◆ ECOLOR_FORMAT

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.

Enumerator
ECF_A1R5G5B5 

16 bit color format used by the software driver.

It is thus preferred by all other nirtcpp engine video drivers. There are 5 bits for every color component, and a single bit is left for alpha information.

ECF_R5G6B5 

Standard 16 bit color format.

ECF_R8G8B8 

24 bit color, no alpha channel, but 8 bit for red, green and blue. Warning: 24 bit formats tend to be badly supported. Depending on driver it's usually converted to another

ECF_A8R8G8B8 

Default 32 bit color format. 8 bits are used for every component: red, green, blue and alpha. Warning: This tends to be BGRA in memory (it's ARGB on file, but with usual big-endian memory it's flipped)

ECF_DXT1 

DXT1 color format.

Compressed image formats.

ECF_DXT2 

DXT2 color format.

ECF_DXT3 

DXT3 color format.

ECF_DXT4 

DXT4 color format.

ECF_DXT5 

DXT5 color format.

ECF_PVRTC_RGB2 

PVRTC RGB 2bpp.

ECF_PVRTC_ARGB2 

PVRTC ARGB 2bpp.

ECF_PVRTC_RGB4 

PVRTC RGB 4bpp.

ECF_PVRTC_ARGB4 

PVRTC ARGB 4bpp.

ECF_PVRTC2_ARGB2 

PVRTC2 ARGB 2bpp.

ECF_PVRTC2_ARGB4 

PVRTC2 ARGB 4bpp.

ECF_ETC1 

ETC1 RGB.

ECF_ETC2_RGB 

ETC2 RGB.

ECF_ETC2_ARGB 

ETC2 ARGB.

ECF_R16F 

16 bit format using 16 bits for the red channel.

The following formats may only be used for render target textures. Floating point formats.

ECF_G16R16F 

32 bit format using 16 bits for the red and green channels.

ECF_A16B16G16R16F 

64 bit format using 16 bits for the red, green, blue and alpha channels.

ECF_R32F 

32 bit format using 32 bits for the red channel.

ECF_G32R32F 

64 bit format using 32 bits for the red and green channels.

ECF_A32B32G32R32F 

128 bit format using 32 bits for the red, green, blue and alpha channels.

ECF_R8 

8 bit format using 8 bits for the red channel.

Unsigned normalized integer formats.

ECF_R8G8 

16 bit format using 8 bits for the red and green channels.

ECF_R16 

16 bit format using 16 bits for the red channel.

ECF_R16G16 

32 bit format using 16 bits for the red and green channels.

ECF_D16 

16 bit format using 16 bits for depth.

Depth and stencil formats.

ECF_D32 

32 bit format using 32 bits for depth.

ECF_D24S8 

32 bit format using 24 bits for depth and 8 bits for stencil.

ECF_UNKNOWN 

Unknown color format:

Function Documentation

◆ A1R5G5B5toA8R8G8B8()

u32 nirt::video::A1R5G5B5toA8R8G8B8 ( u16  color)
inline

Convert A8R8G8B8 Color from A1R5G5B5 color.

build a nicer 32bit Color by extending dest lower bits with source high bits.

◆ getAlpha()

u32 nirt::video::getAlpha ( u16  color)
inline

Returns the alpha component from A1R5G5B5 color.

In Nirtcpp, alpha refers to opacity.

Returns
The alpha value of the color. 0 is transparent, 1 is opaque.

◆ getBlue()

u32 nirt::video::getBlue ( u16  color)
inline

Returns the blue component from A1R5G5B5 color.

Shift left by 3 to get 8 bit value.

◆ getGreen()

u32 nirt::video::getGreen ( u16  color)
inline

Returns the green component from A1R5G5B5 color.

Shift left by 3 to get 8 bit value.

◆ getRed()

u32 nirt::video::getRed ( u16  color)
inline

Returns the red component from A1R5G5B5 color.

Shift left by 3 to get 8 bit value.

◆ pack_textureBlendFunc()

f32 nirt::video::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 
)
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.

◆ pack_textureBlendFuncSeparate()

f32 nirt::video::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 
)
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.

◆ unpack_textureBlendFunc()

void nirt::video::unpack_textureBlendFunc ( E_BLEND_FACTOR srcFact,
E_BLEND_FACTOR dstFact,
E_MODULATE_FUNC modulo,
u32 alphaSource,
const f32  param 
)
inline

Unpack srcFact, dstFact, modulo and alphaSource factors.

The fields don't use the full byte range, so we could pack even more...

◆ unpack_textureBlendFuncSeparate()

void nirt::video::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 
)
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...

Variable Documentation

◆ DRIVER_TYPE_NAMES

const c8* const nirt::video::DRIVER_TYPE_NAMES[]
Initial value:
=
{
"NullDriver",
"Software Renderer",
"Burning's Video",
"Direct3D 8.1",
"Direct3D 9.0c",
"OpenGL 1.x/2.x/3.x",
0
}

◆ DRIVER_TYPE_NAMES_SHORT

const c8* const nirt::video::DRIVER_TYPE_NAMES_SHORT[]
Initial value:
=
{
"null",
"software",
"burning",
"d3d8",
"d3d9",
"opengl",
0
}

◆ FogTypeNames

const c8* const nirt::video::FogTypeNames[]
Initial value:
=
{
"FogExp",
"FogLinear",
"FogExp2",
0
}

◆ GEOMETRY_SHADER_TYPE_NAMES

const c8* const nirt::video::GEOMETRY_SHADER_TYPE_NAMES[]
Initial value:
= {
"gs_4_0",
0 }

String names for supported geometry shader types.

◆ LightTypeNames

const c8* const nirt::video::LightTypeNames[]
Initial value:
=
{
"Point",
"Spot",
"Directional",
0
}

Names for light types.

◆ MATERIAL_MAX_TEXTURES

const u32 nirt::video::MATERIAL_MAX_TEXTURES = _NIRT_MATERIAL_MAX_TEXTURES_

Maximum number of texture an SMaterial can have.

SMaterial might ignore some textures in most function, like assignment and comparison, when SNirtcppCreationParameters::MaxTextureUnits is set to a lower number.

◆ MATERIAL_MAX_TEXTURES_USED

NIRTCPP_API u32 nirt::video::MATERIAL_MAX_TEXTURES_USED
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.

◆ PIXEL_SHADER_TYPE_NAMES

const c8* const nirt::video::PIXEL_SHADER_TYPE_NAMES[]
Initial value:
= {
"ps_1_1",
"ps_1_2",
"ps_1_3",
"ps_1_4",
"ps_2_0",
"ps_2_a",
"ps_2_b",
"ps_3_0",
"ps_4_0",
"ps_4_1",
"ps_5_0",
0 }

Names for all pixel shader types, each entry corresponds to a E_PIXEL_SHADER_TYPE entry.

◆ PolygonOffsetDirectionNames

const c8* const nirt::video::PolygonOffsetDirectionNames[]
Initial value:
=
{
"Back",
"Front",
0
}

Names for polygon offset direction.

◆ sBuiltInMaterialTypeNames

const char* const nirt::video::sBuiltInMaterialTypeNames[]
Initial value:
=
{
"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
}

Array holding the built in material type names.

◆ sBuiltInVertexTypeNames

const char* const nirt::video::sBuiltInVertexTypeNames[]
Initial value:
=
{
"standard",
"2tcoords",
"tangents",
0
}

Array holding the built in vertex type names.

◆ VERTEX_SHADER_TYPE_NAMES

const c8* const nirt::video::VERTEX_SHADER_TYPE_NAMES[]
Initial value:
= {
"vs_1_1",
"vs_2_0",
"vs_2_a",
"vs_3_0",
"vs_4_0",
"vs_4_1",
"vs_5_0",
0 }

Names for all vertex shader types, each entry corresponds to a E_VERTEX_SHADER_TYPE entry.

◆ ZWriteNames

const c8* const nirt::video::ZWriteNames[]
Initial value:
=
{
"Off",
"Auto",
"On",
0
}

Names for E_ZWRITE.