---

sglTexCoords.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: sglTexCoords.hpp
 *  Created: 3 November 2001
 *  Summary: Container for texure coordinates.
 *****************************************************************************/

#ifndef __SGL_TEX_COORDS_HPP
#define __SGL_TEX_COORDS_HPP

#include <sgl.h>
#include <sglDataPtr.hpp>

class SGL_DLL_API sglTexCoords
{
   typedef void (APIENTRY *FuncType1)(const void*);
   typedef void (APIENTRY *FuncType2)(GLenum, const void*);

public:
   sglTexCoords(float *tex_coords, unsigned int size = 2)
      : m_data_ptr(NULL), m_start(NULL)
      { set(new sglNoRefDataPtr(tex_coords), sglDataPtr::eFLOAT, size); }

   sglTexCoords(sglDataPtr *data = NULL,
                sglDataPtr::DataTypeEnum type = sglDataPtr::eFLOAT,
                int size = 2,
                int offset = 0,
                int stride = 0)
      : m_data_ptr(NULL), m_start(NULL)
      { set(data, type, size, offset, stride); }

   ~sglTexCoords() { derefDataPtr(); }

   sglTexCoords(const sglTexCoords &rhs)
      : m_data_ptr(rhs.m_data_ptr), m_type(rhs.m_type),
        m_size(rhs.m_size), m_stride(rhs.m_stride),
        m_gltype(rhs.m_gltype), m_byte_inc(rhs.m_byte_inc),
        m_start(rhs.m_start), m_func1(rhs.m_func1), m_func2(rhs.m_func2)
      { if (m_data_ptr) m_data_ptr->ref(); }

   sglTexCoords &operator=(const sglTexCoords &rhs);

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

   sglDataPtr* getDataPtr() const { return m_data_ptr; }

   sglDataPtr::DataTypeEnum getType() const { return m_type; }

   int getNumDimensions() const { return m_size; }

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

   int getStride() const { return m_stride; }

   // ------------------------------------------------------------------------
   // The rest of these functions are used by the sglDrawable subclasses to
   // apply the texture coordinates to the geometry.
   // ------------------------------------------------------------------------

   void apply(unsigned int index) const
      {
         if (m_start)
            m_func1(m_start + m_byte_inc * index);
      }
   void applyMulti(GLenum unit, unsigned int index) const
      {
         if (m_start)
            m_func2(unit, m_start + m_byte_inc * index);
      }

   static void applySet(const vector<sglTexCoords> &tc,
                        unsigned int index,
                        GLenum max)
      {
         vector<sglTexCoords>::const_iterator it = tc.begin();
         it->apply(index);
         for (GLenum unit = GL_TEXTURE0 + 1; unit != max; ++unit)
         {
            ++it;
            it->applyMulti(unit, index);
         }
      }

   static void applyArraySet(const vector<sglTexCoords> &tc)
      {
         if (!tc.empty())
         {
            vector<sglTexCoords>::const_iterator it = tc.begin();
            if (it->m_start)
            {
               glEnableClientState(GL_TEXTURE_COORD_ARRAY);
               glTexCoordPointer(it->m_size, it->m_gltype,
                                 it->m_stride, it->m_start);
            }
         }
      }

   static void applyArraySetMulti(const vector<sglTexCoords> &tc)
      {
         vector<sglTexCoords>::const_iterator it = tc.begin();
         vector<sglTexCoords>::const_iterator end =
            SGL_MIN(it+sgl::s_num_texture_units, tc.end());
         for (GLenum unit = GL_TEXTURE0;
              it != end;
              ++it, ++unit)
         {
            if (it->m_start)
            {
               sgl::setClientActiveTextureUnit(unit);
               glEnableClientState(GL_TEXTURE_COORD_ARRAY);
               glTexCoordPointer(it->m_size, it->m_gltype,
                                 it->m_stride, it->m_start);
            }
         }
      }

   bool isValid() const { return m_start != NULL; }
   int getInc() const { return m_byte_inc; }
   int getSize() const { return m_size; }
   sglDataPtr::DataTypeEnum getDataType() const { return m_type; }
   int getTypeIndex() const { return (((m_size-1) << 3) | m_type); }

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

   void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   void derefDataPtr();

private:
   sglDataPtr               *m_data_ptr;
   sglDataPtr::DataTypeEnum  m_type;
   int                       m_size; // 1, 2, 3, 4
   int                       m_stride;

   GLenum                    m_gltype;
   int                       m_byte_inc;
   char                     *m_start;
   void (APIENTRY *m_func1)(const void*);
   void (APIENTRY *m_func2)(GLenum, const void*);

   static FuncType1  s_func1[32];
   static FuncType2* s_func2[32];
};

#endif

---