---

sglGeoSetDataPtr.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * 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.
 *****************************************************************************
 *     File: sglGeoSetDataPtr.hpp
 *   Author: Tom Stimson
 *  Created: 6 April 2002
 *  Summary: Container class used internally by the sglGeoSet classes.
 *****************************************************************************/

#ifndef __SGL_GEO_SET_DATA_PTR_HPP
#define __SGL_GEO_SET_DATA_PTR_HPP

#include <sglDataPtr.hpp>
#include <sglVector.hpp>

#ifdef USE_SHORT_INDEX
# define GLINDEXTYPE GL_UNSIGNED_SHORT
   typedef unsigned short sglIndexType;
#else
# define GLINDEXTYPE GL_UNSIGNED_INT
   typedef unsigned int sglIndexType;
#endif


class SGL_DLL_API sglGeoSetDataPtr
{
public:
   sglGeoSetDataPtr()
      : m_data_ptr(NULL), m_stride(0) {}

   virtual ~sglGeoSetDataPtr()
      { derefDataPtr(); }

   sglDataPtr *getDataPtr() const { return m_data_ptr; }
   int getStride() const { return m_stride; }

   typedef void (APIENTRY *FuncType1)(const void*);

protected:
   void derefDataPtr();

   void set(sglDataPtr *data, int stride);

   static void APIENTRY invalidFunc(const void*);

private:
   // Not Implemented.
   sglGeoSetDataPtr(const sglGeoSetDataPtr &);
   sglGeoSetDataPtr &operator=(const sglGeoSetDataPtr &);

protected:
   sglDataPtr               *m_data_ptr;
   int                       m_stride;
};

class SGL_DLL_API sglMultiTypePtr : public sglGeoSetDataPtr
{
public:
   sglMultiTypePtr() : sglGeoSetDataPtr(),
      m_type(sglDataPtr::eFLOAT), m_gltype(0), m_size(0), m_byte_inc(0),
      m_start(NULL), m_func(invalidFunc) {}
   virtual ~sglMultiTypePtr() {}

   void set(sglDataPtr *data, sglDataPtr::DataTypeEnum type,
            int size, int offset, int stride);

   bool isValid() const { return (m_func != invalidFunc); }

   FuncType1 getFunc() const { return m_func; }
   int getInc() const { return m_byte_inc; }
   int getSize() const { return m_size; }
   sglDataPtr::DataTypeEnum getDataType() const { return m_type; }

   int getOffset() const
      { return m_data_ptr ? (m_start - (char*)m_data_ptr->getData()) : 0; }

   typedef const char* iterator;
   iterator begin() const { return m_start; }

   void apply0() const { m_func(m_start); }

protected:
   virtual void setFunc() = 0;

private:
   // Not Implemented.
   sglMultiTypePtr(const sglMultiTypePtr &);
   sglMultiTypePtr &operator=(const sglMultiTypePtr &);

protected:
   sglDataPtr::DataTypeEnum  m_type;
   GLenum                    m_gltype;
   int                       m_size;
   int                       m_byte_inc;
   char                     *m_start;
   FuncType1                 m_func;
};

class SGL_DLL_API sglVertexPtr : public sglMultiTypePtr
{
public:
   sglVertexPtr() : sglMultiTypePtr() {}
   virtual ~sglVertexPtr() {}

   void applyArray() const
      {
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(m_size, m_gltype, m_stride, m_start);
      }

   int getTypeIndex() const { return (((m_size-2) << 3) | m_type); }

protected:
   virtual void setFunc();

private:
   // Not Implemented.
   sglVertexPtr(const sglVertexPtr &);
   sglVertexPtr &operator=(const sglVertexPtr &);

private:
   static FuncType1 s_func[24];
};

class SGL_DLL_API sglNormalPtr : public sglMultiTypePtr
{
public:
   sglNormalPtr() : sglMultiTypePtr() {}
   virtual ~sglNormalPtr() {}

   void applyArray() const
      {
         glEnableClientState(GL_NORMAL_ARRAY);
         glNormalPointer(m_gltype, m_stride, m_start);
      }

   int getTypeIndex() const { return m_type; }

protected:
   virtual void setFunc();

private:
   static FuncType1 s_func[8];
};

class SGL_DLL_API sglColorPtr : public sglMultiTypePtr
{
public:
   sglColorPtr() : sglMultiTypePtr() {}
   virtual ~sglColorPtr() {}

   void applyArray() const
      {
         glEnableClientState(GL_COLOR_ARRAY);
         glColorPointer(m_size, m_gltype, m_stride, m_start);
      }

   int getTypeIndex() const { return (((m_size-3) << 3) | m_type); }

protected:
   virtual void setFunc();

private:
   // Not Implemented.
   sglColorPtr(const sglColorPtr &);
   sglColorPtr &operator=(const sglColorPtr &);

private:
   static FuncType1 s_func[16];
};


class SGL_DLL_API sglIndexPtr : public sglGeoSetDataPtr
{
public:
   sglIndexPtr() : sglGeoSetDataPtr(), m_inc(0) {}
   virtual ~sglIndexPtr() {}

   void set(sglDataPtr *data, int offset, int stride);

   bool isValid() const
      { return m_data_ptr && m_data_ptr->getData() && m_stride >= 0; }

   typedef const sglIndexType* iterator;

   int getOffset() const
      { return m_data_ptr ? (
         (char*)m_start - (char*)m_data_ptr->getData()) : 0; }

   iterator begin() const { return m_start; }
   int getInc() const { return m_inc; }

private:
   // Not Implemented.
   sglIndexPtr(const sglIndexPtr &);
   sglIndexPtr &operator=(const sglIndexPtr &);

private:
   iterator  m_start;
   int       m_inc;
};

#endif

---