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

/* Note: csgfx/renderbuffer.h stores this in _very_ few bits, take care when
   changing this! */
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_HALF,
  
  CS_BUFCOMP_BASE_TYPECOUNT,
  
  CS_BUFCOMP_NORMALIZED = 0x10,
  
  CS_BUFCOMP_BYTE_NORM = CS_BUFCOMP_BYTE | CS_BUFCOMP_NORMALIZED,
  CS_BUFCOMP_UNSIGNED_BYTE_NORM =
      CS_BUFCOMP_UNSIGNED_BYTE | CS_BUFCOMP_NORMALIZED,
  CS_BUFCOMP_SHORT_NORM =
      CS_BUFCOMP_SHORT | CS_BUFCOMP_NORMALIZED,
  CS_BUFCOMP_UNSIGNED_SHORT_NORM =
      CS_BUFCOMP_UNSIGNED_SHORT | CS_BUFCOMP_NORMALIZED,
  CS_BUFCOMP_INT_NORM = CS_BUFCOMP_INT | CS_BUFCOMP_NORMALIZED,
  CS_BUFCOMP_UNSIGNED_INT_NORM = 
      CS_BUFCOMP_UNSIGNED_INT | CS_BUFCOMP_NORMALIZED
};

enum csRenderBufferLockType
{
  CS_BUF_LOCK_READ = 1,
  CS_BUF_LOCK_NORMAL
};

#include "csutil/deprecated_warn_off.h"

namespace CS
{
  namespace Deprecated
  {
    struct CS_DEPRECATED_TYPE_MSG("You shouldn't use CS_BUF_LOCK_NOLOCK in "
      "the first place")
      CS_BUF_LOCK_NOLOCK
    {
      static const uint value = 0;
    };
  }
}

#include "csutil/deprecated_warn_on.h"

#define CS_BUF_LOCK_NOLOCK      CS::Deprecated::CS_BUF_LOCK_NOLOCK::value

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

struct iRenderBuffer;

struct iRenderBufferCallback : public virtual iBase
{
  SCF_INTERFACE (iRenderBufferCallback, 1,0,0);
  virtual void RenderBufferDestroyed (iRenderBuffer* buffer) = 0;
};

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

  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;

  virtual void SetCallback (iRenderBufferCallback* cb) = 0;

  virtual void SetData (const void *data) = 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)
  {    
  }

  csRenderBufferHolder (const csRenderBufferHolder& other)
    : csRefCount (), accessorMask (other.accessorMask),
    accessor (other.accessor)
  {
    for (size_t i = 0; i < CS_BUFFER_COUNT; ++i)
    {
      buffers[i] = other.buffers[i];
    }
  }

  csRenderBufferHolder& operator= (const csRenderBufferHolder& other)
  {
    accessorMask = other.accessorMask;
    accessor = other.accessor;

    for (size_t i = 0; i < CS_BUFFER_COUNT; ++i)
    {
      buffers[i] = other.buffers[i];
    }

    return *this;
  }

  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__

---