CrystalSpace

Public API Reference

3D
[Graphics]

Classes

struct  csAlphaMode
 Describes how to deal with alpha values in textures. More...
class  csRenderBufferHolder
 Holder of standard renderbuffers. 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...

Namespaces

namespace  CS
 

Main namespace for CrystalSpace.


Defines

#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.

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_NORMALIZED = 8, CS_BUFCOMP_BYTE_NORM = CS_BUFCOMP_BYTE | CS_BUFCOMP_NORMALIZED, CS_BUFCOMP_UNSIGNED_BYTE_NORM, CS_BUFCOMP_SHORT_NORM,
  CS_BUFCOMP_UNSIGNED_SHORT_NORM, CS_BUFCOMP_INT_NORM = CS_BUFCOMP_INT | CS_BUFCOMP_NORMALIZED, CS_BUFCOMP_UNSIGNED_INT_NORM
}
 

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_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
}
 

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 or 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.
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.

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_CLEARZBUFFER   0x00000010
 Clear Z-buffer ?
#define CSDRAW_CLEARSCREEN   0x00000020
 Clear frame buffer ?

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_TOPLEVEL   1
 Clipper is top-level.
#define CS_CLIPPER_REQUIRED   2
 Clipper is required.

Clipping requirement for DrawTriangleMesh



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

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_FLAG_BLENDOP_ALPHA   (0x08000000)
 When blending with a blending operation, signinify that separate factors for the alpha channel are present.
#define CS_MIXMODE_TYPE_MESH   (0x80000000)
 Use the mix mode of the mesh mix mode.
#define CS_MIXMODE_TYPE_MASK   (0xc0000000)
 Bit mask to extract the type from a mixmode specifier.

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_ENABLE   (0x10000000)
 Unconditionally enable alpha test.
#define CS_MIXMODE_ALPHATEST_DISABLE   (0x20000000)
 Unconditionally disable 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_SRC(mode)   ((mode >> 20) & CS_MIXMODE_FACT_MASK)
 Helper macro to extract the srcFactor from a blending op mixmode.
#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_BLEND_ALPHA(Src, Dst)
 Helper macro to construct alpha factoes for a blending operation mixmode Src and Dst are blending op factors , however sans the CS_MIXMODE_FACT_ prefix.
#define CS_MIXMODE_BLENDOP_ALPHA_SRC(mode)   ((mode >> 12) & CS_MIXMODE_FACT_MASK)
 Helper macro to extract the alpha srcFactor from a blending op mixmode.
#define CS_MIXMODE_BLENDOP_ALPHA_DST(mode)   ((mode >> 8) & CS_MIXMODE_FACT_MASK)
 Helper macro to extract the alpha dstFactor from a blending op mixmode.

Mix mode: Default modes

A set of commonly used mix modes.



#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_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_ADD   (CS_MIXMODE_BLEND(ONE, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Additive blending. Formula: =SRC+DST
#define CS_FX_ALPHA
 Alpha blending.
#define CS_FX_TRANSPARENT   (CS_MIXMODE_BLEND(ZERO, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Transparent blending (keep framebuffer unmodified).
#define CS_FX_DESTALPHAADD   (CS_MIXMODE_BLEND(DSTALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiply source color with destination alpha and add.
#define CS_FX_SRCALPHAADD   (CS_MIXMODE_BLEND(SRCALPHA, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)
 Multiply source color with source alpha and add.
#define CS_FX_PREMULTALPHA
 Multiply destination color with inverse source alpha and add source color.
#define CS_FX_MESH   (CS_MIXMODE_TYPE_MESH)
 Use the mix mode of the mesh mix mode.
#define CS_FX_FLAT   (0x04000000)
 Flat shading flag.
#define CS_FX_MASK_ALPHA   (0x000000FF)
 Mixmode alpha part.
#define CS_FX_MASK_MIXMODE   (0xf8ffff00)
 Bit mask for bits relevant to mix mode comparison; contains type, alpha test flags and blending op factors.

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).

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_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_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.
#define CS_TEXTURE_NOFILTER   0x00000020
 This texture will not be filtered, even if texture filtering is available.
#define CS_TEXTURE_NPOTS   0x00000040
 Store texture as non-power-of-two sized (NPOTS) if possible.
#define CS_TEXTURE_SCALE_UP   0x00000080
 Texture resizing control flag.
#define CS_TEXTURE_SCALE_DOWN   0x00000100
 Texture resizing control flag.

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 113 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 107 of file graph3d.h.

#define CS_CLIPPER_NONE   -1

There is no clipper.

Definition at line 86 of file graph3d.h.

#define CS_CLIPPER_OPTIONAL   0

Clipper is optional.

Definition at line 90 of file graph3d.h.

#define CS_CLIPPER_REQUIRED   2

Clipper is required.

Definition at line 98 of file graph3d.h.

#define CS_CLIPPER_TOPLEVEL   1

Clipper is top-level.

Definition at line 94 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 370 of file graph3d.h.

#define CS_FX_ALPHA
Value:
(CS_MIXMODE_BLEND(SRCALPHA, SRCALPHA_INV) \
    | CS_MIXMODE_BLEND_ALPHA(ONE, 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 377 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 362 of file graph3d.h.

#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 391 of file graph3d.h.

#define CS_FX_FLAT   (0x04000000)

Flat shading flag.

Definition at line 418 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 428 of file graph3d.h.

#define CS_FX_MASK_MIXMODE   (0xf8ffff00)

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

Definition at line 434 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 415 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 364 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 367 of file graph3d.h.

#define CS_FX_PREMULTALPHA
Value:
(CS_MIXMODE_BLEND(ONE, SRCALPHA_INV) | \
    CS_MIXMODE_BLEND_ALPHA(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 408 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 440 of file graph3d.h.

#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 443 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 397 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 385 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 298 of file graph3d.h.

#define CS_MIXMODE_ALPHATEST_DISABLE   (0x20000000)

Unconditionally disable alpha test.

Definition at line 302 of file graph3d.h.

#define CS_MIXMODE_ALPHATEST_ENABLE   (0x10000000)

Unconditionally enable alpha test.

Definition at line 300 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 305 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 320 of file graph3d.h.

#define CS_MIXMODE_BLEND_ALPHA (   Src,
  Dst 
)
Value:
(CS_MIXMODE_FLAG_BLENDOP_ALPHA                                  \
  | (CS_MIXMODE_FACT_ ## Src << 12) | (CS_MIXMODE_FACT_ ## Dst << 8))

Helper macro to construct alpha factoes for 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)
   | CS_MIXMODE_BLEND_ALPHA(ONE, SRCALPHA_INV);

will generate a blending operation for alpha blending with the written destination alpha values suitable for use for premultiplied alpha blending.

Definition at line 340 of file graph3d.h.

#define CS_MIXMODE_BLENDOP_ALPHA_DST (   mode  )     ((mode >> 8) & CS_MIXMODE_FACT_MASK)

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

Definition at line 346 of file graph3d.h.

#define CS_MIXMODE_BLENDOP_ALPHA_SRC (   mode  )     ((mode >> 12) & CS_MIXMODE_FACT_MASK)

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

Definition at line 344 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 326 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 324 of file graph3d.h.

#define CS_MIXMODE_FLAG_BLENDOP_ALPHA   (0x08000000)

When blending with a blending operation, signinify that separate factors for the alpha channel are present.

Definition at line 246 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 232 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 241 of file graph3d.h.

#define CS_MIXMODE_TYPE_MASK   (0xc0000000)

Bit mask to extract the type from a mixmode specifier.

Definition at line 254 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 251 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 72 of file graph3d.h.

#define CSDRAW_3DGRAPHICS   0x00000002

We're going to draw 3D graphics.

Definition at line 74 of file graph3d.h.

#define CSDRAW_CLEARSCREEN   0x00000020

Clear frame buffer ?

Definition at line 78 of file graph3d.h.

#define CSDRAW_CLEARZBUFFER   0x00000010

Clear Z-buffer ?

Definition at line 76 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 258 of file graph3d.h.

Type of components.

Enumerator:
CS_BUFCOMP_BYTE 

Signed byte.

CS_BUFCOMP_UNSIGNED_BYTE 

Unsigned byte.

CS_BUFCOMP_SHORT 

Signed short.

CS_BUFCOMP_UNSIGNED_SHORT 

Unsigned short.

CS_BUFCOMP_INT 

Signed integer.

CS_BUFCOMP_UNSIGNED_INT 

Unsigned integer.

CS_BUFCOMP_FLOAT 

Float.

CS_BUFCOMP_DOUBLE 

Double.

CS_BUFCOMP_NORMALIZED 

Normalization flag.

CS_BUFCOMP_BYTE_NORM 

Signed byte, normalized to [-1;1].

CS_BUFCOMP_UNSIGNED_BYTE_NORM 

Unsigned byte, normalized to [0;1].

CS_BUFCOMP_SHORT_NORM 

Signed short, normalized to [-1;1].

CS_BUFCOMP_UNSIGNED_SHORT_NORM 

Unsigned short, normalized to [0;1].

CS_BUFCOMP_INT_NORM 

Signed integer, normalized to [-1;1].

CS_BUFCOMP_UNSIGNED_INT_NORM 

Unsigned integer, normalized to [0;1].

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 105 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_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 266 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 312 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.

Definition at line 160 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 117 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 or 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, but not if an additional component such as alpha is
 // present.
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),

  sizeof (char), sizeof (unsigned char), 
  sizeof (short), sizeof (unsigned short),
  sizeof (int), sizeof (unsigned int)
}

Sizes of individual buffer components in bytes.

Definition at line 135 of file rndbuf.h.


Generated for Crystal Space 1.4.1 by doxygen 1.7.1