Public API Reference

ivideo/rndbuf.h

Go to the documentation of this file.

/*
    Copyright (C) 2002 by Marten Svanfeldt
                          Anders Stenberg

    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_RNDBUF_H__
#define __CS_IVIDEO_RNDBUF_H__

#include "csutil/scf.h"
#include "csutil/strset.h"
#include "csutil/refcount.h"

class csVector3;
class csVector2;
class csColor;
class csReversibleTransform;
struct iTextureHandle;
struct iMaterialWrapper;
class csRenderBufferHolder;

enum csRenderBufferType
{
  CS_BUF_DYNAMIC,
  CS_BUF_STATIC,
  CS_BUF_STREAM
};

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

enum csRenderBufferLockType
{
  CS_BUF_LOCK_NOLOCK = 0,
  CS_BUF_LOCK_READ,
  CS_BUF_LOCK_NORMAL
};

static const size_t csRenderBufferComponentSizes[CS_BUFCOMP_TYPECOUNT] = 
{
  sizeof (char), sizeof (unsigned char), 
  sizeof (short), sizeof (unsigned short),
  sizeof (int), sizeof (unsigned int),
  sizeof (float),
  sizeof (double)
};

struct iRenderBuffer : public virtual iBase
{
  SCF_INTERFACE (iRenderBuffer, 2, 0, 0);

  virtual void* Lock(csRenderBufferLockType lockType) = 0;

  virtual void Release() = 0;

  virtual void CopyInto (const void *data, size_t elementCount,
    size_t elemOffset = 0) = 0;

  virtual int GetComponentCount () const = 0;

  virtual csRenderBufferComponentType GetComponentType () const = 0;

  virtual csRenderBufferType GetBufferType() const = 0;

  virtual size_t GetSize() const = 0;

  virtual size_t GetStride() const = 0;

  virtual size_t GetElementDistance() const = 0;

  virtual size_t GetOffset() const = 0;

  virtual uint GetVersion () = 0;

  virtual iRenderBuffer* GetMasterBuffer () const = 0;

  virtual bool IsIndexBuffer() const = 0;
  virtual size_t GetRangeStart() const = 0;
  virtual size_t GetRangeEnd() const = 0;

  virtual size_t GetElementCount() const = 0;
};

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

#define CS_BUFFER_MAKE_MASKABLE(x) (1<<(x))

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


struct iRenderBufferAccessor : public virtual iBase
{
  SCF_INTERFACE (iRenderBufferAccessor,0,0,1);
  virtual void PreGetBuffer (csRenderBufferHolder* holder, 
    csRenderBufferName buffer) = 0;
};

class csRenderBufferHolder : public csRefCount
{
public:
  csRenderBufferHolder() {accessorMask=0;}
  iRenderBuffer* GetRenderBuffer (csRenderBufferName bufferName)
  {
    if (bufferName < CS_BUFFER_INDEX) return 0;
    if (accessor && 
        accessorMask & CS_BUFFER_MAKE_MASKABLE(bufferName))
      accessor->PreGetBuffer (this, bufferName);

    return buffers[bufferName];
  }

  iRenderBuffer* GetRenderBufferNoAccessor (csRenderBufferName bufferName)
  {
    if (bufferName < CS_BUFFER_INDEX) return 0;
    
    return buffers[bufferName];
  }

  void SetRenderBuffer (csRenderBufferName bufferName, iRenderBuffer* buffer)
  {
    CS_ASSERT(bufferName >= 0 && bufferName < CS_BUFFER_COUNT);
    buffers[bufferName] = buffer;
  }

  void SetAccessor (iRenderBufferAccessor* a, uint32 mask)
  {
    accessorMask = mask;
    accessor = a;
  }
  uint GetAccessorMask() const { return accessorMask; }
  iRenderBufferAccessor* GetAccessor() const { return accessor; }
protected:
  uint32 accessorMask;
  csRef<iRenderBufferAccessor> accessor;
  csRef<iRenderBuffer> buffers[CS_BUFFER_COUNT];
};

#endif // __CS_IVIDEO_RNDBUF_H__

---