CrystalSpace

Public API Reference

Geometry utilities


Namespaces

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

Classes

class  csBox2
 A bounding box in 2D space. More...
class  csBox2Int
 A 2D bounding box with integer coordinates. More...
class  csBox3
 A bounding box in 3D space. More...
class  csBoxClipper
 The csBoxClipper class is able to clip convex polygons to a rectangle (such as the screen). More...
class  csBSpline
 A B-spline. More...
class  csBSPTree
 This BSP-tree is a binary tree that organizes a triangle mesh. More...
class  csCatmullRomSpline
 A CatmullRom spline. More...
class  csChainHull2D
 This is Andrew's monotone chain 2D convex hull algorithm. More...
struct  csClipInfo
 Structure for use with ClipToPlane. More...
class  csClipper
 The csClipper class is an abstract parent to all 2D clipping objects. More...
struct  csCompressVertex
 This structure is used by csVector3Array::CompressVertices(). More...
class  csCoverageTile
 Coverage tile. More...
class  csCubicSpline
 A cubic spline. More...
class  csDIntersect3
 Some functions to perform various intersection calculations with 3D line segments. More...
class  csDMath3
 Various assorted 3D mathematical functions. More...
class  csDMatrix3
 A 3x3 matrix. More...
class  csDPlane
 A plane in 3D space. More...
class  csDSquaredDist
 Some functions to perform squared distance calculations. More...
class  csDVector3
 A 3D vector. More...
class  csEllipsoid
 This class represents an ellipsoid. More...
class  csFixed16
 Encapsulation of a 16.16 fixed-point number. More...
class  csFixed24
 Encapsulation of a 8.24 fixed-point number. More...
class  csFrustum
 A general frustum. More...
class  csGeomDebugHelper
 This is a class that does unit testing (and other debug stuff) for most of csgeom classes. More...
class  csIntersect2
 Some functions to perform various intersection calculations with 2D line segments. More...
class  csIntersect3
 Some functions to perform various intersection calculations with 3D line segments. More...
class  csKDTree
 A KD-tree. More...
class  csKDTreeChild
 A child in the KD-tree (usually some object). More...
struct  csLineOperation
class  csMath2
 Various functions in 2D, such as 2D vector functions. More...
class  csMath3
 Various assorted 3D mathematical functions. More...
class  csMatrix2
 A 2x2 matrix. More...
class  csMatrix3
 A 3x3 matrix. More...
struct  csMeshedPolygon
 A polygon. More...
class  csOBB
 Oriented bounding box (OBB). More...
class  csOBBFrozen
 Version of the csOBB with frozen corners (for optimization purposes). More...
class  csObjectModel
 Helper class to make it easier to implement iObjectModel in mesh objects. More...
class  csOrthoTransform
 A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix. More...
class  csPath
 A path in 3D. More...
class  csPlane2
 A plane in 2D space. More...
class  csPlane3
 A plane in 3D space. More...
class  csPoly2D
 The following class represents a general 2D polygon. More...
class  csPoly2DFactory
 This factory is responsible for creating csPoly2D objects or subclasses of csPoly2D. More...
class  csPoly2DPool
 This is an object pool which holds objects of type csPoly2D. More...
class  csPoly3D
 The following class represents a general 3D polygon. More...
class  csPolygonClipper
 The csPolygonClipper class can be used for clipping any polygon against any other convex polygon. More...
class  csPolygonMesh
 A convenience polygon mesh implementation that you can feed with vertices and polygons from another source. More...
class  csPolygonMeshBox
 A convenience polygon mesh implementation that represents a cube. More...
struct  csPolygonMeshEdge
 A definition of one edge. More...
class  csPolygonMeshTools
 A set of tools to work with iPolygonMesh instances. More...
class  csPolyIndexed
 The following class represents a general polygon. More...
class  csQuaternion
 Class for a quaternion. More...
class  csRect
 Rectangle class: simple class for manipulating 2D rectangles. More...
class  csRectRegion
 A rect region is a class that implements splittable 2d rectangles. More...
class  csReversibleTransform
 A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix. More...
class  csSegment2
 A 2D line segment. More...
class  csSegment3
 A 3D line segment. More...
class  csSolidSpace
 This structure keeps track of solid space. More...
class  csSphere
 This class represents a sphere. More...
class  csSpline
 A spline superclass. More...
class  csSquaredDist
 Some functions to perform squared distance calculations. More...
struct  csTestRectData
 A structure used by TestRectangle() and initialized by PrepareTestRectangle(). More...
class  csTextureTrans
 This is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector. More...
class  csTiledCoverageBuffer
 The tiled coverage Buffer. More...
class  csTransform
 A class which defines a transformation from one coordinate system to another. More...
struct  csTriangle
 A triangle. More...
class  csTriangleLODAlgo
 Algorithm class that calculates the cost of a vertex. More...
class  csTriangleLODAlgoEdge
 This subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost. More...
class  csTriangleMesh
 A mesh of triangles. More...
class  csTriangleMeshBox
 A convenience triangle mesh implementation that represents a cube. More...
struct  csTriangleMeshEdge
 A definition of one edge. More...
class  csTriangleMeshLOD
 A static class which performs the calculation of the best order to do the collapsing of a triangle mesh. More...
class  csTriangleMeshPointer
 A convenience triangle mesh which takes vertex and triangle pointers from another source. More...
class  csTriangleMeshPolyMesh
 This triangle mesh is a temporary class that takes a polygon mesh and wraps it so that it becomes a triangle mesh. More...
class  csTriangleMeshTools
 A set of tools to work with iTriangleMesh instances. More...
struct  csTriangleMinMax
 A triangle with minimum/maximum information on x. More...
class  csTriangleVertex
 The representation of a vertex in a triangle mesh. More...
class  csTriangleVertexCost
 The representation of a vertex in a triangle mesh. More...
class  csTriangleVertices
 A class which holds vertices and connectivity information for a triangle mesh. More...
class  csTriangleVerticesCost
 A class which holds vertices and connectivity information for a triangle mesh. More...
class  csTriangleVerticesSorted
 This class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices. More...
class  csVector2
 A 2D vector. More...
class  csVector3
 A 3D vector. More...
class  csVector3Array
 This is actually the same class as csPoly3D. More...
class  csVector4
 A 4D vector with "float" components. More...
class  csVector4T< T >
 A 4D vector with variable type components. More...
struct  csVertexStatus
 The clipper can output additional information about each vertex in output polygon. More...
class  csXRotMatrix3
 An instance of csMatrix3 that is initialized as a rotation about X. More...
class  csXScaleMatrix3
 An instance of csMatrix3 that is initialized to scale the X dimension. More...
class  csYRotMatrix3
 An instance of csMatrix3 that is initialized as a rotation about Y. More...
class  csYScaleMatrix3
 An instance of csMatrix3 that is initialized to scale the Y dimension. More...
class  csZRotMatrix3
 An instance of csMatrix3 that is initialized as a rotation about Z. More...
class  csZScaleMatrix3
 An instance of csMatrix3 that is initialized to scale the Z dimension. More...
struct  iClipper2D
 This interfaces represents a 2D clipper for polygons. More...
struct  iDecal
 A decal created by the decal manager. More...
struct  iDecalBuilder
 Interface for mesh objects to use to build decals for their mesh object. More...
struct  iDecalManager
 Creates and manages decals. More...
struct  iDecalTemplate
 Interface for a decal template which dictates the appearance of a newly created decal. More...
struct  iKDTreeObjectDescriptor
 If you implement this interface then you can give that to the KDtree. More...
struct  iKDTreeUserData
 The data type for user data to be attached to the KDTree. More...
struct  iObjectModel
 This interface represents data related to some geometry in object space. More...
struct  iObjectModelListener
 Implement this class if you're interested in hearing about when the object model changes. More...
struct  iPath
 A path in 3D. More...
struct  iPolygonMesh
 This interface reprents a mesh of polygons. More...
struct  iTriangleMesh
 This interface reprents a mesh of triangles. More...
struct  iTriangleMeshIterator
 Iterator to iterate over all data mesh ID's in an object model. More...

Corner indices

For csBox2::GetCorner().

enum  {
  CS_BOX_CORNER_xy = 0, CS_BOX_CORNER_xY = 1, CS_BOX_CORNER_Xy = 2, CS_BOX_CORNER_XY = 3,
  CS_BOX_CENTER2 = 4
}

Indices of edges for csBox2.

Index e+1 is opposite edge of e (with e even).

enum  {
  CS_BOX_EDGE_xy_Xy = 0, CS_BOX_EDGE_Xy_xy = 1, CS_BOX_EDGE_Xy_XY = 2, CS_BOX_EDGE_XY_Xy = 3,
  CS_BOX_EDGE_XY_xY = 4, CS_BOX_EDGE_xY_XY = 5, CS_BOX_EDGE_xY_xy = 6, CS_BOX_EDGE_xy_xY = 7
}

Indices of corner vertices for csBox3.

Used by csBox3::GetCorner().

enum  {
  CS_BOX_CORNER_xyz = 0, CS_BOX_CORNER_xyZ = 1, CS_BOX_CORNER_xYz = 2, CS_BOX_CORNER_xYZ = 3,
  CS_BOX_CORNER_Xyz = 4, CS_BOX_CORNER_XyZ = 5, CS_BOX_CORNER_XYz = 6, CS_BOX_CORNER_XYZ = 7,
  CS_BOX_CENTER3 = 8
}

Indices of faces for csBox3.

Used by csBox3::GetSide().

enum  {
  CS_BOX_SIDE_x = 0, CS_BOX_SIDE_X = 1, CS_BOX_SIDE_y = 2, CS_BOX_SIDE_Y = 3,
  CS_BOX_SIDE_z = 4, CS_BOX_SIDE_Z = 5, CS_BOX_INSIDE = 6
}

Indices of edges for csBox3.

Index e+1 is opposite edge of e (with e even).

enum  {
  CS_BOX_EDGE_Xyz_xyz = 0, CS_BOX_EDGE_xyz_Xyz = 1, CS_BOX_EDGE_xyz_xYz = 2, CS_BOX_EDGE_xYz_xyz = 3,
  CS_BOX_EDGE_xYz_XYz = 4, CS_BOX_EDGE_XYz_xYz = 5, CS_BOX_EDGE_XYz_Xyz = 6, CS_BOX_EDGE_Xyz_XYz = 7,
  CS_BOX_EDGE_Xyz_XyZ = 8, CS_BOX_EDGE_XyZ_Xyz = 9, CS_BOX_EDGE_XyZ_XYZ = 10, CS_BOX_EDGE_XYZ_XyZ = 11,
  CS_BOX_EDGE_XYZ_XYz = 12, CS_BOX_EDGE_XYz_XYZ = 13, CS_BOX_EDGE_XYZ_xYZ = 14, CS_BOX_EDGE_xYZ_XYZ = 15,
  CS_BOX_EDGE_xYZ_xYz = 16, CS_BOX_EDGE_xYz_xYZ = 17, CS_BOX_EDGE_xYZ_xyZ = 18, CS_BOX_EDGE_xyZ_xYZ = 19,
  CS_BOX_EDGE_xyZ_xyz = 20, CS_BOX_EDGE_xyz_xyZ = 21, CS_BOX_EDGE_xyZ_XyZ = 22, CS_BOX_EDGE_XyZ_xyZ = 23
}

Polygon-to-Frustum relations

Return values for csFrustum::Classify.

The routine makes a difference whenever a polygon is fully outside the frustum, fully inside, fully covers the frustum or is partly inside, partly outside.

enum  { CS_FRUST_OUTSIDE = 0, CS_FRUST_INSIDE = 1, CS_FRUST_COVERED = 2, CS_FRUST_PARTIAL = 3 }

Clipper return codes

The clipper routines return one of CS_CLIP_OUTSIDE, CS_CLIP_INSIDE, CS_CLIP_CLIPPED so that we can distinguish between the cases when input polygon is completely outside the clipping polygon (thus it is not visible), completely inside the clipping polygon (thus it has not changed) and partially outside, partially inside (thus it was clipped).

enum  { CS_CLIP_OUTSIDE = 0, CS_CLIP_CLIPPED = 1, CS_CLIP_INSIDE = 2 }

Additional vertex informations

enum  { CS_VERTEX_ORIGINAL = 0, CS_VERTEX_ONEDGE = 1, CS_VERTEX_INSIDE = 2 }
 Clipped vertex type. More...

Flags for iPolygonMesh

enum  {
  CS_POLYMESH_CLOSED = 1, CS_POLYMESH_NOTCLOSED = 2, CS_POLYMESH_CONVEX = 4, CS_POLYMESH_NOTCONVEX = 8,
  CS_POLYMESH_DEFORMABLE = 16, CS_POLYMESH_TRIANGLEMESH = 32
}

Flags for iTriangleMesh

enum  {
  CS_TRIMESH_CLOSED = 1, CS_TRIMESH_NOTCLOSED = 2, CS_TRIMESH_CONVEX = 4, CS_TRIMESH_NOTCONVEX = 8,
  CS_TRIMESH_DEFORMABLE = 16
}
bool csFinite (double d)
 Checks if a double-precision floating point value is finite.
bool csFinite (float f)
 Checks if a floating point value is finite.
bool csNaN (double d)
 Checks if a double-precision floating point value is not-a-number.
bool csNaN (float f)
 Checks if a floating point value is not-a-number.
bool csNormal (double d)
 Checks if a double-precision floating point value is normal.
bool csNormal (float f)
 Checks if a floating point value is normal (not infinite or nan).

Defines

#define ABS(x)   ((x)<0?-(x):(x))
#define CS_BOUNDINGBOX_MAXVALUE   1000000000.
 The maximum value that a coordinate in the bounding box can use.
#define MAX_OUTPUT_VERTICES   64
 Maximal number of vertices in output (clipped) polygons.

Typedefs

typedef void(* csAAPFCBBox )(int x, int y, int w, int h, void *arg)
 "Draw a box" callback
typedef void(* csAAPFCBPixel )(int x, int y, float area, void *arg)
 Callback functions used by csAntialiasedPolyFill.
typedef bool( csKDTreeVisitFunc )(csKDTree *treenode, void *userdata, uint32 timestamp, uint32 &frustum_mask)
 A callback function for visiting a KD-tree node.
typedef
CS::SubRectangles::SubRect 
csSubRect
typedef CS::SubRectangles csSubRectangles
typedef uint32 csTileCol

Enumerations

enum  { CS_KDTREE_AXISINVALID = -1, CS_KDTREE_AXISX = 0, CS_KDTREE_AXISY = 1, CS_KDTREE_AXISZ = 2 }
enum  { CS_POLY_IN = 1, CS_POLY_ON = 0, CS_POLY_OUT = -1 }
enum  { CS_POL_SAME_PLANE = 0, CS_POL_FRONT = 1, CS_POL_BACK = 2, CS_POL_SPLIT_NEEDED = 3 }
 Values returned by csPoly3D::Classify. More...
enum  {
  SHIFT_TILECOL = 6, SHIFT_TILEROW = 5, NUM_TILECOL = (1<<SHIFT_TILECOL), NUM_TILEROW = (1<<SHIFT_TILEROW),
  NUM_DEPTHROW = (NUM_TILEROW/8), NUM_DEPTHCOL = (NUM_TILECOL/8), NUM_DEPTH = (NUM_DEPTHROW * NUM_DEPTHCOL), TILECOL_EMPTY = 0,
  TILECOL_FULL = ((uint32)~0), TEST_OCCLUDER_QUALITY = 1, TB_DUMMY = -1
}
enum  { OP_LINE = 1, OP_VLINE = 2, OP_FULLVLINE = 3 }
enum  {
  CS_AXIS_NONE = -1, CS_AXIS_X = 0, CS_AXIS_Y = 1, CS_AXIS_Z = 2,
  CS_AXIS_W = 3
}
 Constants for axes. More...
enum  csClipType { CS_CLIPINFO_ORIGINAL = 0, CS_CLIPINFO_ONEDGE = 1, CS_CLIPINFO_INSIDE = 2 }

Functions

void csAntialiasedPolyFill (csVector2 *iVertices, int iVertexCount, void *iArg, csAAPFCBPixel iPutPixel, csAAPFCBBox iDrawBox=0)
 This function takes a 2D polygon and splits it against a integer grid into many sub-polygons.
template<class T>
csClamp (const T &a, T max, T min)
 Clamp a between max and min.
template<class T, class Tfactor>
csLerp (const T &a, const T &b, const Tfactor &f)
 Performs a linear interpolation between a and b with the factor f.
template<class T>
const T & csMax (const T &a, const T &b)
 Returns bigger of a and b.
template<class T>
const T & csMin (const T &a, const T &b)
 Returns smaller of a and b.
template<class T>
csSmoothStep (const T &a, T max, T min)
 Performs a smooth interpolation of a on range min to max.
template<class T, class U>
void csSort (T &a, T &b, U &x, U &y)
 Sort a and b in order of size.
template<class T>
void csSort (T &a, T &b)
 Sort a and b in order of size.
template<class T>
csSquare (const T &x)
 Returns the square of the argument.
double dSqr (double d)

Define Documentation

#define CS_BOUNDINGBOX_MAXVALUE   1000000000.

The maximum value that a coordinate in the bounding box can use.

This is considered the 'infinity' value used for empty bounding boxes.

Definition at line 49 of file box.h.

Referenced by csBox3::StartBoundingBox(), and csBox2::StartBoundingBox().

#define MAX_OUTPUT_VERTICES   64

Maximal number of vertices in output (clipped) polygons.

Definition at line 36 of file clip2d.h.


Typedef Documentation

typedef void(* csAAPFCBBox)(int x, int y, int w, int h, void *arg)

"Draw a box" callback

Definition at line 46 of file polyaa.h.

typedef void(* csAAPFCBPixel)(int x, int y, float area, void *arg)

Callback functions used by csAntialiasedPolyFill.

We have two types of callback: one for "drawing a pixel", the area of the pixel is passed to the callback routine. The second routine is for "drawing a box", the area of every "pixel" is always 1.0. "Draw one pixel" callback

Definition at line 44 of file polyaa.h.

typedef bool( csKDTreeVisitFunc)(csKDTree *treenode, void *userdata, uint32 timestamp, uint32 &frustum_mask)

A callback function for visiting a KD-tree node.

If this function returns true the traversal will continue. Otherwise Front2Back() will stop.

This function is itself responsible for calling Distribute() on the given treenode to ensure that the objects in this node are properly distributed to the children. If the function doesn't want or need this functionality it doesn't have to do Distribute().

If this function decides to process the given node then it is also responsible for checking the timestamp of every child in this node with the timestamp given to this function. If this timestamp is different the child has not been processed before. This function should then update the timestamp of the child. If this is not done then some objects will be encountered multiple times. In some cases this may not be a problem or even desired.

'frustum_mask' can be modified by this function to reduce the number of plane tests (for frustum culling) that have to occur for children of this node.

Definition at line 89 of file kdtree.h.


Enumeration Type Documentation

anonymous enum

Enumerator:
CS_BOX_CORNER_xy  min X, min Y
CS_BOX_CORNER_xY  min X, max Y
CS_BOX_CORNER_Xy  max X, min Y
CS_BOX_CORNER_XY  max X, max Y
CS_BOX_CENTER2  center

Definition at line 54 of file box.h.

anonymous enum

Enumerator:
CS_BOX_EDGE_xy_Xy  from min X, min Y to max X, min Y
CS_BOX_EDGE_Xy_xy  from max X, min Y to min X, min Y
CS_BOX_EDGE_Xy_XY  from max X, min Y to max X, max Y
CS_BOX_EDGE_XY_Xy  from max X, max Y to max X, min Y
CS_BOX_EDGE_XY_xY  from max X, max Y to min X, max Y
CS_BOX_EDGE_xY_XY  from min X, max Y to max X, max Y
CS_BOX_EDGE_xY_xy  from min X, max Y to min X, min Y
CS_BOX_EDGE_xy_xY  from min X, min Y to min X, max Y

Definition at line 73 of file box.h.

anonymous enum

Enumerator:
CS_KDTREE_AXISINVALID 
CS_KDTREE_AXISX 
CS_KDTREE_AXISY 
CS_KDTREE_AXISZ 

Definition at line 143 of file kdtree.h.

anonymous enum

Enumerator:
CS_POLY_IN 
CS_POLY_ON 
CS_POLY_OUT 

Definition at line 36 of file plane2.h.

anonymous enum

Values returned by csPoly3D::Classify.

Enumerator:
CS_POL_SAME_PLANE  Poly is on same plane.
CS_POL_FRONT  Poly is completely in front of the given plane.
CS_POL_BACK  Poly is completely back of the given plane.
CS_POL_SPLIT_NEEDED  Poly intersects with plane.

Definition at line 38 of file poly3d.h.

anonymous enum

Enumerator:
SHIFT_TILECOL 
SHIFT_TILEROW 
NUM_TILECOL 
NUM_TILEROW 
NUM_DEPTHROW 
NUM_DEPTHCOL 
NUM_DEPTH 
TILECOL_EMPTY 
TILECOL_FULL 
TEST_OCCLUDER_QUALITY 
TB_DUMMY 

Definition at line 48 of file tcovbuf.h.

anonymous enum

Enumerator:
OP_LINE 
OP_VLINE 
OP_FULLVLINE 

Definition at line 100 of file tcovbuf.h.

anonymous enum

Enumerator:
CS_BOX_CORNER_xyz  min X, min Y, min Z
CS_BOX_CORNER_xyZ  min X, min Y, max Z
CS_BOX_CORNER_xYz  min X, max Y, min Z
CS_BOX_CORNER_xYZ  min X, max Y, max Z
CS_BOX_CORNER_Xyz  min X, min Y, min Z
CS_BOX_CORNER_XyZ  max X, min Y, max Z
CS_BOX_CORNER_XYz  max X, max Y, min Z
CS_BOX_CORNER_XYZ  max X, max Y, max Z
CS_BOX_CENTER3  center

Definition at line 485 of file box.h.

anonymous enum

Constants for axes.

Can also be used as indices to csVector2::operator[], csVector3::operator[] and csVector4::operator[] for more readability.

Enumerator:
CS_AXIS_NONE  Invalid axis.
CS_AXIS_X  X axis.
CS_AXIS_Y  Y axis.
CS_AXIS_Z  Z axis.
CS_AXIS_W  W axis.

Definition at line 39 of file vector3.h.

anonymous enum

Enumerator:
CS_BOX_SIDE_x  min X
CS_BOX_SIDE_X  max X
CS_BOX_SIDE_y  min Y
CS_BOX_SIDE_Y  max Y
CS_BOX_SIDE_z  min Z
CS_BOX_SIDE_Z  max Z
CS_BOX_INSIDE  inside

Definition at line 512 of file box.h.

anonymous enum

Enumerator:
CS_BOX_EDGE_Xyz_xyz  from max X, min Y, min Z to min X, min Y, min Z
CS_BOX_EDGE_xyz_Xyz  from min X, min Y, min Z to max X, min Y, min Z
CS_BOX_EDGE_xyz_xYz  from min X, min Y, min Z to min X, max Y, min Z
CS_BOX_EDGE_xYz_xyz  from min X, max Y, min Z to min X, min Y, min Z
CS_BOX_EDGE_xYz_XYz  from min X, max Y, min Z to max X, max Y, min Z
CS_BOX_EDGE_XYz_xYz  from max X, max Y, min Z to min X, max Y, min Z
CS_BOX_EDGE_XYz_Xyz  from max X, max Y, min Z to max X, min Y, min Z
CS_BOX_EDGE_Xyz_XYz  from max X, min Y min Z to max X, max Y, min Z
CS_BOX_EDGE_Xyz_XyZ  from max X, min Y, min Z to max X, min Y, max Z
CS_BOX_EDGE_XyZ_Xyz  from max X, min Y, max Z to max X, min Y, min Z
CS_BOX_EDGE_XyZ_XYZ  from max X, min Y, max Z to max X, max Y, max Z
CS_BOX_EDGE_XYZ_XyZ  from max X, max Y, max Z to max X, min Y, max Z
CS_BOX_EDGE_XYZ_XYz  from max X, max Y, max Z to max X, max Y, min Z
CS_BOX_EDGE_XYz_XYZ  from max X, max Y, min Z to max X, max Y, max Z
CS_BOX_EDGE_XYZ_xYZ  from max X, max Y, max Z to min X, max Y, max Z
CS_BOX_EDGE_xYZ_XYZ  from min X, max Y, max Z to max X, max Y, max Z
CS_BOX_EDGE_xYZ_xYz  from min X, max Y, max Z to min X, max Y, min Z
CS_BOX_EDGE_xYz_xYZ  from min X, max Y, min Z to min X, max Y, max Z
CS_BOX_EDGE_xYZ_xyZ  from min X, max Y, max Z to min X, min Y, max Z
CS_BOX_EDGE_xyZ_xYZ  from min X, min Y, max Z to min X, max Y, max Z
CS_BOX_EDGE_xyZ_xyz  from min X, min Y, max Z to min X, min Y, min Z
CS_BOX_EDGE_xyz_xyZ  from min X, min Y, min Z to min X, min Y, max Z
CS_BOX_EDGE_xyZ_XyZ  from min X, min Y, max Z to max X, min Y, max Z
CS_BOX_EDGE_XyZ_xyZ  from max X, min Y, max Z to min X, min Y, max Z

Definition at line 535 of file box.h.

anonymous enum

Enumerator:
CS_FRUST_OUTSIDE  The polygon is fully outside frustum.
CS_FRUST_INSIDE  The polygon is fully inside frustum.
CS_FRUST_COVERED  The polygon fully covers the frustum.
CS_FRUST_PARTIAL  The polygon is partially inside frustum.

Definition at line 46 of file frustum.h.

anonymous enum

Enumerator:
CS_CLIP_OUTSIDE  The input polygon is completely outside of clipper polygon.
CS_CLIP_CLIPPED  The input polygon was partially inside, partially outside.
CS_CLIP_INSIDE  The input polygon is completely inside (thus has not changed).

Definition at line 46 of file clip2d.h.

anonymous enum

Clipped vertex type.

Enumerator:
CS_VERTEX_ORIGINAL  The output vertex is one of the input vertices.
CS_VERTEX_ONEDGE  The output vertex is located on one of the edges of the original polygon.
CS_VERTEX_INSIDE  The output vertex is located somewhere inside the original polygon.

Definition at line 79 of file clip2d.h.

anonymous enum

Enumerator:
CS_POLYMESH_CLOSED  The object is closed, if set.

With closed we mean that if you run a beam of light through the object (through any point outside the mesh to another point outside) it will always hit an even amount of faces (one going in, and one going out). If you don't set CLOSED or NOTCLOSED then the state is not known and the engine may test it if it wants.

CS_POLYMESH_NOTCLOSED  The object is not closed, if set.

This is the opposite of CS_POLYMESH_CLOSED. Use this flag if you are absolutely certain that the object is not closed. The engine will not attempt to test if the object is really closed or not. If you don't set CLOSED or NOTCLOSED then the state is not known and the engine may test it if it wants.

CS_POLYMESH_CONVEX  The object is convex, if set.

With convex we mean that if you run a beam of light through the object (through any point outside the mesh to another point outside) it will always hit exactly two faces (one going in, and one going out). If you don't set CONVEX or NOTCONVEX then the state is not known and the engine may test it if it wants.

CS_POLYMESH_NOTCONVEX  The object is not convex, if set.

This is the opposite of CS_POLYMESH_CONVEX. Use this flag if you are absolutely certain that the object is not convex. The engine will not attempt to test if the object is really convex or not. If you don't set CONVEX or NOTCONVEX then the state is not known and the engine may test it if it wants.

CS_POLYMESH_DEFORMABLE  Set this flag if the polygon mesh is deformable.
CS_POLYMESH_TRIANGLEMESH  Set this flag if the native or desired format of the polygon mesh is a triangle mesh.

If this flag is set it means that GetTriangles() is very cheap. The presence of this flag does not mean that GetPolygons() will not work.

Definition at line 37 of file polymesh.h.

anonymous enum

Enumerator:
CS_TRIMESH_CLOSED  The object is closed, if set.

With closed we mean that if you run a beam of light through the object (through any point outside the mesh to another point outside) it will always hit an even amount of faces (one going in, and one going out). If you don't set CLOSED or NOTCLOSED then the state is not known and the engine may test it if it wants.

CS_TRIMESH_NOTCLOSED  The object is not closed, if set.

This is the opposite of CS_TRIMESH_CLOSED. Use this flag if you are absolutely certain that the object is not closed. The engine will not attempt to test if the object is really closed or not. If you don't set CLOSED or NOTCLOSED then the state is not known and the engine may test it if it wants.

CS_TRIMESH_CONVEX  The object is convex, if set.

With convex we mean that if you run a beam of light through the object (through any point outside the mesh to another point outside) it will always hit exactly two faces (one going in, and one going out). If you don't * set CONVEX or NOTCONVEX then the state is not known and the engine may test it if it wants.

CS_TRIMESH_NOTCONVEX  The object is not convex, if set.

This is the opposite of CS_TRIMESH_CONVEX. Use this flag if you are absolutely certain that the object is not convex. The engine will not attempt to test if the object is really convex or not. If you don't set CONVEX or NOTCONVEX then the state is not known and the engine may test it if it wants.

CS_TRIMESH_DEFORMABLE  Set this flag if the triangle mesh is deformable.

Definition at line 37 of file trimesh.h.

enum csClipType

Enumerator:
CS_CLIPINFO_ORIGINAL 
CS_CLIPINFO_ONEDGE 
CS_CLIPINFO_INSIDE 

Definition at line 59 of file frustum.h.


Function Documentation

void csAntialiasedPolyFill ( csVector2 iVertices,
int  iVertexCount,
void *  iArg,
csAAPFCBPixel  iPutPixel,
csAAPFCBBox  iDrawBox = 0 
)

This function takes a 2D polygon and splits it against a integer grid into many sub-polygons.

Then the area of each subpolygon is computed and a callback function is called, with the area of sub-polygon passed as argument.

template<class T>
T csClamp ( const T &  a,
max,
min 
) [inline]

Clamp a between max and min.

Definition at line 80 of file math.h.

References csMax(), and csMin().

Referenced by csShaderVariable::GetValue().

bool csFinite ( double  d  ) 

Checks if a double-precision floating point value is finite.

Definition at line 144 of file math.h.

bool csFinite ( float  f  ) 

Checks if a floating point value is finite.

Definition at line 127 of file math.h.

Referenced by csNormal().

template<class T, class Tfactor>
T csLerp ( const T &  a,
const T &  b,
const Tfactor &  f 
) [inline]

Performs a linear interpolation between a and b with the factor f.

Definition at line 111 of file math.h.

template<class T>
const T& csMax ( const T &  a,
const T &  b 
) [inline]

Returns bigger of a and b.

If they are equal, a or b can be returned.

Definition at line 35 of file math.h.

Referenced by csBox3::AddBoundingBox(), csClamp(), and csLinearAttenuation::operator()().

template<class T>
const T& csMin ( const T &  a,
const T &  b 
) [inline]

Returns smaller of a and b.

If they are equal, a or b can be returned.

Definition at line 45 of file math.h.

Referenced by csBox3::AddBoundingBox(), csClamp(), and csFmtDefaultWriter< T >::Put().

bool csNaN ( double  d  ) 

Checks if a double-precision floating point value is not-a-number.

Definition at line 175 of file math.h.

bool csNaN ( float  f  ) 

Checks if a floating point value is not-a-number.

Definition at line 160 of file math.h.

Referenced by csNormal().

bool csNormal ( double  d  ) 

Checks if a double-precision floating point value is normal.

Definition at line 202 of file math.h.

References csFinite(), and csNaN().

bool csNormal ( float  f  ) 

Checks if a floating point value is normal (not infinite or nan).

Definition at line 189 of file math.h.

References csFinite(), and csNaN().

template<class T>
T csSmoothStep ( const T &  a,
max,
min 
) [inline]

Performs a smooth interpolation of a on range min to max.

Returns:
Smooth interporlated value if min < a < max, and 0 resp. 1 if a is smaller than min resp. larger than max.

Definition at line 91 of file math.h.

Referenced by csSpotLightProc< AttenuationProc >::PerVertex::PerVertex().

template<class T, class U>
void csSort ( T &  a,
T &  b,
U &  x,
U &  y 
) [inline]

Sort a and b in order of size.

If swapping them, also swap x and y

Definition at line 66 of file math.h.

References CS::Swap().

template<class T>
void csSort ( T &  a,
T &  b 
) [inline]

Sort a and b in order of size.

Definition at line 55 of file math.h.

References CS::Swap().

template<class T>
T csSquare ( const T &  x  )  [inline]

Returns the square of the argument.

Definition at line 120 of file math.h.

Referenced by csSphere::TestIntersect().


Generated for Crystal Space 1.2.1 by doxygen 1.5.3