CrystalSpace

Public API Reference

3D
[Graphics]


Namespaces

namespace  CS
 Main namespace for CrystalSpace.
namespace  CS
 Main namespace for CrystalSpace.

Classes

struct  csAlphaMode
 Describes how to deal with alpha values in textures. More...
struct  csCoreRenderMesh
 Data required by the renderer to draw a mesh. More...
class  csRenderBufferHolder
 Holder of standard renderbuffers. More...
struct  csRenderMesh
 Mesh data as returned by mesh plugins. More...
struct  csRenderMeshModes
 Mesh render mode information. More...
class  csShaderVariable
 Storage class for "shader vars", inheritable variables in the shader system. More...
struct  iFireTexture
 Interface to the 'fire' procedural texture. More...
struct  iHalo
 iHalo: used to render halos (aka "light globes"). More...
struct  iMaterial
 This class represents a material as seen from the engine view. More...
struct  iProcTexture
 Interface to a texture factory. More...
struct  iRenderBuffer
 This is a general buffer. More...
struct  iRenderBufferAccessor
 Interface for renderbuffer accessor. More...
struct  iRenderBufferCallback
 Callback function used upon destruction of render buffer. More...
struct  iRendererLightmap
 A lightmap registered with a renderer. More...
struct  iShaderVariableAccessor
 Interface to an accessorcallback for shadervariables. More...
struct  iSuperLightmap
 A super light map. More...
struct  iTextureFactory
 Interface to a texture factory. More...
struct  iTextureHandle
 A texture handle as returned by iTextureManager. More...
struct  iTextureManager
 This is the standard texture manager interface. More...
struct  iTextureType
 Texture type. More...
class  CS::StructuredTextureFormat
 Structured representation of a texture format. More...
class  CS::TextureFormatStrings
 Texture format string parser routines. More...

Clipping requirement for DrawTriangleMesh

#define CS_CLIP_NEEDED   1
 Clipping may be needed.
#define CS_CLIP_NOT   0
 No clipping required.

Type of clipper (for iGraphics3D::SetClipper())

#define CS_CLIPPER_NONE   -1
 There is no clipper.
#define CS_CLIPPER_OPTIONAL   0
 Clipper is optional.
#define CS_CLIPPER_REQUIRED   2
 Clipper is required.
#define CS_CLIPPER_TOPLEVEL   1
 Clipper is top-level.

Mix mode: Default modes

A set of commonly used mix modes.

#define CS_FX_ADD   (CS_MIXMODE_BLEND(ONE, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Additive blending. Formula: =SRC+DST.
#define CS_FX_ALPHA   (CS_MIXMODE_BLEND(SRCALPHA, SRCALPHA_INV) | CS_MIXMODE_ALPHATEST_DISABLE)
 Alpha blending.
#define CS_FX_COPY   (CS_MIXMODE_TYPE_AUTO | CS_MIXMODE_ALPHATEST_AUTO)
 This mixmode uses alpha smooth blending, binary blending (ie enabled alpha test) and no blending depending on the contents of csRenderMesh::alphaMode.
#define CS_FX_DESTALPHAADD   (CS_MIXMODE_BLEND(DSTALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiply source color with destination alpha and add.
#define CS_FX_FLAT   (0x04000000)
 Flat shading flag.
#define CS_FX_MASK_ALPHA   (0x000000FF)
 Mixmode alpha part.
#define CS_FX_MASK_MIXMODE   (0xf0ff0000)
 Bit mask for bits relevant to mix mode comparison; contains type, alpha test flags and blending op factors.
#define CS_FX_MESH   (CS_MIXMODE_TYPE_MESH)
 Use the mix mode of the mesh mix mode.
#define CS_FX_MULTIPLY   (CS_MIXMODE_BLEND(DSTCOLOR, ZERO) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiplicative blending. Formula: =SRC*DST.
#define CS_FX_MULTIPLY2   (CS_MIXMODE_BLEND(DSTCOLOR, SRCCOLOR) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiplicative doubling blending. Formula: =2*SRC*DST.
#define CS_FX_PREMULTALPHA   (CS_MIXMODE_BLEND(ONE, SRCALPHA_INV) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiply destination color with inverse source alpha and add source color.
#define CS_FX_SRCALPHAADD   (CS_MIXMODE_BLEND(SRCALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiply source color with source alpha and add.
#define CS_FX_TRANSPARENT   (CS_MIXMODE_BLEND(ZERO, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Transparent blending (keep framebuffer unmodified).

Mix mode: alpha helpers

#define CS_FX_SETALPHA(alpha)   (CS_FX_ALPHA | uint ((alpha) * CS_FX_MASK_ALPHA))
 Macro for setting of alpha bits into mixmode (alpha between 0 and 1).
#define CS_FX_SETALPHA_INT(alpha)   (CS_FX_ALPHA | uint ((alpha) & CS_FX_MASK_ALPHA))
 Macro for setting of alpha bits into mixmode (alpha between 0 and 255).

Mix mode: Alpha test flags

Enabled alpha test (or binary alpha) means that a fragment is only drawn when its alpha component is above a certain threshold, and discarded otherwise.

#define CS_MIXMODE_ALPHATEST_AUTO   (0x00000000)
 Automatic alpha test.
#define CS_MIXMODE_ALPHATEST_DISABLE   (0x20000000)
 Unconditionally disable alpha test.
#define CS_MIXMODE_ALPHATEST_ENABLE   (0x10000000)
 Unconditionally enable alpha test.
#define CS_MIXMODE_ALPHATEST_MASK   (0x30000000)
 Bit mask to extract the alpha test flag from a mixmode specifier.

Mix mode: Blending mode helpers

#define CS_MIXMODE_BLEND(Src, Dst)
 Helper macro to construct a blending operation mixmode Src and Dst are blending op factors , however sans the CS_MIXMODE_FACT_ prefix.
#define CS_MIXMODE_BLENDOP_DST(mode)   ((mode >> 16) & CS_MIXMODE_FACT_MASK)
 Helper macro to extract the dstFactor from a blending op mixmode.
#define CS_MIXMODE_BLENDOP_SRC(mode)   ((mode >> 20) & CS_MIXMODE_FACT_MASK)
 Helper macro to extract the srcFactor from a blending op mixmode.

Mix mode: Types

The mix mode specifies how a shaded fragment (denoted as SRC) is mixed (or blended) with the framebuffer fragment (DST).

#define CS_MIXMODE_TYPE_AUTO   (0x00000000)
 Automatic blending mode.
#define CS_MIXMODE_TYPE_BLENDOP   (0x40000000)
 Blend with a blending operation.
#define CS_MIXMODE_TYPE_MASK   (0xc0000000)
 Bit mask to extract the type from a mixmode specifier.
#define CS_MIXMODE_TYPE_MESH   (0x80000000)
 Use the mix mode of the mesh mix mode.

Texture registration flags.

During texture registration you should tell the manager which way you're going to use the texture: whenever you're going to use it for 2D (DrawPixmap ()), for 3D (DrawPolygon ()), whenever the texture will be dynamically modified.

#define CS_TEXTURE_2D   0x00000001
 You're going to use the texture for 2D drawing.
#define CS_TEXTURE_3D   0x00000002
 You're going to use the texture for 3D drawing.
#define CS_TEXTURE_CLAMP   0x00000010
 This texture will not be tiled, and color lookups outside the 0.
#define CS_TEXTURE_NOFILTER   0x00000020
 This texture will not be filtered, even if texture filtering is available.
#define CS_TEXTURE_NOMIPMAPS   0x00000008
 Create mipmaps for this texture? Sometimes we know in advance that some texture will need just one mipmap (or we just don't care about the mipmapping artifacts because of, say, how texture is looking (smoothed etc)).
#define CS_TEXTURE_NPOTS   0x00000040
 Store texture as non-power-of-two sized (NPOTS) if possible.
#define CS_TEXTURE_SCALE_DOWN   0x00000100
 Texture resizing control flag.
#define CS_TEXTURE_SCALE_UP   0x00000080
 Texture resizing control flag.

iGraphics3D::BeginDraw() flags

#define CSDRAW_2DGRAPHICS   0x00000001
 We're going to draw 2D graphics.
#define CSDRAW_3DGRAPHICS   0x00000002
 We're going to draw 3D graphics.
#define CSDRAW_CLEARSCREEN   0x00000020
 Clear frame buffer ?
#define CSDRAW_CLEARZBUFFER   0x00000010
 Clear Z-buffer ?

Defines

#define CS_BUF_LOCK_NOLOCK   CS::Deprecated::CS_BUF_LOCK_NOLOCK::value
#define CS_BUFFER_MAKE_MASKABLE(x)   (1<<(x))
#define CS_MATERIAL_TEXTURE_DIFFUSE   "tex diffuse"
 Name string for the material "diffuse" texture.
#define CS_MATERIAL_VARNAME_FLATCOLOR   "mat flatcolor"
 Name string for the material "flat color" shader var.
#define CS_VATTRIB_GENERIC_FIRST   100
#define CS_VATTRIB_GENERIC_LAST   (CS_VATTRIB_GENERIC_FIRST + 15)
#define CS_VATTRIB_IS_GENERIC(va)   ((va >= CS_VATTRIB_GENERIC_FIRST) && (va <=CS_VATTRIB_GENERIC_LAST))
#define CS_VATTRIB_IS_SPECIFIC(va)   ((va >= CS_VATTRIB_SPECIFIC_FIRST) && (va <=CS_VATTRIB_SPECIFIC_LAST))
#define CS_VATTRIB_SPECIFIC_FIRST   0
#define CS_VATTRIB_SPECIFIC_LAST   15

Enumerations

enum  {
  CS::StructuredTextureFormat::compR = 0x01, CS::StructuredTextureFormat::compG = 0x02, CS::StructuredTextureFormat::compB = 0x04, CS::StructuredTextureFormat::compA = 0x08,
  CS::StructuredTextureFormat::compX = 0x10, CS::StructuredTextureFormat::compL = 0x20, CS::StructuredTextureFormat::compD = 0x40, CS::StructuredTextureFormat::compS = 0x80,
  CS::StructuredTextureFormat::compRGB = compR | compB | compG, CS::StructuredTextureFormat::compRGBA = compR | compB | compG | compA, CS::StructuredTextureFormat::compLumA = compL | compA, CS::StructuredTextureFormat::compDepthStencil = compD | compS,
  CS::StructuredTextureFormat::compUnknown = 0x80000000
}
 Bit flags for components present in a format. More...
enum  {
  CS_MIXMODE_FACT_ZERO = 0x0, CS_MIXMODE_FACT_ONE = 0x1, CS_MIXMODE_FACT_SRCCOLOR = 0x2, CS_MIXMODE_FACT_SRCCOLOR_INV = 0x3,
  CS_MIXMODE_FACT_DSTCOLOR = 0x4, CS_MIXMODE_FACT_DSTCOLOR_INV = 0x5, CS_MIXMODE_FACT_SRCALPHA = 0x6, CS_MIXMODE_FACT_SRCALPHA_INV = 0x7,
  CS_MIXMODE_FACT_DSTALPHA = 0x8, CS_MIXMODE_FACT_DSTALPHA_INV = 0x9, CS_MIXMODE_FACT_COUNT = 0xa, CS_MIXMODE_FACT_MASK = 0xf
}
 Mix mode: Blending op factors. More...
enum  csRenderBufferComponentType {
  CS_BUFCOMP_BYTE = 0, CS_BUFCOMP_UNSIGNED_BYTE, CS_BUFCOMP_SHORT, CS_BUFCOMP_UNSIGNED_SHORT,
  CS_BUFCOMP_INT, CS_BUFCOMP_UNSIGNED_INT, CS_BUFCOMP_FLOAT, CS_BUFCOMP_DOUBLE,
  CS_BUFCOMP_TYPECOUNT
}
 Type of components. More...
enum  csRenderBufferLockType { CS_BUF_LOCK_READ = 1, CS_BUF_LOCK_NORMAL }
 Type of lock of a render buffer. More...
enum  csRenderBufferName {
  CS_BUFFER_NONE = -1, CS_BUFFER_INDEX, CS_BUFFER_POSITION, CS_BUFFER_NORMAL,
  CS_BUFFER_COLOR, CS_BUFFER_COLOR_UNLIT, CS_BUFFER_TEXCOORD0, CS_BUFFER_TEXCOORD1,
  CS_BUFFER_TEXCOORD2, CS_BUFFER_TEXCOORD3, CS_BUFFER_TEXCOORD_LIGHTMAP, CS_BUFFER_GENERIC0,
  CS_BUFFER_GENERIC1, CS_BUFFER_GENERIC2, CS_BUFFER_GENERIC3, CS_BUFFER_TANGENT,
  CS_BUFFER_BINORMAL, CS_BUFFER_COUNT
}
 Defines the names of the renderbuffers as provided by the meshes. More...
enum  csRenderBufferNameMask {
  CS_BUFFER_INDEX_MASK = 1 << CS_BUFFER_INDEX, CS_BUFFER_POSITION_MASK = 1 << CS_BUFFER_POSITION, CS_BUFFER_NORMAL_MASK = 1 << CS_BUFFER_NORMAL, CS_BUFFER_COLOR_MASK = 1 << CS_BUFFER_COLOR,
  CS_BUFFER_COLOR_LIGHTING_MASK = 1 << CS_BUFFER_COLOR_UNLIT, CS_BUFFER_TEXCOORD0_MASK = 1 << CS_BUFFER_TEXCOORD0, CS_BUFFER_TEXCOORD1_MASK = 1 << CS_BUFFER_TEXCOORD1, CS_BUFFER_TEXCOORD2_MASK = 1 << CS_BUFFER_TEXCOORD2,
  CS_BUFFER_TEXCOORD3_MASK = 1 << CS_BUFFER_TEXCOORD3, CS_BUFFER_TEXCOORD_LIGHTMAP_MASK = 1 << CS_BUFFER_TEXCOORD_LIGHTMAP, CS_BUFFER_GENERIC0_MASK = 1 << CS_BUFFER_GENERIC0, CS_BUFFER_GENERIC1_MASK = 1 << CS_BUFFER_GENERIC1,
  CS_BUFFER_GENERIC2_MASK = 1 << CS_BUFFER_GENERIC2, CS_BUFFER_GENERIC3_MASK = 1 << CS_BUFFER_GENERIC3, CS_BUFFER_TANGENT_MASK = 1 << CS_BUFFER_TANGENT, CS_BUFFER_BINORMAL_MASK = 1 << CS_BUFFER_BINORMAL,
  CS_BUFFER_ALL_MASK = ~0
}
 Masks for renderbuffer accessors. More...
enum  csRenderBufferType { CS_BUF_DYNAMIC, CS_BUF_STATIC, CS_BUF_STREAM }
 Buffer usage type. More...
enum  csVertexAttrib {
  CS_VATTRIB_UNUSED = -2, CS_VATTRIB_INVALID = -1, CS_VATTRIB_POSITION = CS_VATTRIB_SPECIFIC_FIRST + 0, CS_VATTRIB_WEIGHT = CS_VATTRIB_SPECIFIC_FIRST + 1,
  CS_VATTRIB_NORMAL = CS_VATTRIB_SPECIFIC_FIRST + 2, CS_VATTRIB_COLOR = CS_VATTRIB_SPECIFIC_FIRST + 3, CS_VATTRIB_PRIMARY_COLOR = CS_VATTRIB_SPECIFIC_FIRST + 3, CS_VATTRIB_SECONDARY_COLOR = CS_VATTRIB_SPECIFIC_FIRST + 4,
  CS_VATTRIB_FOGCOORD = CS_VATTRIB_SPECIFIC_FIRST + 5, CS_VATTRIB_TEXCOORD = CS_VATTRIB_SPECIFIC_FIRST + 8, CS_VATTRIB_TEXCOORD0 = CS_VATTRIB_SPECIFIC_FIRST + 8, CS_VATTRIB_TEXCOORD1 = CS_VATTRIB_SPECIFIC_FIRST + 9,
  CS_VATTRIB_TEXCOORD2 = CS_VATTRIB_SPECIFIC_FIRST + 10, CS_VATTRIB_TEXCOORD3 = CS_VATTRIB_SPECIFIC_FIRST + 11, CS_VATTRIB_TEXCOORD4 = CS_VATTRIB_SPECIFIC_FIRST + 12, CS_VATTRIB_TEXCOORD5 = CS_VATTRIB_SPECIFIC_FIRST + 13,
  CS_VATTRIB_TEXCOORD6 = CS_VATTRIB_SPECIFIC_FIRST + 14, CS_VATTRIB_TEXCOORD7 = CS_VATTRIB_SPECIFIC_FIRST + 15, CS_VATTRIB_0 = CS_VATTRIB_GENERIC_FIRST + 0, CS_VATTRIB_1 = CS_VATTRIB_GENERIC_FIRST + 1,
  CS_VATTRIB_2 = CS_VATTRIB_GENERIC_FIRST + 2, CS_VATTRIB_3 = CS_VATTRIB_GENERIC_FIRST + 3, CS_VATTRIB_4 = CS_VATTRIB_GENERIC_FIRST + 4, CS_VATTRIB_5 = CS_VATTRIB_GENERIC_FIRST + 5,
  CS_VATTRIB_6 = CS_VATTRIB_GENERIC_FIRST + 6, CS_VATTRIB_7 = CS_VATTRIB_GENERIC_FIRST + 7, CS_VATTRIB_8 = CS_VATTRIB_GENERIC_FIRST + 8, CS_VATTRIB_9 = CS_VATTRIB_GENERIC_FIRST + 9,
  CS_VATTRIB_10 = CS_VATTRIB_GENERIC_FIRST + 10, CS_VATTRIB_11 = CS_VATTRIB_GENERIC_FIRST + 11, CS_VATTRIB_12 = CS_VATTRIB_GENERIC_FIRST + 12, CS_VATTRIB_13 = CS_VATTRIB_GENERIC_FIRST + 13,
  CS_VATTRIB_14 = CS_VATTRIB_GENERIC_FIRST + 14, CS_VATTRIB_15 = CS_VATTRIB_GENERIC_FIRST + 15
}
 Vertex attributes. More...
enum  csZBufMode {
  CS_ZBUF_NONE = 0x00000000, CS_ZBUF_FILL = 0x00000001, CS_ZBUF_TEST = 0x00000002, CS_ZBUF_USE = 0x00000003,
  CS_ZBUF_EQUAL = 0x00000004, CS_ZBUF_INVERT = 0x00000005, CS_ZBUF_MESH = 0x80000000, CS_ZBUF_MESH2 = 0x80000001
}
 Z-buffer modes. More...

Functions

bool CS::StructuredTextureFormat::AddComponent (char cmp, int size)
 Add a new component to the texture format.
static
StructuredTextureFormat 
CS::TextureFormatStrings::ConvertStructured (const char *in)
 Convert a (canonical of not) texture format to a structured form.
void CS::StructuredTextureFormat::FixSizes (int size)
 Fix the unset sizes (i.e.
csString CS::StructuredTextureFormat::GetCanonical ()
 Convert this structured format to canonical format.
char CS::StructuredTextureFormat::GetComponent (int n) const
 Get the nth component.
int CS::StructuredTextureFormat::GetComponentCount () const
 Returns the number of components in this format.
uint CS::StructuredTextureFormat::GetComponentMask () const
 Return a bit mask that identifies the contained components, regardless of their order.
char CS::StructuredTextureFormat::GetComponentSize (int n) const
 Get size of the nth component.
TextureFormat CS::StructuredTextureFormat::GetFormat () const
 Returns the basic storage type for this texture format.
const char * CS::StructuredTextureFormat::GetSpecial () const
 Return the special format string.
bool CS::StructuredTextureFormat::IsValid ()
 Returns whether the contained format is a valid texture format.
bool CS::StructuredTextureFormat::operator== (const StructuredTextureFormat &other) const
void CS::StructuredTextureFormat::SetFormat (TextureFormat format)
 Set the format.
void CS::StructuredTextureFormat::SetSpecial (const char *special)
 A special format (like '*dxt1').
 CS::StructuredTextureFormat::StructuredTextureFormat ()
 Construct an invalid texture format.

Variables

static const size_t csRenderBufferComponentSizes [CS_BUFCOMP_TYPECOUNT]
 Sizes of individual buffer components in bytes.

Texture format strings

Special formats

Special formats are simple: they're designated by a string starting with *, everything else afterwards is arbitrary.

Examples:

General formats

The general syntax is (in dog EBNF):
 format := components {components} [_ format] 
 components := component {component} size
 
whereas component is the component type, summarized below, size is the width of the component, in bit, and format is an optional specifier for the component format.

Component types

Format

Format optionally specifies how the data is encoded. Examples:

Matching components and sizes

A component has the size as specified by the next size specifier right of it.

Examples:

Storage

The leftmost component is stored in the most significant bits; the rightmost component in the least significant bits. A tuple of components is interpreted as a word with the size being the sum of all component sizes, rounded up to the next multiple of 8. These words are then stored in little-endian.

This means that for formats with 8-bit components, the bytes in memory are swapped in comparison to their order in the format string. See the examples.

Examples:

Canonical Format

Canonical format strings, in comparison to "normal" format strings, require all "optional" parts to be present. That is, Examples:

More examples


Define Documentation

#define CS_CLIP_NEEDED   1

Clipping may be needed.

Depending on the type of the clipper (one of the CS_CLIPPER_??? flags) the renderer has to clip or not. (setting for clip_portal, clip_plane, or clip_z_plane).

Definition at line 108 of file graph3d.h.

#define CS_CLIP_NOT   0

No clipping required.

(setting for clip_portal, clip_plane, or clip_z_plane).

Definition at line 102 of file graph3d.h.

#define CS_CLIPPER_NONE   -1

There is no clipper.

Definition at line 81 of file graph3d.h.

#define CS_CLIPPER_OPTIONAL   0

Clipper is optional.

Definition at line 85 of file graph3d.h.

#define CS_CLIPPER_REQUIRED   2

Clipper is required.

Definition at line 93 of file graph3d.h.

#define CS_CLIPPER_TOPLEVEL   1

Clipper is top-level.

Definition at line 89 of file graph3d.h.

#define CS_FX_ADD   (CS_MIXMODE_BLEND(ONE, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)

Additive blending. Formula: =SRC+DST.

Definition at line 340 of file graph3d.h.

#define CS_FX_ALPHA   (CS_MIXMODE_BLEND(SRCALPHA, SRCALPHA_INV) | CS_MIXMODE_ALPHATEST_DISABLE)

Alpha blending.

Formula: =srcAlpha*SRC + (1-srcAlpha)*DST

Remarks:
Usually used with a non-zero alpha part.
See also:
CS_FX_MASK_ALPHA,

CS_FX_SETALPHA

Definition at line 347 of file graph3d.h.

#define CS_FX_COPY   (CS_MIXMODE_TYPE_AUTO | CS_MIXMODE_ALPHATEST_AUTO)

This mixmode uses alpha smooth blending, binary blending (ie enabled alpha test) and no blending depending on the contents of csRenderMesh::alphaMode.

Remarks:
For a "true" copy mixmode that just writes the source fragment color to the frame buffer, you can use:

Definition at line 332 of file graph3d.h.

Referenced by csRenderMeshModes::csRenderMeshModes(), and csMeshObject::GetMixMode().

#define CS_FX_DESTALPHAADD   (CS_MIXMODE_BLEND(DSTALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)

Multiply source color with destination alpha and add.

Formula: =(dstalpha)*SRC + DST

Definition at line 360 of file graph3d.h.

#define CS_FX_FLAT   (0x04000000)

Flat shading flag.

Definition at line 386 of file graph3d.h.

#define CS_FX_MASK_ALPHA   (0x000000FF)

Mixmode alpha part.

Values range from 0(opaque) to 255 (transparent) (note that this is the reverse of the "common" alpha meaning). When this part is non-null, the renderer will scale the incoming color buffer alpha components by the (inverse of) this value.

Remarks:
The scaling may be relatively expensive, it is recommended to scale the vertex alpha by other means, e.g. through a vertex program.

Definition at line 396 of file graph3d.h.

#define CS_FX_MASK_MIXMODE   (0xf0ff0000)

Bit mask for bits relevant to mix mode comparison; contains type, alpha test flags and blending op factors.

Definition at line 402 of file graph3d.h.

#define CS_FX_MESH   (CS_MIXMODE_TYPE_MESH)

Use the mix mode of the mesh mix mode.

Warning:
NOT VALID AS MESH MIXMODE - only for shader pass mixmodes.

Definition at line 383 of file graph3d.h.

#define CS_FX_MULTIPLY   (CS_MIXMODE_BLEND(DSTCOLOR, ZERO) | CS_MIXMODE_ALPHATEST_DISABLE)

Multiplicative blending. Formula: =SRC*DST.

Definition at line 334 of file graph3d.h.

#define CS_FX_MULTIPLY2   (CS_MIXMODE_BLEND(DSTCOLOR, SRCCOLOR) | CS_MIXMODE_ALPHATEST_DISABLE)

Multiplicative doubling blending. Formula: =2*SRC*DST.

Definition at line 337 of file graph3d.h.

#define CS_FX_PREMULTALPHA   (CS_MIXMODE_BLEND(ONE, SRCALPHA_INV) | CS_MIXMODE_ALPHATEST_DISABLE)

Multiply destination color with inverse source alpha and add source color.

Formula: =SRC + DST*(1-srcalpha)

Remarks:
When the SRC alpha component was multiplied into the source color, this acts like alpha blending; if it was not, it acts like additive blending. Hence, this mixmode can be used to use both additive and alpha blending on the same triangle even and interpolate between those two "extremes" by appropriate choice of the color and alpha values.

Definition at line 377 of file graph3d.h.

#define CS_FX_SETALPHA ( alpha   )     (CS_FX_ALPHA | uint ((alpha) * CS_FX_MASK_ALPHA))

Macro for setting of alpha bits into mixmode (alpha between 0 and 1).

Definition at line 408 of file graph3d.h.

Referenced by csParticleSystem::SetAlpha().

#define CS_FX_SETALPHA_INT ( alpha   )     (CS_FX_ALPHA | uint ((alpha) & CS_FX_MASK_ALPHA))

Macro for setting of alpha bits into mixmode (alpha between 0 and 255).

Definition at line 411 of file graph3d.h.

#define CS_FX_SRCALPHAADD   (CS_MIXMODE_BLEND(SRCALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)

Multiply source color with source alpha and add.

Formula: =(srcalpha)*SRC + DST

Definition at line 366 of file graph3d.h.

#define CS_FX_TRANSPARENT   (CS_MIXMODE_BLEND(ZERO, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)

Transparent blending (keep framebuffer unmodified).

Formula: =DST

Remarks:
The Z buffer will still be modified!

Definition at line 354 of file graph3d.h.

#define CS_MATERIAL_TEXTURE_DIFFUSE   "tex diffuse"

Name string for the material "diffuse" texture.

Definition at line 38 of file material.h.

#define CS_MATERIAL_VARNAME_FLATCOLOR   "mat flatcolor"

Name string for the material "flat color" shader var.

Definition at line 36 of file material.h.

#define CS_MIXMODE_ALPHATEST_AUTO   (0x00000000)

Automatic alpha test.

Whether the texture is alpha-blended binarily is taken from csRenderMesh::alphaMode and whether the alpha part of the mixmode is non-zero.

Definition at line 288 of file graph3d.h.

#define CS_MIXMODE_ALPHATEST_DISABLE   (0x20000000)

Unconditionally disable alpha test.

Definition at line 292 of file graph3d.h.

#define CS_MIXMODE_ALPHATEST_ENABLE   (0x10000000)

Unconditionally enable alpha test.

Definition at line 290 of file graph3d.h.

#define CS_MIXMODE_ALPHATEST_MASK   (0x30000000)

Bit mask to extract the alpha test flag from a mixmode specifier.

Definition at line 295 of file graph3d.h.

#define CS_MIXMODE_BLEND ( Src,
Dst   ) 

Value:

(CS_MIXMODE_TYPE_BLENDOP                                                \
  | (CS_MIXMODE_FACT_ ## Src << 20) | (CS_MIXMODE_FACT_ ## Dst << 16))
Helper macro to construct a blending operation mixmode Src and Dst are blending op factors , however sans the CS_MIXMODE_FACT_ prefix.

E.g.:

 uint mixmode = CS_MIXMODE_BLEND(SRCALPHA, SRCALPHA_INV);
will generate a blending operation for alpha blending.

Definition at line 310 of file graph3d.h.

#define CS_MIXMODE_BLENDOP_DST ( mode   )     ((mode >> 16) & CS_MIXMODE_FACT_MASK)

Helper macro to extract the dstFactor from a blending op mixmode.

Definition at line 316 of file graph3d.h.

#define CS_MIXMODE_BLENDOP_SRC ( mode   )     ((mode >> 20) & CS_MIXMODE_FACT_MASK)

Helper macro to extract the srcFactor from a blending op mixmode.

Definition at line 314 of file graph3d.h.

#define CS_MIXMODE_TYPE_AUTO   (0x00000000)

Automatic blending mode.

Whether the texture is alpha-blended or not is taken from csRenderMesh::alphaMode and whether the alpha part of the mixmode is non-zero.

Definition at line 227 of file graph3d.h.

#define CS_MIXMODE_TYPE_BLENDOP   (0x40000000)

Blend with a blending operation.

The fragment value written to the framebuffer is computed from the formula SRC * srcFactor + DST * dstFactor. srcFactor and dstFactor are one of CS_MIXMODE_FACT_xxx , encoded into the mixmode specifier with CS_MIXMODE_BLEND.

Definition at line 236 of file graph3d.h.

#define CS_MIXMODE_TYPE_MASK   (0xc0000000)

Bit mask to extract the type from a mixmode specifier.

Definition at line 244 of file graph3d.h.

#define CS_MIXMODE_TYPE_MESH   (0x80000000)

Use the mix mode of the mesh mix mode.

Warning:
NOT VALID AS MESH MIXMODE - only for shader pass mixmodes.

Definition at line 241 of file graph3d.h.

#define CS_TEXTURE_2D   0x00000001

You're going to use the texture for 2D drawing.

Definition at line 54 of file txtmgr.h.

#define CS_TEXTURE_3D   0x00000002

You're going to use the texture for 3D drawing.

Definition at line 56 of file txtmgr.h.

#define CS_TEXTURE_CLAMP   0x00000010

This texture will not be tiled, and color lookups outside the 0.

.1 range will be clamped to the edge of the texture.

Definition at line 71 of file txtmgr.h.

#define CS_TEXTURE_NOFILTER   0x00000020

This texture will not be filtered, even if texture filtering is available.

Definition at line 75 of file txtmgr.h.

#define CS_TEXTURE_NOMIPMAPS   0x00000008

Create mipmaps for this texture? Sometimes we know in advance that some texture will need just one mipmap (or we just don't care about the mipmapping artifacts because of, say, how texture is looking (smoothed etc)).

This flag is a hint for texture manager so that it will know this.

Note that if texture is not registered for 3D usage (i.e. if CS_TEXTURE_3D is not set) this flag does not matter - 2D textures do not use mipmaps.

Definition at line 66 of file txtmgr.h.

#define CS_TEXTURE_NPOTS   0x00000040

Store texture as non-power-of-two sized (NPOTS) if possible.

Remarks:
On a lot of hardware, support for NPOTS-texture is rather limited; for example, commonly only clamped and textures without mipmaps are supported, hence a texture may only be considered for NPOTS use if the CS_TEXTURE_CLAMP and CS_TEXTURE_NOMIPMAPS flags are also set. Some hardware may not support NPOTS textures at all. It is at the discretion of the renderer to decide whether a texture really becomes NPOTS or not. This flag serves merely as an expression of the wish that a texture should be NPOTS, if possible. If that cannot be granted, the flag will be removed (thus you can query whether a texture was stored NPOTS or not by checking if this flag is set on it).

Definition at line 89 of file txtmgr.h.

#define CS_TEXTURE_SCALE_DOWN   0x00000100

Texture resizing control flag.

If a texture needs to be resized to power-of-two dimensions (either because non-power-of-two textures are not supported or just not requested), specify that powers of two smaller than or equal to the original dimensions should be selected.

See also:
CS_TEXTURE_SCALE_UP
Remarks:
If none or both texture scale flags are specified, the renderer will decide whether a dimension is scaled up or down.

Definition at line 111 of file txtmgr.h.

#define CS_TEXTURE_SCALE_UP   0x00000080

Texture resizing control flag.

If a texture needs to be resized to power-of-two dimensions (either because non-power-of-two textures are not supported or just not requested), specify that powers of two larger than or equal to the original dimensions should be selected.

See also:
CS_TEXTURE_SCALE_DOWN
Remarks:
If none or both texture scale flags are specified, the renderer will decide whether a dimension is scaled up or down.

Definition at line 100 of file txtmgr.h.

#define CSDRAW_2DGRAPHICS   0x00000001

We're going to draw 2D graphics.

Definition at line 67 of file graph3d.h.

#define CSDRAW_3DGRAPHICS   0x00000002

We're going to draw 3D graphics.

Definition at line 69 of file graph3d.h.

#define CSDRAW_CLEARSCREEN   0x00000020

Clear frame buffer ?

Definition at line 73 of file graph3d.h.

#define CSDRAW_CLEARZBUFFER   0x00000010

Clear Z-buffer ?

Definition at line 71 of file graph3d.h.


Enumeration Type Documentation

anonymous enum [inherited]

Bit flags for components present in a format.

See also:
Component types
Enumerator:
compR  'r' component
compG  'g' component
compB  'b' component
compA  'a' component
compX  'x' component
compL  'l' component
compD  'd' component
compS  's' component
compRGB  'r', 'g' and 'b' components
compRGBA  'r', 'g', 'b' and 'a' components
compLumA  'l' and 'a' components
compDepthStencil  'd' and 's' components
compUnknown  One or more components are unknown.

Definition at line 257 of file textureformatstrings.h.

anonymous enum

Mix mode: Blending op factors.

Enumerator:
CS_MIXMODE_FACT_ZERO  0
CS_MIXMODE_FACT_ONE  -(e^(i*Pi))
CS_MIXMODE_FACT_SRCCOLOR  Source fragment (R,G,B,A) components.
CS_MIXMODE_FACT_SRCCOLOR_INV  Source fragment (1-R,1-G,1-B,-1A) components.
CS_MIXMODE_FACT_DSTCOLOR  Destination fragment (R,G,B,A) components.
CS_MIXMODE_FACT_DSTCOLOR_INV  Destination fragment (1-R,1-G,1-B,-1A) components.
CS_MIXMODE_FACT_SRCALPHA  Source fragment alpha.
CS_MIXMODE_FACT_SRCALPHA_INV  Source fragment 1-alpha.
CS_MIXMODE_FACT_DSTALPHA  Destination fragment alpha.
CS_MIXMODE_FACT_DSTALPHA_INV  Destination fragment 1-alpha.
CS_MIXMODE_FACT_COUNT  Number of available mixmodes.
CS_MIXMODE_FACT_MASK  Mask to extract factors.

Definition at line 248 of file graph3d.h.

Type of components.

Enumerator:
CS_BUFCOMP_BYTE 
CS_BUFCOMP_UNSIGNED_BYTE 
CS_BUFCOMP_SHORT 
CS_BUFCOMP_UNSIGNED_SHORT 
CS_BUFCOMP_INT 
CS_BUFCOMP_UNSIGNED_INT 
CS_BUFCOMP_FLOAT 
CS_BUFCOMP_DOUBLE 
CS_BUFCOMP_TYPECOUNT 

Definition at line 60 of file rndbuf.h.

Type of lock of a render buffer.

Enumerator:
CS_BUF_LOCK_READ  Lock used for reading only from the buffer.
CS_BUF_LOCK_NORMAL  Get a (writeable) pointer to the buffer.

Definition at line 77 of file rndbuf.h.

Defines the names of the renderbuffers as provided by the meshes.

Remarks:
These constants are used to generate a mask (see csRenderBufferNameMask), hence their number should be kept below 32.
Enumerator:
CS_BUFFER_NONE 
CS_BUFFER_INDEX  Index buffer.
CS_BUFFER_POSITION  Vertex positions.
CS_BUFFER_NORMAL  Normals.
CS_BUFFER_COLOR  Primary color multiplied with lighting.
CS_BUFFER_COLOR_UNLIT  Primary color.
CS_BUFFER_TEXCOORD0  Texture coordinate 0.
CS_BUFFER_TEXCOORD1  Texture coordinate 1.
CS_BUFFER_TEXCOORD2  Texture coordinate 2.
CS_BUFFER_TEXCOORD3  Texture coordinate 3.
CS_BUFFER_TEXCOORD_LIGHTMAP  Texture coordinates for lightmap.
CS_BUFFER_GENERIC0  Generic buffer 0, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC1  Generic buffer 1, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC2  Generic buffer 2, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC3  Generic buffer 3, can be used for example for matrix-palette skinning etc.
CS_BUFFER_TANGENT  Tangents.
CS_BUFFER_BINORMAL  Binormals.
CS_BUFFER_COUNT  Not really a renderbuffer.

Use to determine the number of available default buffer names.

Definition at line 234 of file rndbuf.h.

Masks for renderbuffer accessors.

Enumerator:
CS_BUFFER_INDEX_MASK  Index buffer.
CS_BUFFER_POSITION_MASK  Vertex positions.
CS_BUFFER_NORMAL_MASK  Normals.
CS_BUFFER_COLOR_MASK  Primary color.
CS_BUFFER_COLOR_LIGHTING_MASK  Primary color multiplied with lighting.
CS_BUFFER_TEXCOORD0_MASK  Texture coordinate 0.
CS_BUFFER_TEXCOORD1_MASK  Texture coordinate 1.
CS_BUFFER_TEXCOORD2_MASK  Texture coordinate 2.
CS_BUFFER_TEXCOORD3_MASK  Texture coordinate 3.
CS_BUFFER_TEXCOORD_LIGHTMAP_MASK  Texture coordinates for lightmap.
CS_BUFFER_GENERIC0_MASK  Generic buffer 0, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC1_MASK  Generic buffer 1, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC2_MASK  Generic buffer 2, can be used for example for matrix-palette skinning etc.
CS_BUFFER_GENERIC3_MASK  Generic buffer 3, can be used for example for matrix-palette skinning etc.
CS_BUFFER_TANGENT_MASK  Tangents.
CS_BUFFER_BINORMAL_MASK  Binormals.
CS_BUFFER_ALL_MASK  All buffers.

Definition at line 280 of file rndbuf.h.

Buffer usage type.

Drivers may do some optimizations based on this value. Use a type that most closely matches the intended use.

Enumerator:
CS_BUF_DYNAMIC  Data that changes every couple of frames and is drawn repeatedly.
CS_BUF_STATIC  Data that is seldom modified and often drawn.
CS_BUF_STREAM  Data that changes every time it is drawn.

Definition at line 48 of file rndbuf.h.

Vertex attributes.

Enumerator:
CS_VATTRIB_UNUSED  An attribute is valid, but unused by a shader program and can be discarded.
CS_VATTRIB_INVALID  Invalid attribute.
CS_VATTRIB_POSITION  Position vertex attribute.
CS_VATTRIB_WEIGHT  Vertex weight attribute.
CS_VATTRIB_NORMAL  Normal attribute.
CS_VATTRIB_COLOR  Primary color attribute.
CS_VATTRIB_PRIMARY_COLOR  Primary color attribute.
CS_VATTRIB_SECONDARY_COLOR  Secondary color attribute.
CS_VATTRIB_FOGCOORD  Fog coordinate attribute.
CS_VATTRIB_TEXCOORD  TU 0 texture coordinates.
CS_VATTRIB_TEXCOORD0  TU 0 texture coordinates.
CS_VATTRIB_TEXCOORD1  TU 1 texture coordinates.
CS_VATTRIB_TEXCOORD2  TU 2 texture coordinates.
CS_VATTRIB_TEXCOORD3  TU 3 texture coordinates.
CS_VATTRIB_TEXCOORD4  TU 4 texture coordinates.
CS_VATTRIB_TEXCOORD5  TU 5 texture coordinates.
CS_VATTRIB_TEXCOORD6  TU 6 texture coordinates.
CS_VATTRIB_TEXCOORD7  TU 7 texture coordinates.
CS_VATTRIB_0  General vertex attribute.
CS_VATTRIB_1  General vertex attribute.
CS_VATTRIB_2  General vertex attribute.
CS_VATTRIB_3  General vertex attribute.
CS_VATTRIB_4  General vertex attribute.
CS_VATTRIB_5  General vertex attribute.
CS_VATTRIB_6  General vertex attribute.
CS_VATTRIB_7  General vertex attribute.
CS_VATTRIB_8  General vertex attribute.
CS_VATTRIB_9  General vertex attribute.
CS_VATTRIB_10  General vertex attribute.
CS_VATTRIB_11  General vertex attribute.
CS_VATTRIB_12  General vertex attribute.
CS_VATTRIB_13  General vertex attribute.
CS_VATTRIB_14  General vertex attribute.
CS_VATTRIB_15 

Definition at line 155 of file graph3d.h.

enum csZBufMode

Z-buffer modes.

Enumerator:
CS_ZBUF_NONE  Don't test or write.
CS_ZBUF_FILL  Write unconditionally.
CS_ZBUF_TEST  Test only.
CS_ZBUF_USE  Test, write if successful.
CS_ZBUF_EQUAL  Test if equal.
CS_ZBUF_INVERT  Inverted test.
CS_ZBUF_MESH  Use the z mode of the render mesh (NOTE: NOT VALID AS MESH ZMODE).
CS_ZBUF_MESH2  Use a "pass 2" z mode depending on the render mesh zmode.

The mesh zmode is used a to choose a zmode that makes sure only pixels that are changed by the mesh zmode can be touched, e.g. if the mesh has a zmode of "zuse", zmesh2 will resolve to "ztest". This is useful for multi- pass stuff. (NOTE: NOT VALID AS MESH ZMODE)

Definition at line 112 of file graph3d.h.


Function Documentation

bool CS::StructuredTextureFormat::AddComponent ( char  cmp,
int  size 
) [inherited]

Add a new component to the texture format.

Parameters:
cmp One of the 'Component types' listed in Component types.
size Size of that component. Can be 0, but then it will have to be set later using FixSizes().
Returns:
Whether the component could be added or not.

static StructuredTextureFormat CS::TextureFormatStrings::ConvertStructured ( const char *  in  )  [static, inherited]

Convert a (canonical of not) texture format to a structured form.

See also:
Texture format strings

void CS::StructuredTextureFormat::FixSizes ( int  size  )  [inherited]

Fix the unset sizes (i.e.

0 sizes) so that they are filled with the given size.

csString CS::StructuredTextureFormat::GetCanonical (  )  [inherited]

Convert this structured format to canonical format.

See also:
Canonical Format

char CS::StructuredTextureFormat::GetComponent ( int  n  )  const [inline, inherited]

Get the nth component.

Returns 0 if there is no such component.

Definition at line 218 of file textureformatstrings.h.

int CS::StructuredTextureFormat::GetComponentCount (  )  const [inline, inherited]

Returns the number of components in this format.

Returns 0 for special or invalid formats.

Definition at line 202 of file textureformatstrings.h.

uint CS::StructuredTextureFormat::GetComponentMask (  )  const [inherited]

Return a bit mask that identifies the contained components, regardless of their order.

This can be used to "classify" a texture format. The bit flags are compR, compG etc.

Example: Testing whether a format is an RGB format:

 const char* formatString = "rgb8";
 CS::StructuredTextureFormat format = 
   CS::TextureFormatStrings::ConvertStructured (formatString);
 // Succeeds
 if (format.GetComponentMask() == CS::StructuredTextureFormat::compRGB)
 { ... }
 // Would also succeed for formatString = "bgr8", or even wierd formats like 
 // "gbr4", and more

char CS::StructuredTextureFormat::GetComponentSize ( int  n  )  const [inline, inherited]

Get size of the nth component.

Remarks:
If there is no such component 0 is returned. However, this return value does not imply that a component doesn not exist, as 0-sized components can be added by AddComponent(). Only the return values of GetComponent() and GetComponentCount() can be used for existance checkes.

Definition at line 233 of file textureformatstrings.h.

TextureFormat CS::StructuredTextureFormat::GetFormat (  )  const [inline, inherited]

Returns the basic storage type for this texture format.

See also:
Format

Definition at line 244 of file textureformatstrings.h.

const char* CS::StructuredTextureFormat::GetSpecial (  )  const [inline, inherited]

Return the special format string.

Definition at line 247 of file textureformatstrings.h.

bool CS::StructuredTextureFormat::IsValid (  )  [inline, inherited]

Returns whether the contained format is a valid texture format.

Definition at line 196 of file textureformatstrings.h.

void CS::StructuredTextureFormat::SetFormat ( TextureFormat  format  )  [inline, inherited]

Set the format.

Definition at line 171 of file textureformatstrings.h.

void CS::StructuredTextureFormat::SetSpecial ( const char *  special  )  [inline, inherited]

A special format (like '*dxt1').

Definition at line 153 of file textureformatstrings.h.

CS::StructuredTextureFormat::StructuredTextureFormat (  )  [inherited]

Construct an invalid texture format.


Variable Documentation

const size_t csRenderBufferComponentSizes[CS_BUFCOMP_TYPECOUNT] [static]

Initial value:

 
{
  sizeof (char), sizeof (unsigned char), 
  sizeof (short), sizeof (unsigned short),
  sizeof (int), sizeof (unsigned int),
  sizeof (float),
  sizeof (double)
}
Sizes of individual buffer components in bytes.

Definition at line 107 of file rndbuf.h.

Referenced by csRenderBuffer::GetElementDistance(), and CS::TriangleIndicesStream< T >::Next().


Generated for Crystal Space 1.2.1 by doxygen 1.5.3