SoVertexProperty.h

Go to the documentation of this file.

/*
 *
 *  Copyright (C) 2000 Silicon Graphics, Inc.  All Rights Reserved. 
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 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
 *  Lesser General Public License for more details.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 * 
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 *  Mountain View, CA  94043, or:
 * 
 *  http://www.sgi.com 
 * 
 *  For further information regarding this notice, see: 
 * 
 *  http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
 
 
 
/*
 * Copyright (C) 1995-96   Silicon Graphics, Inc.
 *
 _______________________________________________________________________
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 |
 |   $Revision: 1.1.1.1 $
 |
 |   Description:
 |      This file defines the SoVertexProperty node class, and the
 |       SoVertexPropertyCache class.
 |
 |   Author(s)          : Alan Norton, Gavin Bell
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */
 
#ifndef  _SO_VERTEX_PROPERTY
#define  _SO_VERTEX_PROPERTY
 
#include <Inventor/fields/SoMFUInt32.h>
#include <Inventor/fields/SoMFVec3f.h>
#include <Inventor/fields/SoMFVec2f.h>
#include <Inventor/nodes/SoSubNode.h>
#include <Inventor/nodes/SoNormalBinding.h>
#include <Inventor/nodes/SoMaterialBinding.h>
#include <Inventor/nodes/SoTextureCoordinateBinding.h>
 
 
class SoVertexPropertyCache;
class SoVBO;
 
 
 
class INVENTOR_API SoVertexProperty : public SoNode {
 
    SO_NODE_HEADER(SoVertexProperty);
 
  public:
 
    SoMFVec3f           vertex;         
    SoMFVec2f           texCoord;       
    SoMFVec3f           normal;         
    SoSFEnum            normalBinding;  
    SoMFUInt32          orderedRGBA;    
    SoSFEnum            materialBinding;
 
    enum Binding {
        OVERALL =               SoMaterialBindingElement::OVERALL,
        PER_PART =              SoMaterialBindingElement::PER_PART,
        PER_PART_INDEXED =      SoMaterialBindingElement::PER_PART_INDEXED,
        PER_FACE =              SoMaterialBindingElement::PER_FACE,
        PER_FACE_INDEXED =      SoMaterialBindingElement::PER_FACE_INDEXED,
        PER_VERTEX =            SoMaterialBindingElement::PER_VERTEX,
        PER_VERTEX_INDEXED =    SoMaterialBindingElement::PER_VERTEX_INDEXED
    };
 
    SoVertexProperty();
 
  SoEXTENDER public:
    virtual void        doAction(SoAction *action);
    virtual void        GLRender(SoGLRenderAction *action);
    virtual void        getBoundingBox(SoGetBoundingBoxAction *action);
    virtual void        callback(SoCallbackAction *action);
    virtual void        pick(SoPickAction *action);
 
  SoINTERNAL public:
    void   putVBOsIntoState(SoState* state);
 
    static void         initClass();
 
  protected:
    virtual ~SoVertexProperty();
 
    SoVBO* _vertexVBO;
    SoVBO* _colorVBO;
    SoVBO* _normalVBO;
    SoVBO* _texCoordVBO;
    
};
 
 
#include <Inventor/elements/SoShapeStyleElement.h>
 
typedef void SoVPCacheFunc(const char *);
 
SoEXTENDER class INVENTOR_API SoVertexPropertyCache {
  public:
 
 
    bool mightNeedSomethingFromState(const SoShapeStyleElement *sse) const
        { return (needFromState & sse->getRenderCaseMask())!=0; }
 
    void        fillInColorAndTranspAvail(const SoVertexProperty *, SoState *state);
    void        fillInCache(const SoVertexProperty *,   SoState *);
 
    bool        shouldGenerateNormals(const SoShapeStyleElement *sse) const
        { return (generateNormals && sse->needNormals()); }
 
    bool        shouldGenerateTexCoords(const SoShapeStyleElement *sse) const
        { return (generateTexCoords && sse->needTexCoords()); }
 
    int         getRenderCase(const SoShapeStyleElement *sse) const
        { return renderCase & sse->getRenderCaseMask(); }
        
    bool        haveTexCoordsInVP()
        { return (needFromState & TEXTURE_FUNCTION_BIT) != 0; }
 
    void        sendVertex(const char *vp) const
        { (*vertexFunc)(vp); }
    void        sendNormal(const char *np) const
        { (*normalFunc)(np); }
    void        sendColor(const char *cp) const
        { (*colorFunc)(cp); }
    void        sendTexCoord(const char *tcp) const
        { (*texCoordFunc)(tcp); }
 
    int         getNumVertices() const { return numVerts; }
    int         getNumNormals() const { return numNorms; }
    int         getNumColors() const { return numColors; }
    int         getNumTexCoords() const { return numTexCoords; }
 
    const char *getVertices(int i) const
        { return vertexPtr + vertexStride*i; }
    const char *getNormals(int i) const 
        { return normalPtr + normalStride*i; }
    const char *getColors(int i) const
        { return colorPtr + colorStride*i; }
    const char *getTexCoords(int i) const
        { return texCoordPtr + texCoordStride*i; }
        
    bool colorIsInVtxProp() const {return colorIsInVP!=0;}
    
    bool transpIsInVtxProp() const {return transpIsInVP!=0;}
 
    int         getVertexStride() const { return vertexStride; }
    int         getNormalStride() const { return normalStride; }
    int         getColorStride() const { return colorStride; }
    int         getTexCoordStride() const { return texCoordStride; }
    
    SoNormalBindingElement::Binding     getNormalBinding()
        { return (SoNormalBindingElement::Binding)normalBinding; }
        
    SoMaterialBindingElement::Binding   getMaterialBinding()
        { return (SoMaterialBindingElement::Binding)materialBinding; }
 
    SoTextureCoordinateBindingElement::Binding  getTexCoordBinding()
        { return (SoTextureCoordinateBindingElement::Binding)texCoordBinding; }
 
    void        invalidate() { needFromState = ALL_FROM_STATE_BITS; }
 
    SoVertexPropertyCache();
    
  public:
 
    SoVPCacheFunc *vertexFunc;
    const char *vertexPtr;
    int vertexStride, numVerts;
    SoVPCacheFunc *normalFunc;
    const char *normalPtr;
    int normalStride, numNorms;
    SoVPCacheFunc *colorFunc;
    const char *colorPtr;
    int colorStride, numColors;
    SoVPCacheFunc *texCoordFunc;
    const char *texCoordPtr;
    int texCoordStride, numTexCoords;
 
    bool generateNormals;
    bool generateTexCoords;
    
    unsigned char needFromState;
 
  SoINTERNAL public:
    enum { 
        COLOR_BITS = 0x18,
        PART_COLOR = 0x8,
        FACE_COLOR = 0x10,
        VERTEX_COLOR = 0x18,
 
        NORMAL_BITS = 0x6,
        PART_NORMAL = 0x2,
        FACE_NORMAL = 0x4,
        VERTEX_NORMAL = 0x6,
 
        TEXCOORD_BIT = 0x1
        };
  
    enum {
        TEXTURE_FUNCTION_BIT = 0x80,
        OVERRIDE_FROM_STATE_BIT = 0x40, 
        COORD_FROM_STATE_BIT = 0x20,
        COLOR_FROM_STATE_BITS = COLOR_BITS,
        NORMAL_FROM_STATE_BITS = NORMAL_BITS,
        TEXCOORD_FROM_STATE_BIT = TEXCOORD_BIT,
        ALL_FROM_STATE_BITS = 0xFF
    };
  private:
 
    unsigned char normalBinding;
    unsigned char materialBinding;
    unsigned char texCoordBinding;
    unsigned char renderCase;
    unsigned char colorIsInVP;
    unsigned char transpIsInVP;
};
 
#endif /* _SO_VERTEX_PROPERTY */