RE/RE_Light.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 (I guess)
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        RE_Light.h (C++)
 *
 * COMMENTS:    Header file for RE_Light and RE_Lights
 *
 *      This class is probably more complicated than we need for
 *      right now, however, the future should be considered.
 *
 *      These lights are currently stored in a linked list.
 *
 */

#ifndef __RE_Light_H__
#define __RE_Light_H__

#include "RE_API.h"
#include "RE_Types.h"   // for RE_OGL_SINGLE_CONTEXT
#include <string.h>
#include <UT/UT_String.h>
#include <UT/UT_LinkList.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Matrix4.h>

class UT_Raster;
class RE_Texture2DMap;

class RE_API RE_LightFlag
{
public:
    RE_LightFlag()
    {
        cone            = 0;
        infinite        = 0;
        ambient         = 0;
        mapprojector    = 0;
        clampprojectormap = 0;
        projectormapdirty = 0;
    }

    unsigned    mapprojector:1,
                cone:1,
                infinite:1,
                ambient:1,
                clampprojectormap:1,
                projectormapdirty:1;
};


class RE_API RE_Light {
public:
    RE_Light(const char *n = 0);

    const char          *getName() const { return myName; }
    void                 setName(const char *name) { myName.harden(name); }

    virtual void         setForDelete();

    const UT_Vector3    &getPosition() const { return pos; }
    UT_Vector3          &getPosition() { return pos; }
    void                 setPosition(const UT_Vector3 &p) { pos = p; }

    const UT_Vector3    &getDirection() const { return dir; }
    UT_Vector3          &getDirection() { return dir; }
    void                 setDirection(const UT_Vector3 &d) { dir = d; }

    const UT_Vector3    &getColor() const { return clr; }
    UT_Vector3          &getColor() { return clr; }
    void                 setColor(const UT_Vector3 &c) { clr = c; }

    const UT_Matrix4    &getTransform() const { return xform; }
    UT_Matrix4          &getTransform() { return xform; }
    void                 setTransform(const UT_Matrix4 &m) { xform = m; }

    int                  isCone() const { return flag.cone; }
    int                  isInfinite() const { return flag.infinite; }
    int                  isAmbient() const { return flag.ambient; }
    int                  isMapProjector() const { return flag.mapprojector; }

    int                  isDiffuse() const      { return myContribDiff; }
    int                  isSpecular() const     { return myContribSpec; }

    bool                 isShadowed() const     { return myUseShadows; }

    //
    //  Light attribute settings, infinite, point, and cone light
    //
    void                 setInfinite(int onoff) { flag.infinite = onoff; }
    void                 setAmbient(int onoff)  { flag.ambient = onoff; }
    void                 setCone(int onoff) { flag.cone = onoff; }
    void                 setDiffuse(int onoff)  { myContribDiff = onoff; }
    void                 setSpecular(int onoff) { myContribSpec = onoff; }
    void                 setShadowed(bool onoff) { myUseShadows = onoff; }
    void                 setConeAttrib(float a = 45, float d = 10, float r = 1)
                         {
                            coneAngle = a;
                            coneDelta = d;
                             coneRoll = r;
                            setCone((a*.5 + d >= 180) ? 0 : 1);
                         }
    float                getConeAngle() const { return coneAngle; }
    float                getConeDelta() const { return coneDelta; }
    float                getConeRoll() const { return coneRoll; }

    //
    //  Other attributes (like zoom)
    void                 setZoom(float z) { zoom = z; }
    float                getZoom() const { return zoom; }

    void                 setFocalLength(float focal) { myFocalLength = focal; }
    float                getFocalLength() const      { return myFocalLength; }

    void                 setAperture(float aper)     { myAperture = aper; }
    float                getAperture() const         { return myAperture; }

    void                 setOrthoWidth(float width)  { myOrthoWidth = width; }
    float                getOrthoWidth() const       { return myOrthoWidth; }

    void                 setNearDistance(float znear)   { myNearDist = znear; }
    float                getNearDistance() const        { return myNearDist; }

    void                 setFarDistance(float zfar) { myFarDist = zfar; }
    float                getFarDistance() const     { return myFarDist; }

#if RE_OGL_SINGLE_CONTEXT
    int                  getIndex() const  { return myIndex; }
    void                 setIndex(int idx);
#endif

    int                  getConeTextureIndex() const  
                                                { return myGLConeTextureIndex;}
    void                 setConeTextureIndex(int idx) 
                                                { myGLConeTextureIndex = idx; }

    int                  needConeGLReset() const  { return myGLConeNeedReset; }
    void                 needConeGLReset(int f)   { myGLConeNeedReset = f; }

    //
    //  Methods to set up different rasters used by lights
    //  The light will never delete maps used by it.
    //  WARNING:  If someone deletes the raster, they should note
    //          that the light no longer has a map...
    //
    void                    setMaskPic(UT_Raster *r) {    maskPic = r; }
    void                  setShadowPic(UT_Raster *r) {  shadowPic = r; }
    void                 setDiffusePic(UT_Raster *r) { diffusePic = r; }
    void                 setReflectPic(UT_Raster *r) { reflectPic = r; }
    void                 setProjectMap(const char *name,
                                       const char *relativeTo); 
    void                 setProjectMapClamp(int onoff);

    UT_Raster              *getMaskPic() const { return maskPic; }
    UT_Raster            *getShadowPic() const { return shadowPic; }
    UT_Raster           *getDiffusePic() const { return diffusePic; }
    UT_Raster           *getReflectPic() const { return reflectPic; }
    RE_Texture2DMap     *getProjectMap();

    virtual void         getVexShader(UT_String &str, float now);
    virtual void         getVexShadow(UT_String &str, float now);
    virtual void         getAttenuation(float atten[3]) const;

protected:
#ifdef LINUX
    public:
    virtual ~RE_Light();        // Private - people should use "setForDelete"
    protected:
#else
    virtual ~RE_Light();        // Private - people should use "setForDelete"
#endif

#if RE_OGL_SINGLE_CONTEXT
    int                  myIndex;
#endif
    int                  myGLConeTextureIndex;  // for lights that project maps
    unsigned             myGLConeNeedReset:1,   // reset the cone texture
                         myContribDiff:1,       // contributes to diffuse
                         myContribSpec:1,       // contributes to specular
                         myUseShadows:1;        // uses shadow maps
#if RE_OGL_SINGLE_CONTEXT
    int                  myDeletePending;
#endif
    RE_LightFlag         flag;
    UT_String            myName; 
    UT_Vector3           pos;
    UT_Vector3           dir;
    UT_Vector3           clr;
    UT_Matrix4           xform;
    float                coneAngle, coneDelta, coneRoll;
    float                myAperture, myFocalLength;
    float                myOrthoWidth;
    float                myNearDist;
    float                myFarDist;
    float                zoom;
    UT_Raster           *maskPic;               // For filter masks
    UT_Raster           *shadowPic;             // Depth image for shadows
    UT_Raster           *diffusePic;            // Diffuse reflection map
    UT_Raster           *reflectPic;            // Specular reflection map
    RE_Texture2DMap     *projectMap;            // Projection texture

    UT_String            myProjectMapName;
    UT_String            myProjectMapRelativeTo;
};
#endif

---