VRAY_StampFile.C

Go to the documentation of this file.

/** \defgroup VRAY_StampFile
 * @file
 * @author  katrin schmid <info@lo-motion.de>
 * @version 0.1.0
 *
 * 
 * @section DESCRIPTION
 * \brief VrayProcedural/mantra geo shader
 * that creates an instances of a given geometry
 * file on each point of object with the geometry shader applied. 
 * Applies color (as Cd attribute) and scaling to instanced objects.
 * The Instance color is taken from geometry objects point Cd or 
 * a random color if no Cd attribute is found.
 * Use from stampFile.otl, see .hip for an example scene. 
 * WIP, has no motion blur yet.
 * Could add more features like variation based on user definded 
 * point attributes, think about hnadling textures, animation
 *
*/

#ifdef debug
#undef debug
#endif
//#define debug 

#include <GB/GB_ExtraMacros.h>
#include <GB/GB_AttributeDefines.h>
#include <GEO/GEO_AttributeHandle.h>
#include <GEO/GEO_Point.h>
#include <GU/GU_Detail.h>
#include <GU/GU_PrimPoly.h>

#include <SYS/SYS_Math.h>
#include <UT/UT_XformOrder.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>

#include <UT/UT_DSOVersion.h>
#include <time.h>

#include "VRAY_StampFile.h"


/// map value to min, max range
inline fpreal remapValue(fpreal minV, fpreal maxV, fpreal value)
{
  return (minV +(maxV- minV)*value);
}

/*! \class vray_InstanceFile
* \brief instanced file
*
* "private" procedural used for instancing, user can't allocate these directly
*/
class vray_InstanceFile : public VRAY_Procedural 
{
public:
    vray_InstanceFile(UT_Vector3 pCenter, fpreal pSize, int pSizeRandom,
                    UT_Vector3 pNormal,  GU_Detail *pCFileGDP, UT_Vector3 pPointCd)
    : m_InstCenter(pCenter), m_InstSizeFactor(pSize), m_InstSizeRandomPerc(pSizeRandom),
        m_mOrientUp(pNormal), m_InstFileGDP(pCFileGDP),m_InstDiffColor(pPointCd)
    {
        fpreal doubleSize=m_InstSizeFactor*2;
        m_InstBox.expandBounds(doubleSize, doubleSize, doubleSize);
    }
    virtual const char *getClassName();
    virtual void getBoundingBox(UT_BoundingBox &box);
    virtual int initialize(const UT_BoundingBox *);
    virtual void  render();

private:
    int m_InstSizeRandomPerc;
    fpreal m_InstSizeFactor;
    UT_BoundingBox m_InstBox;
    GU_Detail *m_InstFileGDP;
    UT_Vector3 m_InstDiffColor, m_InstCenter, m_mOrientUp;
};

static VRAY_ProceduralArg   theArgs[] = 
{
    VRAY_ProceduralArg("minbound",  "real", "-1 -1 -1"),
    VRAY_ProceduralArg("maxbound",  "real", "1 1 1"),
    VRAY_ProceduralArg("geoscale",  "real", "1"),
    VRAY_ProceduralArg("randscale", "int",  "1"),
    VRAY_ProceduralArg("geofile",   "string", ""),
    VRAY_ProceduralArg("blurfile",  "string", ""),
    VRAY_ProceduralArg("velocityblur", "int",   "1"),
    VRAY_ProceduralArg("shutter",   "real",  "1"),
    VRAY_ProceduralArg()
};

VRAY_Procedural * allocProcedural(const char *)
{
    return new VRAY_StampFile();
}

const VRAY_ProceduralArg * getProceduralArgs(const char *)
{
    return theArgs;
}

VRAY_StampFile::VRAY_StampFile()
{
    m_Box.initBounds(0, 0, 0);
}

VRAY_StampFile::~VRAY_StampFile()
{}

const char * VRAY_StampFile::getClassName()
{
    return "VRAY_StampFile";
}

int VRAY_StampFile::initialize(const UT_BoundingBox *)
{
    fpreal val[3]={-1., -1., -1.};
    import("minbound", val, 3);
    m_Box.initBounds(val[0], val[1], val[2]);

    val[0] = val[1] = val[2] = 1;
    import("maxbound", val, 3);
    m_Box.enlargeBounds(val[0], val[1], val[2]);

    if (!import("geoscale", &m_GeoSizeFactor, 1))
        m_GeoSizeFactor = 1;
    if (!import("randscale", &m_SizeRandomPerc, 1))
        m_SizeRandomPerc = 0;

    import("geofile", m_File);
    import("blurfile", m_BlurFile);

    return 1;
}

void VRAY_StampFile::getBoundingBox(UT_BoundingBox &box)
{
    box = m_Box;
    box.enlargeBounds(0, m_GeoSizeFactor);  
}

void VRAY_StampFile::render()
{
    UT_Vector3 pointCd(-1., -1. , -1.);
    UT_Vector4 pValue, nValue;

    GEO_AttributeHandle pHandle, nHandle;
    const GEO_Point * ppt=NULL;
    GU_Detail *pGuDetail;

    void *handle = queryObject(NULL);
    handle = queryObject(m_Object);
    if (!handle)
    {
        fprintf(stderr, "VRAY_StampFile: Unable to find handle for %s\n", (const char *)m_Object);
        return; 
    }
    const GU_Detail *sgdp;
    sgdp = queryGeometry(handle, 0);
    if (!sgdp)
    {
        fprintf(stderr, "VRAY_StampFile: There's no geometry for %s\n", (const char *)m_Object);
        return;
    }
    
    pGuDetail = allocateGeometry();
    // Load geo from the disk file
    if (pGuDetail->load(m_File, 0) < 0)
    {
        fprintf(stderr, "VRAY_StampFile: Unable to load geometry: '%s'\n",(const char *)m_File);
        freeGeometry(pGuDetail);
        return;
    }
    int npts = sgdp->points().entries();

#ifdef debug
    std::cout <<" parent npts:   "<<     npts   <<std::endl;
#endif
    pHandle = sgdp->getAttribute(GEO_POINT_DICT, "P");
    if (!pHandle.isAttributeValid())
    {
        fprintf(stderr, "VRAY_StampFile: no points in geometry '%s'\n",(const char *)m_File);
        return;
    }
    nHandle = sgdp->getAttribute(GEO_POINT_DICT, "N");
    int pCdIndex=sgdp->findDiffuseAttribute ( GEO_POINT_DICT );
    m_Box.enlargeBounds(m_GeoSizeFactor, m_GeoSizeFactor, m_GeoSizeFactor);
    
    for (int i = 0; i < npts; i++)// FOR_ALL_GPOINTS ( gdp, ppt ) 
    {
        ppt=(sgdp->points()(i));
        pHandle.setElement(ppt);
        nHandle.setElement(ppt);
        if (pCdIndex >= 0)
        pointCd= *ppt->castAttribData<UT_Vector3> (pCdIndex);
        pValue = pHandle.getV3();
        nValue = nHandle.getV3();

        openProceduralObject();
            addProcedural( new vray_InstanceFile(pValue, m_GeoSizeFactor, m_SizeRandomPerc, nValue, pGuDetail, pointCd) );
        closeObject();
    }
}

/// vray_InstanceFile member functions
const char * vray_InstanceFile::getClassName()
{
    return "vray_InstanceFile";
}

/// Since the procedural is generated by the Stamp, this method should never be called
int vray_InstanceFile::initialize(const UT_BoundingBox *)
{
    fprintf(stderr, "VRAY_StampFile: This method should never be called\n");
    return 0;
}

void vray_InstanceFile::getBoundingBox(UT_BoundingBox &box)
{
    box.initBounds(m_InstCenter);
    box.enlargeBounds(0, m_InstSizeFactor);
}

/// setup instance color and transformations, add geometry
void vray_InstanceFile::render()
{
    GU_Detail gdp(m_InstFileGDP);
    GU_Detail *instGdp=NULL;
    GEO_Primitive *prim=NULL;

    UT_Matrix4 rXform(1.0);// identity
    UT_Matrix4 instXform(1.0);
    UT_Matrix3 rotXform(1.0);
    UT_Vector3 *iCd=NULL;
    instGdp = allocateGeometry();

    // set instance color
    int pCdIndex = gdp.addDiffuseAttribute( GEO_PRIMITIVE_DICT );
#ifdef debug
    std::cout<<"rgb: " << m_InstDiffColor[0] <<" "<<m_InstDiffColor[1] << " "<<m_InstDiffColor[2]<< std::endl; 
#endif
    if (pCdIndex >=0)
    {
        if (m_InstDiffColor[0] < 0)
        {
            // TODO: use something better for seed srand
            unsigned int seed=static_cast <unsigned>( time(NULL)/m_InstCenter.x()+ 1000*m_InstCenter.z());
            m_InstDiffColor[0]=SYSfastRandom(seed);// float random number in range [0, 1]
            m_InstDiffColor[1]=SYSfastRandom(seed);
            m_InstDiffColor[2]=SYSfastRandom(seed);
        }

        FOR_ALL_PRIMITIVES(&gdp, prim)  
        {
            iCd = prim->castAttribData<UT_Vector3> ( pCdIndex);
            iCd->assign(m_InstDiffColor[0], m_InstDiffColor[1], m_InstDiffColor[2]);
        }
    }
    
    // transform instance, SRT tranform order
    if (m_InstSizeRandomPerc >0)
    {
        unsigned int seed=static_cast <unsigned>(  time(NULL)*m_InstCenter.y()-m_InstCenter.x()*1000 );
        fpreal dsx=SYSfastRandom(seed);// random number in range [0, 1]
        fpreal dsy=SYSfastRandom(seed);
        fpreal dsz=SYSfastRandom(seed);

        dsx=remapValue(-m_InstSizeRandomPerc, m_InstSizeRandomPerc, dsx); 
        dsy=remapValue(-m_InstSizeRandomPerc, m_InstSizeRandomPerc, dsy);
        dsz=remapValue(-m_InstSizeRandomPerc, m_InstSizeRandomPerc, dsz);
        instXform.scale(m_InstSizeFactor+dsx/100, m_InstSizeFactor+dsy/100, m_InstSizeFactor+dsz/100);
    }
    else
        instXform.scale(m_InstSizeFactor,m_InstSizeFactor,m_InstSizeFactor);

    m_mOrientUp.normalize();
    UT_Vector3 iUp = UT_Vector3(0,1,0);// get up axis from object?
    rotXform.orient(iUp, m_mOrientUp);
    UT_Matrix4 tXform(1.0);
    tXform=rotXform;
    instXform=instXform*tXform;

#ifdef debug
    std::cout << "myDir:"<< time(NULL) <<std::endl <<std::endl;
#endif

    instXform.translate(m_InstCenter.x(), m_InstCenter.y(), m_InstCenter.z() );
    gdp.transform(instXform);

    instGdp->merge(gdp);
#ifdef debug
    int  inpts = instGdp->points().entries();
    int  npts = gdp.points().entries();
    std::cout << m_InstSizeFactor<<" child npts: "<< npts<<" : "<<inpts << " m_FileGDP: " <<std::endl;
#endif

    // TODO: add motion blur
    openGeometryObject();
        addGeometry(instGdp, 0);
    closeObject();
}

---