Public API Reference

csgfx/renderbuffer.h

Go to the documentation of this file.

/*
  Copyright (C) 2003-2005 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_CSGFX_RENDERBUFFER_H__
#define __CS_CSGFX_RENDERBUFFER_H__

#include "csextern.h"
#include "csutil/leakguard.h"
#include "csutil/scf_implementation.h"
#include "ivideo/rndbuf.h"

struct csInterleavedSubBufferOptions
{
  csRenderBufferComponentType componentType;
  uint componentCount;
};

#ifdef CS_DEBUG
class csCallStack;
#endif

class CS_CRYSTALSPACE_EXPORT csRenderBuffer :
  public scfImplementation1<csRenderBuffer, iRenderBuffer>
{
protected:
  csRenderBuffer (size_t size, csRenderBufferType type, 
    csRenderBufferComponentType componentType, uint componentCount, 
    size_t rangeStart, size_t rangeEnd, bool copy);
public:
  CS_LEAKGUARD_DECLARE (csRenderBuffer);

  virtual ~csRenderBuffer ();

  virtual void* Lock (csRenderBufferLockType lockType);

  virtual void Release();

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

  virtual int GetComponentCount () const
  {
    return props.compCount;
  }

  virtual csRenderBufferComponentType GetComponentType () const 
  {
    return props.comptype;
  }

  virtual csRenderBufferType GetBufferType() const
  {
    return props.bufferType;
  }

  virtual size_t GetSize() const
  {
    return bufferSize;
  }

  virtual size_t GetStride() const 
  {
    return props.stride;
  }

  virtual size_t GetElementDistance() const
  {
    return props.stride ? props.stride :
      props.compCount * csRenderBufferComponentSizes[props.comptype];
  }

  virtual size_t GetOffset() const
  { return props.offset; }

  virtual uint GetVersion ()
  {
    return version;
  }

  virtual bool IsMasterBuffer ()
  {
    return !masterBuffer.IsValid();
  }

  virtual iRenderBuffer* GetMasterBuffer () const
  {
    return masterBuffer;
  }

  virtual bool IsIndexBuffer() const
  { return props.isIndex; }

  virtual size_t GetRangeStart() const
  { return rangeStart; }
  virtual size_t GetRangeEnd() const
  { return rangeEnd; }

  virtual size_t GetElementCount() const;
  static csRef<csRenderBuffer> CreateRenderBuffer (size_t elementCount, 
    csRenderBufferType type, csRenderBufferComponentType componentType, 
    uint componentCount, bool copy = true);
  static csRef<csRenderBuffer> CreateIndexRenderBuffer (size_t elementCount, 
    csRenderBufferType type, csRenderBufferComponentType componentType,
    size_t rangeStart, size_t rangeEnd, bool copy = true);
  static csRef<csRenderBuffer> CreateInterleavedRenderBuffers (
    size_t elementCount, 
    csRenderBufferType type, uint count, 
    const csInterleavedSubBufferOptions* elements, 
    csRef<iRenderBuffer>* buffers);
  static const char* GetDescrFromBufferName (csRenderBufferName bufferName);
  static csRenderBufferName GetBufferNameFromDescr (const char* name);
  void SetRenderBufferProperties (size_t elementCount, 
    csRenderBufferType type, csRenderBufferComponentType componentType, 
    uint componentCount, bool copy = true);
  void SetIndexBufferProperties (size_t elementCount, 
    csRenderBufferType type, csRenderBufferComponentType componentType,
    size_t rangeStart, size_t rangeEnd, bool copy = true);
protected:
  size_t bufferSize;

  struct Props
  {
    csRenderBufferType bufferType : 2;
    csRenderBufferComponentType comptype : 4; 
  
    uint compCount : 8;
    size_t stride : 8;
    size_t offset : 8;

    bool doCopy : 1; 
    bool doDelete : 1;
    bool isLocked : 1;
    bool isIndex : 1;

    uint lastLock : 2;

    Props (csRenderBufferType type, csRenderBufferComponentType componentType,
      uint componentCount, bool copy) : bufferType (type), 
      comptype (componentType), compCount (componentCount), stride(0), 
      offset (0), doCopy (copy), doDelete (false), isLocked (false), 
      isIndex (false), lastLock (CS_BUF_LOCK_NOLOCK)
    {
      CS_ASSERT(componentCount <= 255); // Just to be sure...
    }
  } props;

  size_t rangeStart; 
  size_t rangeEnd; 
  
  unsigned int version; 

  unsigned char *buffer; 
  
  csRef<iRenderBuffer> masterBuffer;
#ifdef CS_DEBUG
  csCallStack* lockStack;
#endif
};

#endif // __CS_CSGFX_RENDERBUFFER_H__

---