SoLazyElement.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) 1990,91   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 SoLazyElement and SoColorPacker classes.
 |
 |   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_LAZY_ELEMENT
#define  _SO_LAZY_ELEMENT
 
#include <Inventor/system/SbSystem.h>
#include <Inventor/SbColor.h>
#include <Inventor/elements/SoElement.h>
#include <Inventor/elements/SoSubElement.h>
#include <Inventor/system/SbOpenGL.h>
#include <math.h>
 
class SoMFFloat; class SoMFColor; class SoColorPacker;
 
 
#define SO_LAZY_SHINY_THRESHOLD         0.005
 
#define SO_LAZY_NUM_COMPONENTS          9
 
typedef void SoDrawElementsCallback(void* userData, SoState* state, GLenum mode,
                    GLsizei count,
                    GLenum type,
                    const GLvoid * indices);
 
typedef void SoDrawArraysCallback(void* userData, SoState* state, GLenum mode,
                                  GLint first,
                                  GLsizei count);
 
SoEXTENDER class INVENTOR_API SoLazyElement : public SoElement {
 
    SO_ELEMENT_HEADER(SoLazyElement);
 
  public:   
    enum cases{ 
        LIGHT_MODEL_CASE        =   0,
        COLOR_MATERIAL_CASE     =   1,
        DIFFUSE_CASE            =   2, 
        AMBIENT_CASE            =   3,
        EMISSIVE_CASE           =   4,
        SPECULAR_CASE           =   5,
        SHININESS_CASE          =   6,
        BLENDING_CASE           =   7, 
        TRANSPARENCY_CASE       =   8
    }; 
    enum masks{
        LIGHT_MODEL_MASK        = 1<<LIGHT_MODEL_CASE, 
        COLOR_MATERIAL_MASK     = 1<<COLOR_MATERIAL_CASE,  
        DIFFUSE_MASK            = 1<<DIFFUSE_CASE, 
        AMBIENT_MASK            = 1<<AMBIENT_CASE, 
        EMISSIVE_MASK           = 1<<EMISSIVE_CASE,
        SPECULAR_MASK           = 1<<SPECULAR_CASE,
        SHININESS_MASK          = 1<<SHININESS_CASE,
        TRANSPARENCY_MASK       = 1<<TRANSPARENCY_CASE,
        BLENDING_MASK           = 1<<BLENDING_CASE, 
        ALL_MASK                = (1<<SO_LAZY_NUM_COMPONENTS)-1
    };
 
    enum LightModel {
        BASE_COLOR      = 0, 
        PHONG           = 1
    };
    
    virtual void        init(SoState *state);
 
 
    static void setDiffuse(SoState *state, SoNode *node, int32_t numColors, 
            const SbColor *colors, SoColorPacker *cPacker);                 
    static void setTransparency(SoState *state, SoNode *node, int32_t numTransp, 
            const float *transp, SoColorPacker *cPacker);                              
    static void         setPacked(SoState *state, SoNode *node,
            int32_t numColors, const uint32_t *colors);    
    static void         setAmbient(SoState *state, const SbColor* color);                   
    static void         setEmissive(SoState *state, const SbColor* color);          
    static void         setSpecular(SoState *state, const SbColor* color);                  
    static void         setShininess(SoState *state, float value);                  
    static void         setColorMaterial(SoState *state, bool value);                     
    static void         setBlending(SoState *state,  bool value);
    static void         setOverrideBlending(SoState *state,  bool flag);             
    static void         setLightModel(SoState *state, const int32_t model);
    
    static const SbColor &      getDiffuse(SoState* state, int index);  
    static float                getTransparency(SoState*, int index);
    static const uint32_t       *getPackedColors(SoState*);       
    static const SbColor &      getAmbient(SoState*);   
    static const SbColor &      getEmissive(SoState*);  
    static const SbColor &      getSpecular(SoState*);  
    static float                getShininess(SoState*);
    static bool                 getColorMaterial(SoState*);
    static bool                 getBlending(SoState*);
    static int32_t              getLightModel(SoState*);
    
    int32_t                     getNumDiffuse() const
        {return ivState.numDiffuseColors;} 
    int32_t                     getNumTransparencies() const
        {return ivState.numTransparencies;}
    bool                        isPacked() const
        {return ivState.packed;}                
    bool                        isTransparent() const
        {return(ivState.packedTransparent ||
            (ivState.numTransparencies > 1)||
            (ivState.transparencies[0]>0.0));}
    
    static  SoLazyElement * getInstance(SoState *state)
    {  return (SoLazyElement *) 
        (state->getElementNoPush(classStackIndex));}
         
    static SbColor      getDefaultDiffuse()
            {return SbColor(0.8f, 0.8f, 0.8f);}
    static SbColor      getDefaultAmbient()
            {return SbColor(0.2f, 0.2f, 0.2f);}
    static SbColor      getDefaultSpecular()
            {return SbColor(0.0f, 0.0f, 0.0f);}
    static SbColor      getDefaultEmissive()
            {return SbColor(0.0f, 0.0f, 0.0f);}
    static float        getDefaultShininess()
            {return 0.2f;}
    static uint32_t     getDefaultPacked()
            {return (0xccccccff);}          
    static float        getDefaultTransparency()
            {return 0.0f;}
    static int32_t      getDefaultLightModel()
            {return PHONG;}
   
    SoINTERNAL public:
    
    static void setMaterials(SoState *state, SoNode *node, uint32_t bitmask,
        SoColorPacker *cPacker,   
        const SoMFColor& diffuse, const SoMFFloat& transp, 
        const SoMFColor& ambient, const SoMFColor& emissive, 
        const SoMFColor& specular, const SoMFFloat& shininess);
                          
    virtual void        push(SoState *state);
 
    virtual bool        matches(const SoElement *) const; 
        
    virtual SoElement   *copyMatchInfo() const; 
                
    static SoLazyElement * getWInstance(SoState *state)
        {return (SoLazyElement *)
        (state->getElement(classStackIndex));}
    
    virtual void        print(FILE *fp) const;
 
    static void         initClass();
    
    const uint32_t *getPackedPointer() const
        {return ivState.packedColors;}
        
    const SbColor*      getDiffusePointer() const
        {return ivState.diffuseColors; }
                 
    const float         *getTransparencyPointer() const
        {return ivState.transparencies;}
        
    static void setTransparencyType(SoState *state, int32_t type);
 
    static void setDrawElementsCallback(SoState* state, SoDrawElementsCallback* cb, void* userData);
 
    // Fixed positions for attributes, shaders need to use these fixed attribute locations:
    enum VertexAttribs {
      ATTRIB_VERTEX = 0,
      ATTRIB_NORMAL = 1,
      ATTRIB_COLOR  = 2,
      ATTRIB_TEXCOORD = 3
    };
 
    static void setUseVertexAttributes( SoState* state, bool flag );
    static bool shouldUseVertexAttributes( SoState* state );
 
    static void setDrawArraysCallback(SoState* state, SoDrawArraysCallback* cb, void* userData);
 
    static void drawArrays(SoState* state, GLenum mode, GLint first, GLsizei count);
 
    static void drawElements(SoState* state, GLenum mode, GLsizei count,
                             GLenum type, const GLvoid * indices);
 
    enum internalMasks{
        OTHER_COLOR_MASK        = AMBIENT_MASK|EMISSIVE_MASK|SPECULAR_MASK|SHININESS_MASK,   
        ALL_COLOR_MASK          = OTHER_COLOR_MASK|DIFFUSE_MASK, 
        NO_COLOR_MASK           = ALL_MASK & (~ALL_COLOR_MASK), 
        ALL_BUT_DIFFUSE_MASK    =       ALL_MASK &(~ DIFFUSE_MASK), 
        DIFFUSE_ONLY_MASK       =  ALL_MASK &(~ OTHER_COLOR_MASK)
        };
   
  protected:
 
    virtual void        registerRedundantSet(SoState *, uint32_t);
    
    virtual void        registerGetDependence(SoState *, uint32_t);             
     
    struct ivStateStruct { 
        SbNodeIdType          diffuseNodeId;
        
        SbNodeIdType          transpNodeId;
            
        SbColor             ambientColor;
        SbColor             emissiveColor;
        SbColor             specularColor;
        float               shininess;
        bool                colorMaterial;
        bool                blending;
        int32_t             lightModel;
        int32_t             stippleNum;
        
        bool                packed;
        bool                packedTransparent;
        int32_t             numDiffuseColors;
        int32_t             numTransparencies;
        const SbColor       *diffuseColors;
        const float         *transparencies;
        const uint32_t      *packedColors;
        int32_t             transpType;
        uint32_t            cacheLevelSetBits;
        uint32_t            cacheLevelSendBits;
        bool                overrideBlending;
 
        bool                useVertexAttributes;
 
        SoDrawArraysCallback*   drawArraysCallback;
        void*                   drawArraysCallbackUserData;
        SoDrawElementsCallback* drawElementsCallback;
        void*                   drawElementsCallbackUserData;
    };
 
    ivStateStruct ivState;
 
    virtual ~SoLazyElement();
    
    uint32_t invalidBits;
 
  
    
    static SbColor      *defaultDiffuseColor;
    static float        *defaultTransparency;
    static uint32_t     *defaultPackedColor;
    
    static int          getNumPatterns()        { return 64; }
    
    private:
    virtual void        setDiffuseElt(SoNode*,  int32_t numColors, 
        const SbColor *colors, SoColorPacker *cPacker);   
    virtual void        setPackedElt( SoNode *, int32_t numColors, 
        const uint32_t *colors);
    virtual void        setTranspElt(SoNode *, int32_t numTrans, 
        const float *trans, SoColorPacker *cPacker);
        
    virtual void        setTranspTypeElt(int32_t type);
    virtual void        setAmbientElt(const SbColor* color);
    virtual void        setEmissiveElt(const SbColor* color);
    virtual void        setSpecularElt(const SbColor* color);
    virtual void        setShininessElt(float value);
    virtual void        setColorMaterialElt(bool value);
    virtual void        setBlendingElt(bool value);
    virtual void        setLightModelElt(SoState *state, int32_t model);
    virtual void        setMaterialElt(SoNode *, uint32_t bitmask, 
        SoColorPacker *cPacker, const SoMFColor&, const SoMFFloat&, 
        const SoMFColor&, const SoMFColor&, const SoMFColor&, const SoMFFloat&);
 
};
 
 
class INVENTOR_API SoColorPacker {
    public:
    SoColorPacker();
    
    ~SoColorPacker();
    
    uint32_t* getPackedColors() const
    { return packedColors;}
    
    bool diffuseMatch(SbNodeIdType nodeId)
    { return (nodeId == diffuseNodeId);}
    
    bool transpMatch(SbNodeIdType nodeId)
    { return (nodeId == transpNodeId);}
    
    void setNodeIds(SbNodeIdType diffNodeId, SbNodeIdType tNodeId)
    {diffuseNodeId = diffNodeId; transpNodeId = tNodeId;}
 
    int32_t getSize()
    { return packedArraySize;}
    
    void reallocate(int32_t size);
    
    private:
    SbNodeIdType    transpNodeId;
    SbNodeIdType    diffuseNodeId;
    uint32_t*   packedColors;
    int32_t     packedArraySize;
};
    
 
#endif /* _SO_LAZY_ELEMENT */