GU/GU_PrimVolumeCache.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GU_PrimVolumeCache.h ( GU Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_PrimVolumeCache__
#define __GU_PrimVolumeCache__

#include "GU_API.h"

#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_VoxelArray.h>
#include <UT/UT_EnvControl.h>

#include "GU_Detail.h"
#include "GU_DisplayCache.h"

class GU_API GU_PrimVolumeCacheLight
{
public:
    bool                 operator==(const GU_PrimVolumeCacheLight &l) const
                        {
                            // Hack: treat infinite lights like rainbow
                            // lights.
                            if (myIsInfinite &&
                                myIsInfinite == l.myIsInfinite)
                                return true;
                            return (myOrg == l.myOrg) &&
                                   (myDir == l.myDir) &&
                                   (myCd == l.myCd) &&
                                   (myIsAmbient == l.myIsAmbient) &&
                                   (myIsInfinite == l.myIsInfinite);
                        }
    
    void                 setOrg(const UT_Vector3 &org) { myOrg = org; }
    void                 setDir(const UT_Vector3 &dir) { myDir = dir; }
    void                 setCd(const UT_Vector3 &cd) { myCd = cd; }
    void                 setIsAmbient(bool isamb) { myIsAmbient = isamb; }
    void                 setIsInfinite(bool isinfinite) { myIsInfinite = isinfinite; }
    
    const UT_Vector3    &getOrg() const { return myOrg; }
    const UT_Vector3    &getDir() const { return myDir; }
    const UT_Vector3    &getCd() const { return myCd; }

    bool                 isAmbient() const { return myIsAmbient; }
    bool                 isInfinite() const { return myIsInfinite; }

    fpreal               getDistance(const UT_Vector3 &pos) const;

protected:
    UT_Vector3          myOrg, myDir;
    UT_Vector3          myCd;
    bool                myIsAmbient, myIsInfinite;
};


class GU_PrimVolumeCacheParms;
class GU_PrimVolume;

class GU_API GU_PrimVolumeTexture
{
public: 
                 GU_PrimVolumeTexture() {}
    virtual     ~GU_PrimVolumeTexture() {}

    virtual void         refresh(const UT_VoxelArray<UT_Vector4> *voxels) = 0;
};

class GU_API GU_PrimVolumeCache : public GU_DisplayCache
{
public:
                 GU_PrimVolumeCache(void);
    virtual     ~GU_PrimVolumeCache(void);

    // Build the cache.
    int          refresh(GU_PrimVolumeCacheParms &parms);

    // Get the cached data.
    UT_VoxelArray<UT_Vector4>   *getShadedVoxels() const { return myVoxels; }
    GU_PrimVolumeTexture        *getTexture() const      { return myTexture; }
    void                         setTexture(GU_PrimVolumeTexture *tex)
                                 { myTexture = tex; }

    GU_Detail                   *getIsoSurface() const { return myIsoSurf; }

    UT_Vector3                   getIsoCd() const { return myIsoCd; }
        
    
protected:
    void         lightVoxelsFromLight(const UT_VoxelArrayF *density,
                                    const GU_PrimVolumeCacheLight &light,
                                    const UT_Vector3 &cd,
                                    fpreal shadowdensity);

    void         rainbowVoxels(const UT_VoxelArrayF *density);

    /// Maximum per-axis resolution to do the self shadowing calculations
    /// at.
    int                  getMaxRes(int axis) const { return UT_EnvControl::getInt(ENV_HOUDINI_MAX_VOLUME_RES); }

    /// Used to convert to and from our *cached* indices, not the
    /// actual primitive indices that may be a different resolution
    bool                 indexToPos(int x, int y, int z, UT_Vector3 &pos) const;
    bool                 posToIndex(UT_Vector3 pos, int &x, int &y, int &z) const;      

    UT_VoxelArray<UT_Vector4>   *myVoxels;
    UT_RefArray<GU_PrimVolumeCacheLight> myLightList;
    GU_PrimVolumeTexture        *myTexture;
    GU_Detail                   *myIsoSurf;
    float                        myOldLOD;
    UT_Vector3                   myIsoCd;
    
    UT_Vector3                   myCacheRes;
    UT_Matrix4                   myCacheXform;
    UT_Matrix4                   myCacheIXform;
    const UT_VoxelArrayF        *myCacheDensity;
};

class GU_API GU_PrimVolumeCacheParms : public GU_CacheParms
{
public:
                 GU_PrimVolumeCacheParms(void) {}
    virtual     ~GU_PrimVolumeCacheParms(void) {}

    void        setVolume(GU_PrimVolume *vol) { myVolume = vol; }
    GU_PrimVolume *getVolume() const { return myVolume; }

    void        setLights(UT_RefArray<GU_PrimVolumeCacheLight> &lightlist)
                { myLightList = lightlist; }
    const UT_RefArray<GU_PrimVolumeCacheLight> &getLights() const { return myLightList; }

private:
    UT_RefArray<GU_PrimVolumeCacheLight> myLightList;
    GU_PrimVolume                       *myVolume;
};

#endif

---