RE/RE_OGLMaterial.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Render Library (C++)
 *
 * COMMENTS:    Material definition for lit geometry
 *
 */

#ifndef __RE_OGLMaterial_h__
#define __RE_OGLMaterial_h__

#include "RE_API.h"
#include <UT/UT_RefCount.h>
#include <UT/UT_String.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_BitArray.h>

class RE_Material;
class RE_OGLRender;
class RE_Texture2DMap;
class RE_Shader;
class TIL_TextureMap;

typedef RE_Texture2DMap *(* RE_MatTexCallback)( void *,float now,int layer);

class RE_API RE_TextureCallback
{
public:
    /// This class is used to provide texture parameters for each texture layer
             RE_TextureCallback();
    virtual ~RE_TextureCallback();

    virtual RE_Texture2DMap     *createTexture(int layer);
};

class RE_API RE_OGLMaterial : public UT_RefCount
{
public:
    RE_OGLMaterial(const char *materialName);

    const char  *getMaterialName() const        { return myMaterialName; }

    // methods to deal with textures
    void         clearTextureIndex();
    void         clearDiffuseMap();

    void         setDiffuseMap(TIL_TextureMap *map, int clamp = 0,
                               int layer = 0);
    void         setDiffuseMap(const char *mapname, const char *relativeTo,
                               int layer = 0);

    int          getTextureIndex(int layer=0);

    int          isTextured() const;
    int          isTransparent() const          { return alpha() < 1.0F; }

    // This allows the creator of this object to hook up a callback
    // with which an instance of RE_OGLMaterial could ask for a texture
    // if and when the texture is needed.  The presence of a callback
    // marks this material as being textured, so only set when necessary.
    void                         setCallback(RE_TextureCallback *cb);
    RE_TextureCallback  *getCallback()  { return myTexCallback; }

    // methods to deal with lighting
    void         doLighting( int yes )          { myDoLighting = yes != 0; }
    int          isLit() const                  { return myDoLighting; }

    RE_Shader   *createShader();
    RE_Shader   *getShader() const;

    void         doAlphaTest(int yes)           { myTestAlpha = yes != 0; }
    int          testAlpha() const              { return myTestAlpha; }

    // methods to access and change the material information
    float        amb( unsigned idx ) const      { return myAtimesD[idx]; }
    const float *amb() const                    { return myAtimesD; }
    float        diff( unsigned idx ) const     { return myDiff[idx]; }
    const float *diff() const                   { return myDiff; }
    float        spec( unsigned idx ) const     { return mySpec[idx]; }
    const float *spec() const                   { return mySpec; }
    float        emit( unsigned idx ) const     { return myEmit[idx]; }
    const float *emit() const                   { return myEmit; }

    float        alpha() const                  { return myAmb[3]; }
    float        shininess() const              { return myShininess; }

    void         setAlpha( float a );
   
    // give roughness: this method will calculate shininess needed by OGL
    void         setRoughness( float r );

    // give shininess: this method will enforce r within [0.0, 128.0]
    void         setShininess( float r );

    void         setAmb( float r, float g, float b );
    void         setDiff( float r, float g, float b );
    void         setSpec( float r, float g, float b );
    void         setEmit( float r, float g, float b );

    // normally amb() = setAmb() * setDiff(), but sometimes when playing 
    // tricks on multi-pass shading, we may want to force the amb() to be it
    // Normally, setAmb() should be used instead of forceAmb(), unless you know
    // what you are doing. 
    // NB: r,g,b is going to be overriden with new setAmb() or setDiff(),
    // also probably should be restored after forcing it to be something else.
    void         forceAmb( float r, float g, float b );
    float        getUnscaledAmbient(unsigned idx) const { return myAmb[idx]; }
    const float *getUnscaledAmbient() const             { return myAmb; }

    virtual void        getVexShader(UT_String &str, float now);

#ifdef UT_DEBUG
    // debug output
    void         output();
#endif

    RE_Material *cloneWithoutTexture() const;

protected:
    virtual     ~RE_OGLMaterial();

    void         loadShaderAttribNames();

    // This verifies we have enough layers.
    void         growLayers(int layer);

private:
    RE_TextureCallback          *myTexCallback;
    float                        myAmb[4];
    float                        myDiff[4];
    float                        myAtimesD[4];  // Maintained as amb*diff
    float                        mySpec[4];
    float                        myEmit[4];
    float                        myShininess;

    // I own map if if I created my RE_OGLTex
    UT_PtrArray<RE_Texture2DMap *>      myTextureMap;
    UT_BitArray                         myIOwnMap;

    UT_String            myMaterialName;
    unsigned             myDoLighting:1,
                         myTestAlpha:1;

    RE_Shader           *myShader;
};

#endif

---