Public API Reference

ivideo/graph3d.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2001 by Jorrit Tyberghein
                       2004 by Marten Svanfeldt
    Written by Jorrit Tyberghein, Dan Ogles, and Gary Clark.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IVIDEO_GRAPH3D_H__
#define __CS_IVIDEO_GRAPH3D_H__

#include "csutil/scf.h"

#include "csgeom/transfrm.h"
#include "csutil/flags.h"
#include "csutil/strset.h"

#include "ivideo/rndbuf.h"

struct iClipper2D;
struct iGraphics2D;
struct iHalo;
struct iRenderBuffer;
struct iRendererLightmap;
struct iShader;
struct iShaderVariableContext;
struct iShaderVarStack;
struct iTextureHandle;
struct iTextureManager;

class csRect;
class csPlane3;
class csShaderVariable;
class csVector2;
class csVector3;
class csVector4;


struct csCoreRenderMesh;
struct csRenderMeshModes;
class csRenderBufferHolder;



#define CSDRAW_2DGRAPHICS   0x00000001
#define CSDRAW_3DGRAPHICS   0x00000002
#define CSDRAW_CLEARZBUFFER 0x00000010
#define CSDRAW_CLEARSCREEN  0x00000020

#define CS_CLIPPER_NONE -1

#define CS_CLIPPER_OPTIONAL 0

#define CS_CLIPPER_TOPLEVEL 1

#define CS_CLIPPER_REQUIRED 2

#define CS_CLIP_NOT 0

#define CS_CLIP_NEEDED 1


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

// @@@ Keep in sync with values below
// \todo Document me!
#define CS_VATTRIB_SPECIFIC_FIRST    0
#define CS_VATTRIB_SPECIFIC_LAST    15
#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))

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

#define CS_MIXMODE_TYPE_AUTO (0x00000000)

#define CS_MIXMODE_TYPE_BLENDOP (0x40000000)

#define CS_MIXMODE_TYPE_MESH (0x80000000)

#define CS_MIXMODE_TYPE_MASK (0xc0000000)


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

#define CS_MIXMODE_ALPHATEST_AUTO (0x00000000)
#define CS_MIXMODE_ALPHATEST_ENABLE (0x10000000)
#define CS_MIXMODE_ALPHATEST_DISABLE (0x20000000)
  
#define CS_MIXMODE_ALPHATEST_MASK (0x30000000)

#define CS_MIXMODE_BLEND(Src, Dst)                                      \
  (CS_MIXMODE_TYPE_BLENDOP                                              \
  | (CS_MIXMODE_FACT_ ## Src << 20) | (CS_MIXMODE_FACT_ ## Dst << 16))
#define CS_MIXMODE_BLENDOP_SRC(mode)    ((mode >> 20) & CS_MIXMODE_FACT_MASK)
#define CS_MIXMODE_BLENDOP_DST(mode)    ((mode >> 16) & CS_MIXMODE_FACT_MASK)

#define CS_FX_COPY (CS_MIXMODE_TYPE_AUTO | CS_MIXMODE_ALPHATEST_AUTO)
#define CS_FX_MULTIPLY \
    (CS_MIXMODE_BLEND(DSTCOLOR, ZERO) | CS_MIXMODE_ALPHATEST_DISABLE)
#define CS_FX_MULTIPLY2 \
    (CS_MIXMODE_BLEND(DSTCOLOR, SRCCOLOR) | CS_MIXMODE_ALPHATEST_DISABLE)
#define CS_FX_ADD \
    (CS_MIXMODE_BLEND(ONE, ONE) | CS_MIXMODE_ALPHATEST_DISABLE)

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

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

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

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

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

#define CS_FX_MESH (CS_MIXMODE_TYPE_MESH)
  
#define CS_FX_FLAT (0x04000000)

#define CS_FX_MASK_ALPHA (0x000000FF)
  
#define CS_FX_MASK_MIXMODE (0xf0ff0000)


#define CS_FX_SETALPHA(alpha) \
  (CS_FX_ALPHA | uint ((alpha) * CS_FX_MASK_ALPHA))
#define CS_FX_SETALPHA_INT(alpha) \
  (CS_FX_ALPHA | uint ((alpha) & CS_FX_MASK_ALPHA))

struct csAlphaMode
{
  enum AlphaType
  {
    alphaNone = 1,
    alphaBinary,
    alphaSmooth
  };
  bool autoAlphaMode;
  union
  {
    AlphaType alphaType;
    csStringID autoModeTexture;
  };
};

#define CS_LIGHTPARAM_POSITION 0
#define CS_LIGHTPARAM_DIFFUSE 1
#define CS_LIGHTPARAM_SPECULAR 2
#define CS_LIGHTPARAM_ATTENUATION 3


#define CS_SHADOW_VOLUME_BEGIN 1
#define CS_SHADOW_VOLUME_PASS1 2
#define CS_SHADOW_VOLUME_PASS2 3
#define CS_SHADOW_VOLUME_FAIL1 4
#define CS_SHADOW_VOLUME_FAIL2 5
#define CS_SHADOW_VOLUME_USE 6
#define CS_SHADOW_VOLUME_FINISH 7


enum G3D_RENDERSTATEOPTION
{
  G3DRENDERSTATE_ZBUFFERMODE,
  G3DRENDERSTATE_DITHERENABLE,
  G3DRENDERSTATE_BILINEARMAPPINGENABLE,
  G3DRENDERSTATE_TRILINEARMAPPINGENABLE,
  G3DRENDERSTATE_TRANSPARENCYENABLE,
  G3DRENDERSTATE_MIPMAPENABLE,
  G3DRENDERSTATE_TEXTUREMAPPINGENABLE,
  G3DRENDERSTATE_LIGHTINGENABLE,
  G3DRENDERSTATE_INTERLACINGENABLE,
  G3DRENDERSTATE_MMXENABLE,
  G3DRENDERSTATE_INTERPOLATIONSTEP,
  G3DRENDERSTATE_MAXPOLYGONSTODRAW,
  G3DRENDERSTATE_GOURAUDENABLE,
  G3DRENDERSTATE_EDGES
};

struct csGraphics3DCaps
{
  int minTexHeight, minTexWidth;
  int maxTexHeight, maxTexWidth;
  bool SupportsPointSprites;
  bool DestinationAlpha;
  bool StencilShadows;
};

enum csRenderMeshType
{
  CS_MESHTYPE_TRIANGLES,
  CS_MESHTYPE_QUADS,
  CS_MESHTYPE_TRIANGLESTRIP,
  CS_MESHTYPE_TRIANGLEFAN,
  CS_MESHTYPE_POINTS,
  CS_MESHTYPE_POINT_SPRITES,
  CS_MESHTYPE_LINES,
  CS_MESHTYPE_LINESTRIP
};

enum csSimpleMeshFlags
{
  csSimpleMeshScreenspace = 0x01
};

enum csOpenPortalFlags
{
  CS_OPENPORTAL_ZFILL = 0x00000004,
  CS_OPENPORTAL_MIRROR = 0x00000010,
  CS_OPENPORTAL_FLOAT = 0x00000040
};

struct csSimpleRenderMesh
{
  csRenderMeshType meshtype;

  uint indexCount;
  const uint* indices;

  uint vertexCount;
  const csVector3* vertices;
  const csVector2* texcoords;
  const csVector4* colors;
  iTextureHandle* texture;

  iShader* shader;
  iShaderVariableContext* dynDomain;
  csAlphaMode alphaType;
  csZBufMode z_buf_mode;
  uint mixmode;
  csReversibleTransform object2world;

  csSimpleRenderMesh () : indexCount(0), indices(0), texcoords(0), colors(0), 
    texture (0), shader (0), dynDomain (0), z_buf_mode (CS_ZBUF_NONE), 
    mixmode (CS_FX_COPY)
  {  
    alphaType.autoAlphaMode = true;
    alphaType.autoModeTexture = csInvalidStringID;
  };
};

struct iGraphics3D : public virtual iBase
{
  SCF_INTERFACE(iGraphics3D, 2, 1, 0);
  
  virtual bool Open () = 0;
  virtual void Close () = 0;

  virtual iGraphics2D *GetDriver2D () = 0;

  virtual iTextureManager *GetTextureManager () = 0;

  virtual void SetDimensions (int width, int height) = 0;
  virtual int GetWidth () const = 0;
  virtual int GetHeight () const = 0;

  virtual const csGraphics3DCaps *GetCaps () const = 0;

  virtual void SetPerspectiveCenter (int x, int y) = 0;

  virtual void GetPerspectiveCenter (int& x, int& y) const = 0;

  virtual void SetPerspectiveAspect (float aspect) = 0;

  virtual float GetPerspectiveAspect () const = 0;
 
  virtual void SetRenderTarget (iTextureHandle* handle,
        bool persistent = false,
        int subtexture = 0) = 0;

  virtual iTextureHandle* GetRenderTarget () const = 0;

  virtual bool BeginDraw (int DrawFlags) = 0;

  virtual void FinishDraw () = 0;

  virtual void Print (csRect const* area) = 0;

  virtual void DrawMesh (const csCoreRenderMesh* mymesh,
                         const csRenderMeshModes& modes,
                         const iShaderVarStack* stacks) = 0;
  virtual void DrawSimpleMesh (const csSimpleRenderMesh& mesh,
    uint flags = 0) = 0;

  virtual void DrawPixmap (iTextureHandle *hTex, int sx, int sy,
    int sw, int sh, int tx, int ty, int tw, int th, uint8 Alpha = 0) = 0;

  virtual void DrawLine (const csVector3& v1, const csVector3& v2,
    float fov, int color) = 0;

  virtual bool ActivateBuffers (csRenderBufferHolder* holder, 
    csRenderBufferName mapping[CS_VATTRIB_SPECIFIC_LAST+1]) = 0;

  virtual bool ActivateBuffers (csVertexAttrib *attribs,
    iRenderBuffer **buffers, unsigned int count) = 0;

  virtual void DeactivateBuffers (csVertexAttrib *attribs, unsigned int count) = 0;

  virtual void SetTextureState (int* units, iTextureHandle** textures,
    int count) = 0;


  virtual void SetClipper (iClipper2D* clipper, int cliptype) = 0;

  virtual iClipper2D* GetClipper () = 0;

  virtual int GetClipType () const = 0;

  virtual void SetNearPlane (const csPlane3& pl) = 0;

  virtual void ResetNearPlane () = 0;

  virtual const csPlane3& GetNearPlane () const = 0;

  virtual bool HasNearPlane () const = 0;

  virtual bool SetRenderState (G3D_RENDERSTATEOPTION op, long val) = 0;

  virtual long GetRenderState (G3D_RENDERSTATEOPTION op) const = 0;

  virtual bool SetOption (const char*, const char*) = 0;
  
  virtual void SetWriteMask (bool red, bool green, bool blue, bool alpha) = 0;

  virtual void GetWriteMask (bool &red, bool &green, bool &blue,
        bool &alpha) const = 0;

  virtual void SetZMode (csZBufMode mode) = 0;

  virtual csZBufMode GetZMode () = 0;

  virtual void EnableZOffset () = 0;

  virtual void DisableZOffset () = 0;

  virtual void SetShadowState (int state) = 0;

  virtual float GetZBuffValue (int x, int y) = 0;

  virtual void OpenPortal (size_t numVertices, const csVector2* vertices,
    const csPlane3& normal, csFlags flags) = 0;

  virtual void ClosePortal () = 0;

  virtual iHalo *CreateHalo (float iR, float iG, float iB,
    unsigned char *iAlpha, int iWidth, int iHeight) = 0;

  virtual void RemoveFromCache (iRendererLightmap* rlm) = 0;

  virtual void SetWorldToCamera (const csReversibleTransform& w2c) = 0;

  virtual bool PerformExtension (char const* command, ...) = 0;

  virtual bool PerformExtensionV (char const* command, va_list) = 0;
  
  virtual const csReversibleTransform& GetWorldToCamera () = 0;
};

#endif // __CS_IVIDEO_GRAPH3D_H__

---