void BoundBox::Build(GU_Detail& gdp)
{
if(!organized) return;
if(!splitted)
{
if(count < 1) return;
GB_AttributeRef at = gdp.addPrimAttrib("count",4,GB_ATTRIB_INT,&count);
GB_AttributeRef rt = gdp.addAttrib("radius",4,GB_ATTRIB_FLOAT,&radius);
// SETUP BBOX
Collapse();
UT_BoundingBox bbox(bounds[0],bounds[1],bounds[2],bounds[3],bounds[4],bounds[5]);
int div[3] = {1,1,1};
GEO_Primitive* pl = GU_PrimVolume::buildFromFunction(&gdp,func,bbox,div[0],div[1],div[2]);
if(GBisAttributeRefValid(at))
{
int* ct = pl->castAttribData<int>(at);
*ct = count;
};
return;
};
for(int i=0;i<NODECOUNT;i++) b[i].Build(gdp);
};
SIM_CompoundAttributeReader(const GU_Detail &gdp)
{
myPos = gdp.findFloatTuple(GA_ATTRIB_POINT, "primPosition", 3, 3);
myRot = gdp.findFloatTuple(GA_ATTRIB_POINT, "primRotation", 3, 3);
myScale = gdp.findFloatTuple(GA_ATTRIB_POINT, "primScale", 3, 3);
myType = gdp.findIntTuple(GA_ATTRIB_POINT, "primType", 1);
myLength = gdp.findFloatTuple(GA_ATTRIB_POINT, "primLength", 1);
myRadius = gdp.findFloatTuple(GA_ATTRIB_POINT, "primRadius", 1);
}
int
main(int argc, char *argv[])
{
// Make sure to install the GU plug-ins
GU_Detail::loadIODSOs();
// Process command line arguments
UT_Args args;
args.initialize(argc, argv);
args.stripOptions("l:o:v:h");
if (args.found('h'))
{
usage(argv[0]);
return 1;
}
const char *output = args.found('o') ? args.argp('o') : "stdout.geo";
int lod = args.found('l') ? args.iargp('l') : 3;
const char *viewportLOD = args.found('v') ? args.argp('v') : "full";
GU_Detail gdp;
// Create a packed sphere primitive
GU_PrimPacked *pack = GU_PrimPacked::build(gdp, "PackedSphere");
if (!pack)
fprintf(stderr, "Can't create a packed sphere\n");
else
{
// Set the location of the packed primitive's point.
UT_Vector3 pivot(0, 0, 0);
pack->setPivot(pivot);
gdp.setPos3(pack->getPointOffset(0), pivot);
// Set the options on the sphere primitive
UT_Options options;
options.setOptionI("lod", lod);
pack->implementation()->update(options);
pack->setViewportLOD(GEOviewportLOD(viewportLOD));
// Save the geometry. With the .so file installed, this should load
// into Houdini and should be rendered by mantra.
if (!gdp.save(output, NULL).success())
fprintf(stderr, "Error saving to: %s\n", output);
}
return 0;
}
bool ToHoudiniGeometryConverter::convert( GU_DetailHandle handle ) const
{
ConstCompoundObjectPtr operands = parameters()->getTypedValidatedValue<CompoundObject>();
GU_DetailHandleAutoWriteLock writeHandle( handle );
GU_Detail *geo = writeHandle.getGdp();
if ( !geo )
{
return false;
}
bool result = doConversion( srcParameter()->getValidatedValue(), geo );
if ( result )
{
geo->incrementMetaCacheCount();
}
return result;
}
GU_RayIntersect *GU_CortexPrimitive::createRayCache( int &persistent )
{
GU_Detail *gdp = (GU_Detail *)getParent();
persistent = 0;
if ( gdp->cacheable() )
{
buildRayCache();
}
GU_RayIntersect *intersect = getRayCache();
if ( !intersect )
{
intersect = new GU_RayIntersect( gdp, this );
persistent = 1;
}
return intersect;
}
int
SOP_PrimCentroid::copyLocalVariables(const char *attr,
const char *varname,
void *data)
{
GA_ROAttributeRef gah;
GU_Detail *gdp;
// Extract the detail.
gdp = (GU_Detail *)data;
// Try to find the attribute we are processing.
gah = gdp->findPointAttribute(attr);
// If a point attribute exists then we can copy this variable mapping.
if (gah.isValid())
gdp->addVariableName(attr, varname);
return 1;
}
ROP_RENDER_CODE
ROP_DopField::renderFrame(fpreal time, UT_Interrupt *)
{
OP_Node *op;
DOP_Parent *dopparent;
UT_String doppath, savepath;
UT_String dopobject, dopdata;
if( !executePreFrameScript(time) )
return ROP_ABORT_RENDER;
DOPPATH(doppath, time);
if( !doppath.isstring() )
{
addError(ROP_MESSAGE, "Invalid DOP path");
return ROP_ABORT_RENDER;
}
op = findNode(doppath);
if (!op)
{
addError(ROP_COOK_ERROR, (const char *)doppath);
return ROP_ABORT_RENDER;
}
dopparent = op ? op->castToDOPParent() : 0;
if( !dopparent )
{
addError(ROP_COOK_ERROR, (const char *)doppath);
return ROP_ABORT_RENDER;
}
DOPOBJECT(dopobject, time);
DOPDATA(dopdata, time);
OUTPUT(savepath, time);
time = DOPsetBestTime(dopparent, time);
OP_Context context(time);
const SIM_Object *object;
object = dopparent->findObjectFromString(dopobject, 0, 0, time);
if (!object)
{
addError(ROP_COOK_ERROR, (const char *)dopobject);
return ROP_ABORT_RENDER;
}
const SIM_Data *data;
data = object->getConstNamedSubData(dopdata);
if (!data)
{
addError(ROP_COOK_ERROR, (const char *) dopdata);
return ROP_ABORT_RENDER;
}
// Create our GDP.
GU_Detail *gdp = new GU_Detail();
const SIM_ScalarField *scalarfield = SIM_DATA_CASTCONST(data, SIM_ScalarField);
if (scalarfield)
{
addField(gdp, scalarfield->getField());
}
const SIM_VectorField *vectorfield = SIM_DATA_CASTCONST(data, SIM_VectorField);
if (vectorfield)
{
for (int i = 0; i < 3; i++)
{
addField(gdp, vectorfield->getField(i));
}
}
const SIM_MatrixField *matrixfield = SIM_DATA_CASTCONST(data, SIM_MatrixField);
if (matrixfield)
{
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
addField(gdp, matrixfield->getField(i, j));
}
}
if (!gdp->save((const char *)savepath, 0, 0).success())
{
addError(ROP_SAVE_ERROR, (const char *)savepath);
return ROP_ABORT_RENDER;
}
// DO NOT delete gdp if we are stealing the voxels!
// delete gdp;
if (ALFPROGRESS() && (myEndTime != myStartTime))
{
fpreal fpercent = (time - myStartTime) / (myEndTime - myStartTime);
int percent = (int)SYSrint(fpercent * 100);
percent = SYSclamp(percent, 0, 100);
fprintf(stdout, "ALF_PROGRESS %d%%\n", percent);
fflush(stdout);
}
if (error() < UT_ERROR_ABORT)
{
if( !executePostFrameScript(time) )
return ROP_ABORT_RENDER;
}
return ROP_CONTINUE_RENDER;
}
OP_ERROR SOP_FluidSolver2D::cookMySop(OP_Context &context) {
oldf = f;
double t = context.getTime();
int f = context.getFrame();
UT_Interrupt *boss;
GU_PrimVolume *volume;
OP_Node::flags().timeDep = 1;
fluidSolver->fps = OPgetDirector()->getChannelManager()->getSamplesPerSec();
int newResX = RESX(t);
int newResY = RESY(t);
if ( newResX != fluidSolver->res.x || newResY != fluidSolver->res.y) {
fluidSolver->changeFluidRes(newResX,newResY);
}
UT_Vector3 fluidPos(POSX(t), POSY(t), POSZ(t));
UT_Vector3 fluidRot(ROTX(t), ROTY(t), ROTZ(t));
fluidRot.degToRad();
fluidSolver->fluidSize.x = FLUIDSIZEX(t);
fluidSolver->fluidSize.y = FLUIDSIZEY(t);
fluidSolver->borderNegX = BORDERNEGX(t);
fluidSolver->borderPosX = BORDERPOSX(t);
fluidSolver->borderNegY = BORDERNEGY(t);
fluidSolver->borderPosY = BORDERPOSY(t);
fluidSolver->preview = PREVIEW(t);
fluidSolver->previewType = PREVIEWTYPE(t);
fluidSolver->bounds = BOUNDS(t);
fluidSolver->substeps = SUBSTEPS(t);
fluidSolver->jacIter = JACITER(t);
fluidSolver->densDis = DENSDIS(t);
fluidSolver->densBuoyStrength = DENSBUOYSTRENGTH(t);
float ddirX = DENSBUOYDIRX(t);
float ddirY = DENSBUOYDIRY(t);
fluidSolver->densBuoyDir = cu::make_float2(ddirX,ddirY);
fluidSolver->velDamp = VELDAMP(t);
fluidSolver->vortConf = VORTCONF(t);
fluidSolver->noiseStr = NOISESTR(t);
fluidSolver->noiseFreq = NOISEFREQ(t);
fluidSolver->noiseOct = NOISEOCT(t);
fluidSolver->noiseLacun = NOISELACUN(t);
fluidSolver->noiseSpeed = NOISESPEED(t);
fluidSolver->noiseAmp = NOISEAMP(t);
if (error() < UT_ERROR_ABORT) {
boss = UTgetInterrupt();
gdp->clearAndDestroy();
// Start the interrupt server
if (boss->opStart("Building Volume")){
static float zero = 0.0;
#ifdef HOUDINI_11
GB_AttributeRef fluidAtt = gdp->addAttrib("cudaFluidPreview", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(fluidAtt, fluidSolver->preview);
GB_AttributeRef solverIdAtt = gdp->addAttrib("solverId", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(solverIdAtt, fluidSolver->id);
#else
GA_WOAttributeRef fluidAtt = gdp->addIntTuple(GA_ATTRIB_DETAIL, "cudaFluidPreview", 1);
gdp->element().setValue<int>(fluidAtt, fluidSolver->preview);
GA_WOAttributeRef solverIdAtt = gdp->addIntTuple(GA_ATTRIB_DETAIL, "solverId", 1);
gdp->element().setValue<int>(solverIdAtt, fluidSolver->id);
#endif
UT_Matrix3 xform;
const UT_XformOrder volXFormOrder;
volume = (GU_PrimVolume *)GU_PrimVolume::build(gdp);
#ifdef HOUDINI_11
volume->getVertex().getPt()->getPos() = fluidPos;
#else
volume->getVertexElement(0).getPt()->setPos(fluidPos);
#endif
xform.identity();
xform.scale(fluidSolver->fluidSize.x*0.5, fluidSolver->fluidSize.y*0.5, 0.25);
xform.rotate(fluidRot.x(), fluidRot.y(), fluidRot.z(), volXFormOrder);
volume->setTransform(xform);
xform.identity();
xform.rotate(fluidRot.x(), fluidRot.y(), fluidRot.z(), volXFormOrder);
xform.invert();
if(lockInputs(context) >= UT_ERROR_ABORT)
return error();
if(getInput(0)){
GU_Detail* emittersInput = (GU_Detail*)inputGeo(0, context);
GEO_PointList emittersList = emittersInput->points();
int numEmitters = emittersList.entries();
if (numEmitters != fluidSolver->nEmit) {
delete fluidSolver->emitters;
fluidSolver->nEmit = numEmitters;
fluidSolver->emitters = new FluidEmitter[numEmitters];
}
GEO_AttributeHandle radAh, amountAh;
radAh = emittersInput->getPointAttribute("radius");
amountAh = emittersInput->getPointAttribute("amount");
for (int i = 0; i < numEmitters; i++) {
UT_Vector4 emitPos = emittersList[i]->getPos();
UT_Vector3 emitPos3(emitPos);
emitPos3 -= fluidPos;
emitPos3 = emitPos3*xform;
fluidSolver->emitters[i].posX = emitPos3.x();
fluidSolver->emitters[i].posY = emitPos3.y();
radAh.setElement(emittersList[i]);
amountAh.setElement(emittersList[i]);
fluidSolver->emitters[i].radius = radAh.getF(0);
fluidSolver->emitters[i].amount = amountAh.getF(0);
}
} else {
fluidSolver->nEmit = 0;
}
if(getInput(1)) {
GU_Detail* collidersInput = (GU_Detail*)inputGeo(1, context);
GEO_PointList collidersList = collidersInput->points();
int numColliders = collidersList.entries();
if (numColliders != fluidSolver->nColliders) {
delete fluidSolver->colliders;
fluidSolver->nColliders = numColliders;
fluidSolver->colliders = new Collider[numColliders];
}
GEO_AttributeHandle colRadAh;
colRadAh = collidersInput->getPointAttribute("radius");
for (int i = 0; i < numColliders; i++) {
UT_Vector4 colPos = collidersList[i]->getPos();
UT_Vector3 colPos3(colPos);
colPos3 -= fluidPos;
colPos3 = colPos3*xform;
if (f > STARTFRAME(t)) {
fluidSolver->colliders[i].oldPosX = fluidSolver->colliders[i].posX;
fluidSolver->colliders[i].oldPosY = fluidSolver->colliders[i].posY;
} else {
fluidSolver->colliders[i].oldPosX = colPos3.x();
fluidSolver->colliders[i].oldPosY = colPos3.y();
}
fluidSolver->colliders[i].posX = colPos3.x();
fluidSolver->colliders[i].posY = colPos3.y();
colRadAh.setElement(collidersList[i]);
fluidSolver->colliders[i].radius = colRadAh.getF(0);
}
} else {
fluidSolver->nColliders = 0;
}
unlockInputs();
if (f <= STARTFRAME(t)) {
fluidSolver->resetFluid();
if (fluidSolver->preview != 1) {
{
UT_VoxelArrayWriteHandleF handle = volume->getVoxelWriteHandle();
handle->constant(0);
}
}
} else {
if (f!=oldf) {
fluidSolver->solveFluid();
}
if (fluidSolver->preview != 1) {
cu::cudaMemcpy( fluidSolver->host_dens, fluidSolver->dev_dens,
fluidSolver->res.x*fluidSolver->res.y*sizeof(float), cu::cudaMemcpyDeviceToHost );
{
UT_VoxelArrayWriteHandleF handle = volume->getVoxelWriteHandle();
handle->size(fluidSolver->res.x, fluidSolver->res.y, 1);
for (int i = 0; i < fluidSolver->res.x; i++) {
for (int j = 0; j < fluidSolver->res.y; j++) {
handle->setValue(i, j, 0, fluidSolver->host_dens[(j*fluidSolver->res.x + i)]);
}
}
}
}
}
select(GU_SPrimitive);
}
// Tell the interrupt server that we've completed. Must do this
// regardless of what opStart() returns.
boss->opEnd();
}
gdp->notifyCache(GU_CACHE_ALL);
return error();
}
OP_ERROR SOP_CudaParticles::cookMySop(OP_Context &context) {
oldf = f;
f = context.getFrame();
GEO_ParticleVertex* pvtx;
double t = context.getTime();
particlesSystem->dt = 1/(OPgetDirector()->getChannelManager()->getSamplesPerSec() * SUBSTEPS(t));
particlesSystem->preview = PREVIEW(t);
particlesSystem->partsLife = LIFE(t);
particlesSystem->partsLifeVar = LIFEVAR(t);
particlesSystem->velDamp = VELDAMP(t);
particlesSystem->gravityStrength = GRAVITYSTR(t);
particlesSystem->gravityDir = cu::make_float3(GRAVITYX(t),GRAVITYY(t),GRAVITYZ(t));
particlesSystem->fluidStrength = FLUIDSTR(t);
particlesSystem->noiseAmp = cu::make_float3(NOISEAMP(t),NOISEAMP(t),NOISEAMP(t));
particlesSystem->noiseOct = NOISEOCT(t);
particlesSystem->noiseFreq = NOISEFREQ(t);
particlesSystem->noiseLac = NOISELACUN(t);
particlesSystem->noiseOffset = cu::make_float3(NOISEOFFSETX(t),NOISEOFFSETY(t),NOISEOFFSETZ(t));
particlesSystem->pointSize = POINTSIZE(t);
particlesSystem->opacity = OPACITY(t);
particlesSystem->startColor = cu::make_float3(STARTCOLORX(t),STARTCOLORY(t),STARTCOLORZ(t));
particlesSystem->endColor = cu::make_float3(ENDCOLORX(t),ENDCOLORY(t),ENDCOLORZ(t));
UT_Interrupt *boss;
OP_Node::flags().timeDep = 1;
if (error() < UT_ERROR_ABORT) {
boss = UTgetInterrupt();
// Start the interrupt server
if (boss->opStart("Building Particles")){
//gdp->clearAndDestroy();
static float zero = 0.0;
GB_AttributeRef partsAtt = gdp->addAttrib("cudaParticlesPreview", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(partsAtt, particlesSystem->preview);
GB_AttributeRef systemIdAtt = gdp->addAttrib("systemId", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(systemIdAtt, particlesSystem->id);
if (f < STARTFRAME(t)) {
gdp->clearAndDestroy();
particlesSystem->resetParticles();
} else if (f == STARTFRAME(t)) {
gdp->clearAndDestroy();
particlesSystem->resetParticles();
int maxParts = MAXPARTS(t);
if (particlesSystem->nParts!=maxParts)
particlesSystem->changeMaxParts(maxParts);
//hSystem = (GEO_PrimParticle *)gdp->appendPrimitive(GEOPRIMPART);
//hSystem->clearAndDestroy();
GB_AttributeRef hVelocity = gdp->addPointAttrib("v", sizeof(UT_Vector3),GB_ATTRIB_VECTOR, 0);
GB_AttributeRef hLife = gdp->addPointAttrib("life", sizeof(float)*2,GB_ATTRIB_FLOAT, 0);
if(particlesSystem->preview!=1) {
UT_Vector4 orig = UT_Vector4(0,0,0,1);
for (int i = 0; i<particlesSystem->nParts; i++) {
GEO_Point* newPoint = gdp->appendPoint();
newPoint->setPos(orig);
/*pvtx = hSystem->giveBirth();
GEO_Point* ppt = pvtx->getPt();
//ppt->getPos().assign(0,0,0,1);*/
hSystemInit = 1;
}
}
} else {
if(particlesSystem->nParts != -1) {
if(lockInputs(context) >= UT_ERROR_ABORT)
return error();
if(getInput(0)){
GU_Detail* emittersInput = (GU_Detail*)inputGeo(0, context);
GEO_PointList emittersList = emittersInput->points();
int numEmitters = emittersList.entries();
if (numEmitters != particlesSystem->nEmit) {
delete particlesSystem->emitters;
particlesSystem->nEmit = numEmitters;
particlesSystem->emitters = new ParticlesEmitter[numEmitters];
}
GEO_AttributeHandle radAh, amountAh;
GEO_AttributeHandle initVelAh, radVelAmpAh, noiseVelAmpAh,
noiseVelOffsetAh, noiseVelOctAh, noiseVelLacAh, noiseVelFreqAh;
radAh = emittersInput->getPointAttribute("radius");
amountAh = emittersInput->getPointAttribute("amount");
initVelAh = emittersInput->getPointAttribute("initVel");
radVelAmpAh = emittersInput->getPointAttribute("radVelAmp");
noiseVelAmpAh = emittersInput->getPointAttribute("noiseVelAmp");
noiseVelOffsetAh = emittersInput->getPointAttribute("noiseVelOffset");
noiseVelOctAh = emittersInput->getPointAttribute("noiseVelOct");
noiseVelLacAh = emittersInput->getPointAttribute("noiseVelLac");
noiseVelFreqAh = emittersInput->getPointAttribute("noiseVelFreq");
for (int i = 0; i < numEmitters; i++) {
UT_Vector4 emitPos = emittersList[i]->getPos();
UT_Vector3 emitPos3(emitPos);
particlesSystem->emitters[i].posX = emitPos.x();
particlesSystem->emitters[i].posY = emitPos.y();
particlesSystem->emitters[i].posZ = emitPos.z();
radAh.setElement(emittersList[i]);
amountAh.setElement(emittersList[i]);
initVelAh.setElement(emittersList[i]);
radVelAmpAh.setElement(emittersList[i]);
noiseVelAmpAh.setElement(emittersList[i]);
noiseVelOffsetAh.setElement(emittersList[i]);
noiseVelOctAh.setElement(emittersList[i]);
noiseVelLacAh.setElement(emittersList[i]);
noiseVelFreqAh.setElement(emittersList[i]);
particlesSystem->emitters[i].radius = radAh.getF(0);
particlesSystem->emitters[i].amount = amountAh.getF(0);
particlesSystem->emitters[i].velX = initVelAh.getF(0);
particlesSystem->emitters[i].velY = initVelAh.getF(1);
particlesSystem->emitters[i].velZ = initVelAh.getF(2);
particlesSystem->emitters[i].radVelAmp = radVelAmpAh.getF(0);
particlesSystem->emitters[i].noiseVelAmpX = noiseVelAmpAh.getF(0);
particlesSystem->emitters[i].noiseVelAmpY = noiseVelAmpAh.getF(1);
particlesSystem->emitters[i].noiseVelAmpZ = noiseVelAmpAh.getF(2);
particlesSystem->emitters[i].noiseVelOffsetX = noiseVelOffsetAh.getF(0);
particlesSystem->emitters[i].noiseVelOffsetY = noiseVelOffsetAh.getF(1);
particlesSystem->emitters[i].noiseVelOffsetZ = noiseVelOffsetAh.getF(2);
particlesSystem->emitters[i].noiseVelOct = noiseVelOctAh.getF(0);
particlesSystem->emitters[i].noiseVelLac = noiseVelLacAh.getF(0);
particlesSystem->emitters[i].noiseVelFreq = noiseVelFreqAh.getF(0);
}
} else {
particlesSystem->nEmit = 0;
}
if(getInput(1)){
GU_Detail* fluidInput = (GU_Detail*)inputGeo(1, context);
GEO_AttributeHandle fluidIdAh= fluidInput->getDetailAttribute("solverId");
fluidIdAh.setElement(fluidInput);
int sId = fluidIdAh.getI();
VHFluidSolver3D* curr3DSolver = VHFluidSolver3D::solverList[sId];
particlesSystem->fluidSolver = curr3DSolver;
}
unlockInputs();
if (f!=oldf) {
particlesSystem->emitParticles();
particlesSystem->updateParticles();
}
if(particlesSystem->preview!=1 && hSystemInit == 1) {
cu::cudaMemcpy( particlesSystem->host_pos, particlesSystem->dev_pos,
particlesSystem->nParts*sizeof(cu::float3), cu::cudaMemcpyDeviceToHost );
GEO_Point* ppt;
int i = 0;
UT_Vector4 p;
FOR_ALL_GPOINTS(gdp, ppt) {
ppt->getPos() = UT_Vector4(particlesSystem->host_pos[i*3],
particlesSystem->host_pos[i*3+1],
particlesSystem->host_pos[i*3+2],
1);
i++;
}
/*pvtx = hSystem->iterateInit();
for (int i =0; i<particlesSystem->nParts; i++){
pvtx->getPos().assign(particlesSystem->host_pos[i*3],
particlesSystem->host_pos[i*3+1],
particlesSystem->host_pos[i*3+2],
1);
pvtx = hSystem->iterateFastNext(pvtx);
}*/
}
}
}
int
main(int argc, char *argv[])
{
// Init:
CMD_Args args;
args.initialize(argc, argv);
args.stripOptions("r:v");
if (args.argc() < 3)
{
usage(argv[0]);
return 1;
}
// Options:
int res = 256;
int verbose = 0;
if(args.found('r')) res = atoi(args.argp('r'));
if(args.found('v')) verbose = 1;
UT_String dcm_file, gdp_file;
gdp_file.harden(argv[argc-2]);
dcm_file.harden(argv[argc-1]);
#if 1
// Open GDP with samples:
GU_Detail gdp;
UT_BoundingBox bbox;
if (!gdp.load(gdp_file, 0).success())
{
cerr << "Cant open " << gdp_file << endl;
return 1;
}
// Points arrays and bbox details:
gdp.getBBox(&bbox);
int range = gdp.getNumPoints();
UT_Vector3Array positions(range);
UT_ValArray<int> indices(range);
const GEO_Point *ppt;
const GEO_PointList plist = gdp.points();
for (int i = 0; i < gdp.getNumPoints(); i++)
{
ppt = plist(i);
UT_Vector3 pos = ppt->getPos3();
positions.append(pos);
indices.append(i);
}
if (verbose)
cout << "Points in gdp : " << positions.entries() << endl;
// Point Grid structures/objects:
UT_Vector3Point accessor(positions, indices);
UT_PointGrid<UT_Vector3Point> pointgrid(accessor);
// Can we build it?
if (!pointgrid.canBuild(res, res, res))
{
cout << "Can't build the grid!" << endl;
return 1;
}
// Build it:
pointgrid.build(bbox.minvec(), bbox.size(), res, res, res);
if (verbose)
{
cout << "Point grid res : " << res << "x" << res << "x" << res << endl;
cout << "Bounding box size : " << bbox.size().x() << ", " << bbox.size().y() << ", " << bbox.size().z() << endl;
cout << "Bounding box center: " << bbox.center().x() << ", " << bbox.center().y() << ", " << bbox.center().z() << endl;
cout << "Pointgrid mem size : " << pointgrid.getMemoryUsage() << endl;
cout << "Voxel size is : " << pointgrid.getVoxelSize() << endl;
cout << "Total grid points : " << pointgrid.entries() << endl;
}
#endif
// Open rat (our random access, variable array length storage):
IMG_DeepShadow dsm;
dsm.setOption("compression", "0");
dsm.setOption("zbias", "0.05");
dsm.setOption("depth_mode", "nearest");
dsm.setOption("depth_interp", "discrete");
dsm.open(dcm_file, res*res, res);
dsm.getTBFOptions()->setOptionV3("bbox:min" , bbox.minvec());
dsm.getTBFOptions()->setOptionV3("bbox:max" , bbox.maxvec());
if (verbose)
cout << "DCM created res : " << res*res << "x" << res << endl;
#if 1
// db_* debug variables...
int db_index = 0;
int db_uindex = 0;
int db_av_iter = 0;
// Put point into deep pixels:
Locker locker;
Timer timer;
timer.start();
parallel_fillDCM(res, &dsm, &pointgrid, &positions, &locker);
cout << "Creation time : " << timer.current() << endl;
if (verbose)
{
cout << "Total voxels : " << db_index << endl;
cout << "Written voxel : " << db_uindex << endl;
cout << "Points per voxel : " << (float)db_av_iter / db_uindex << endl;
}
timer.start();
dsm.close();
cout << "Saving time : " << timer.current() << endl;
if (verbose)
cout << "Deep map closed." << endl;
return 0;
#endif
}
void SOP_Scallop::SaveDivMap(float time)
{
OP_Context context(time);
bool clip = (lockInputs(context) < UT_ERROR_ABORT);
UT_BoundingBox bbox;
if(clip)
{
const GU_Detail* input = inputGeo(0,context);
if(input != NULL)
{
//UT_Matrix4 bm;
int res = input->getBBox(&bbox);
if(res == 0) clip = false;
}
else clip = false;
unlockInputs();
};
if(!clip) return;
UT_String file;
STR_PARM(file,"mappath", 11, 0, time);
float& now=time;
//////////////////////////////////////////////////////////////////////////
Daemon::now=now;
Daemon::bias = evalFloat("bias",0,now);
int cnt = evalInt("daemons", 0, now);
Daemon* daemons=new Daemon[cnt];
float weights = 0;
int totd=0;
float maxR = 0;
for(int i=1;i<=cnt;i++)
{
bool skip = (evalIntInst("enabled#",&i,0,now)==0);
if(skip) continue;
Daemon& d = daemons[totd];
UT_String path = "";
evalStringInst("obj#", &i, path, 0, now);
if(path == "") continue;
SOP_Node* node = getSOPNode(path);
OBJ_Node* obj = dynamic_cast<OBJ_Node*>(node->getParent());
if(obj == NULL) continue;
obj->getWorldTransform(d.xform,context);
d.weight = evalFloatInst("weight#",&i,0,now);
d.c[0] = evalFloatInst("color#",&i,0,now);
d.c[1] = evalFloatInst("color#",&i,1,now);
d.c[2] = evalFloatInst("color#",&i,2,now);
int mth = evalIntInst("model#",&i,0,now);
switch(mth)
{
case 1:
d.method = Methods::Spherical;
break;
case 2:
d.method = Methods::Polar;
break;
case 3:
d.method = Methods::Swirl;
break;
case 4:
d.method = Methods::Trigonometric;
break;
case 5:
{
UT_String script;
evalStringInst("vexcode#", &i, script, 0, now);
d.SetupCVEX(script);
break;
};
case 0:
default:
d.method = Methods::Linear;
};
d.power = evalFloatInst("power#",&i,0,now);
d.radius = evalFloatInst("radius#",&i,0,now);
d.parameter = evalFloatInst("parameter#",&i,0,now);
if(d.radius > maxR) maxR = d.radius;
weights+=d.weight;
totd++;
};
if(totd == 0)
{
delete [] daemons;
return;
};
float base = 0.0;
for(int i=0;i<totd;i++)
{
Daemon& d = daemons[i];
d.range[0]=base;
d.range[1] = base+d.weight/weights;
base=d.range[1];
};
//////////////////////////////////////////////////////////////////////////
int total = evalInt("count",0,now);
int degr = evalInt("degr",0,now);
total >>= degr;
GU_Detail det;
UT_Vector3 current(0,0,0);
float C[3] = { 0,0,0 };
float R=1.0f;
float param=0.0f;
srand(0);
bool medial = (evalInt("mapmedial",0,now)!=0);
int mapdiv = evalInt("mapdiv",0,now);
//BoundBox Box;
OctreeBox O(mapdiv);
//if(medial)
//{
O.bbox=bbox;
//}
//else
//{
// BoundBox::limit = evalInt("nodecount", 0, now);
// BoundBox::medial = (evalInt("mapmedial",0,now)!=0);
// float boxb[6];
// memcpy(boxb,bbox.minvec().vec,12);
// memcpy(boxb+3,bbox.maxvec().vec,12);
// Box.Organize(boxb);
//};
for(int i=-50;i<total;i++)
{
bool ok = false;
float w = double(rand())/double(RAND_MAX);
for(int j=0;j<totd;j++)
{
ok = daemons[j].Transform(w,current,C,R,param);
if(ok) break;
};
if(i<0) continue;
//if(medial)
//{
float P[4] = { current.x(), current.y(), current.z(), R };
O.Insert(P);
//}
//else
//{
// Box.CheckPoint(current.vec);
//}
};
delete [] daemons;
//////////////////////////////////////////////////////////////////////////
int ita[3] = {-1,-1,-1};
//if(medial)
//{
int count = 0;
OctreeBox::at = det.addPrimAttrib("count",4,GB_ATTRIB_INT,&count);
det.addVariableName("count","COUNT");
float radius = 0.0f;
OctreeBox::rt = det.addAttrib("radius",4,GB_ATTRIB_FLOAT,&radius);
det.addVariableName("radius","RADIUS");
OctreeBox::it = det.addPrimAttrib("mask",12,GB_ATTRIB_INT,ita);
det.addVariableName("mask","MASK");
float box[6] = {bbox.xmin(),bbox.xmax(),bbox.ymin(),bbox.ymax(),bbox.zmin(),bbox.zmax()};
det.addAttrib("bbox",24,GB_ATTRIB_FLOAT,box);
O.maxlevel = 0x01<<mapdiv;
O.parentbbox = bbox;
O.Build(det);
//}
//else Box.Build(det);
det.save(file.buffer(),1,NULL);
// ...SAVE ATLAS
{
UT_String atlas =file;
atlas+=".atlas";
FILE* fa = fopen(atlas.buffer(),"wb");
GEO_PrimList& pl = det.primitives();
int cnt = pl.entries();
fwrite(&cnt,sizeof(int),1,fa);
float bb[6] = { bbox.xmin(), bbox.xmax(), bbox.ymin(), bbox.ymax(), bbox.zmin(), bbox.zmax() };
fwrite(bb,sizeof(float),6,fa);
fwrite(&(O.maxlevel),sizeof(int),1,fa);
fwrite(&(O.maxlevel),sizeof(int),1,fa);
fwrite(&(O.maxlevel),sizeof(int),1,fa);
for(int i=0;i<cnt;i++)
{
const GEO_PrimVolume* v = dynamic_cast<const GEO_PrimVolume*>(pl[i]);
UT_BoundingBox b;
v->getBBox(&b);
float _bb[6] = { b.xmin(), b.xmax(), b.ymin(), b.ymax(), b.zmin(), b.zmax() };
fwrite(_bb,sizeof(float),6,fa);
// MASK
fwrite(v->castAttribData<int>(OctreeBox::it),sizeof(int),3,fa);
}
fclose(fa);
}
};
bool
GusdGU_PackedUSD::unpackPrim(
GU_Detail& destgdp,
UsdGeomImageable prim,
const SdfPath& primPath,
const UT_Matrix4D& xform,
const GT_RefineParms& rparms,
bool addPathAttributes ) const
{
GT_PrimitiveHandle gtPrim =
GusdPrimWrapper::defineForRead(
prim,
m_frame,
m_purposes );
if( !gtPrim ) {
const TfToken &type = prim.GetPrim().GetTypeName();
if( type != "PxHairman" && type != "PxProcArgs" )
TF_WARN( "Can't convert prim for unpack. %s. Type = %s.",
prim.GetPrim().GetPath().GetText(),
type.GetText() );
return false;
}
GusdPrimWrapper* wrapper = UTverify_cast<GusdPrimWrapper*>(gtPrim.get());
if( !wrapper->unpack(
destgdp,
fileName(),
primPath,
xform,
intrinsicFrame(),
#if SYS_VERSION_FULL_INT < 0x10050000
intrinsicViewportLOD(),
#else
intrinsicViewportLOD( getPrim() ),
#endif
m_purposes )) {
// If the wrapper prim does not do the unpack, do it here.
UT_Array<GU_Detail *> details;
if( prim.GetPrim().IsInMaster() ) {
gtPrim->setPrimitiveTransform( new GT_Transform( &xform, 1 ) );
}
GA_Size startIndex = destgdp.getNumPrimitives();
GT_Util::makeGEO(details, gtPrim, &rparms);
for (exint i = 0; i < details.entries(); ++i)
{
copyPrimitiveGroups(*details(i), false);
#if SYS_VERSION_FULL_INT < 0x11000000
unpackToDetail(destgdp, details(i), true);
#else
unpackToDetail(destgdp, details(i), &xform);
#endif
delete details(i);
}
if( addPathAttributes ) {
// Add usdpath and usdprimpath attributes to unpacked geometry.
GA_Size endIndex = destgdp.getNumPrimitives();
const char *path = prim.GetPrim().GetPath().GetString().c_str();
if( endIndex > startIndex )
{
GA_RWHandleS primPathAttr(
destgdp.addStringTuple( GA_ATTRIB_PRIMITIVE, GUSD_PRIMPATH_ATTR, 1 ));
GA_RWHandleS pathAttr(
destgdp.addStringTuple( GA_ATTRIB_PRIMITIVE, GUSD_PATH_ATTR, 1 ));
for( GA_Size i = startIndex; i < endIndex; ++i )
{
primPathAttr.set( destgdp.primitiveOffset( i ), 0, path );
pathAttr.set( destgdp.primitiveOffset( i ), 0, fileName().c_str() );
}
}
}
}
return true;
}
// *****************************************************************************
int outputToGto( const char *filename, bool ascii, bool verbose )
{
using namespace HGto;
if( verbose ) std::cerr << "Loading from stdin..." << std::flush;
GU_Detail gdp;
if( gdp.load( std::cin ) < 0 )
{
std::cerr << "Unable to load input geometry" << std::endl;
exit(1);
}
if( verbose ) std::cerr << "Done" << std::endl;
if( verbose ) std::cerr << "Building GTO Data..." << std::flush;
std::vector<Object *> Objects;
Poly gtoPoly( "hPolyShape" ); // There is only ever 1 poly shape?
if( verbose ) std::cerr << "Found " << gdp.primitives().entries() << " primitives." << std::endl;
for( size_t i = 0; i < gdp.primitives().entries(); ++i )
{
const GEO_Primitive *prim = gdp.primitives()(i);
if( const GEO_PrimPoly *poly = dynamic_cast<const GEO_PrimPoly *>( prim ) )
{
gtoPoly.addFace( poly );
}
else if( const GEO_PrimParticle *particle = dynamic_cast<const GEO_PrimParticle *>( prim ) )
{
Objects.push_back( new Particle( particle ) );
}
// else if( const GEO_PrimNURBSurf *nurbs = dynamic_cast<const GEO_PrimNURBSurf *>( prim ) )
// {
// Objects.push_back( new NURBS( nurbs ) );
// }
else
{
if(verbose) std::cerr << "Unknown object: " << prim->getPrimitiveId() << std::endl;
}
}
gtoPoly.getVertices( gdp.points() );
if( verbose ) std::cerr << "Done" << std::endl;
try
{
if( verbose ) std::cerr << "Writing GTO File..." << std::flush;
Gto::Writer writer;
writer.open( filename, ascii ? Gto::Writer::TextGTO : Gto::Writer::CompressedGTO );
gtoPoly.writeHeader( writer );
for( int i = 0; i < Objects.size(); ++i ) Objects[i]->writeHeader( writer );
writer.beginData();
gtoPoly.writeData( writer );
for( int i = 0; i < Objects.size(); ++i ) Objects[i]->writeData( writer );
writer.endData();
writer.close();
if( verbose ) std::cerr << "Done" << std::endl;
}
catch( std::exception &e )
{
std::cerr << "hgto::exception: " << e.what() << std::endl;
exit(-1);
}
return 0;
}
void add_simple_mesh(GU_Detail& gdp,
const dgal::simple_mesh<Imath::V3f>& smesh,
const std::string& pointIDAttrib, const std::vector<int>* pointIDs,
const std::string& polyIDAttrib, const std::vector<int>* polyIDs,
const std::string& cellTypeAttrib, unsigned int cellType,
const std::string& cellIDAttrib, unsigned int cellID)
{
unsigned int first_point = gdp.points().entries();
unsigned int first_prim = gdp.primitives().entries();
// create dest points
for(std::vector<Imath::V3f>::const_iterator it=smesh.m_points.begin();
it!=smesh.m_points.end(); ++it)
{
GEO_Point* pt = gdp.appendPoint();
pt->setPos(it->x, it->y, it->z);
}
GEO_PointList& points = gdp.points();
GEO_PrimList& prims = gdp.primitives();
// create dest polys
for(unsigned int i=0; i<smesh.m_polys.size(); ++i)
{
const std::vector<unsigned int>& cpoly = smesh.m_polys[i];
GEO_PrimPoly* poly = GU_PrimPoly::build(&gdp, cpoly.size(), GU_POLY_CLOSED, 0);
for(unsigned int j=0; j<cpoly.size(); ++j)
poly->getVertex(j).setPt(points[cpoly[j] + first_point]);
}
// create cell-type attribute
if(!cellTypeAttrib.empty())
{
int defaultv = -1;
GB_AttributeRef aref = gdp.addAttribute(cellTypeAttrib.c_str(), sizeof(int),
GB_ATTRIB_INT, &defaultv, GEO_PRIMITIVE_DICT);
if(aref.isValid())
{
unsigned int npolys = prims.entries();
for(unsigned int i=first_prim; i<npolys; ++i)
prims[i]->setValue<int32>(aref, static_cast<int>(cellType));
}
}
// create cell-id attribute
if(!cellIDAttrib.empty())
{
int defaultv = -1;
GB_AttributeRef aref = gdp.addAttribute(cellIDAttrib.c_str(), sizeof(int),
GB_ATTRIB_INT, &defaultv, GEO_PRIMITIVE_DICT);
if(aref.isValid())
{
unsigned int npolys = prims.entries();
for(unsigned int i=first_prim; i<npolys; ++i)
prims[i]->setValue<int32>(aref, static_cast<int>(cellID));
}
}
// create point-id attribute
if(!pointIDAttrib.empty())
{
int defaultv = -1;
GB_AttributeRef aref = gdp.addAttribute(pointIDAttrib.c_str(), sizeof(int),
GB_ATTRIB_INT, &defaultv, GEO_POINT_DICT);
if(aref.isValid() && pointIDs)
{
unsigned int sz = std::min(points.entries()-first_point,
static_cast<unsigned int>(pointIDs->size()));
for(unsigned int i=0; i<sz; ++i)
points[i + first_point]->setValue<int32>(aref, (*pointIDs)[i]);
}
}
// create poly-id attribute
if(!polyIDAttrib.empty())
{
int defaultv = 0;
GB_AttributeRef aref = gdp.addAttribute(polyIDAttrib.c_str(), sizeof(int),
GB_ATTRIB_INT, &defaultv, GEO_PRIMITIVE_DICT);
if(aref.isValid() && polyIDs)
{
unsigned int sz = std::min(prims.entries()-first_prim,
static_cast<unsigned int>(polyIDs->size()));
for(unsigned int i=0; i<sz; ++i)
prims[i + first_prim]->setValue<int32>(aref, (*polyIDs)[i]);
}
}
}
void IECoreMantra::ProceduralPrimitive::addVisibleRenderable( VisibleRenderablePtr renderable )
{
ToHoudiniGeometryConverterPtr converter = ToHoudiniGeometryConverter::create( renderable );
if( !converter )
{
msg( Msg::Warning, "ProceduralPrimitive::addVisibleRenderable", "converter could not be found" );
return;
}
GU_Detail *gdp = allocateGeometry();
GU_DetailHandle handle;
handle.allocateAndSet( (GU_Detail*)gdp, false );
bool converted = converter->convert( handle );
if ( !converted )
{
msg( Msg::Warning, "ProceduralPrimitive::addVisibleRenderable", "converter failed" );
return;
}
/// \todo ToHoudiniGeometryConverter does not create a Houdini style uv attribute.
/// We make one from s and t. This code should probably live in a converter or in an Op that
/// remaps IECore conventions to common Houdini ones.
MeshPrimitivePtr mesh = runTimeCast<MeshPrimitive> (renderable);
if ( mesh )
{
gdp->addTextureAttribute( GA_ATTRIB_VERTEX );
GEO_AttributeHandle auv = gdp->getAttribute( GA_ATTRIB_VERTEX, "uv" );
GEO_AttributeHandle as = gdp->getAttribute( GA_ATTRIB_VERTEX, "s" );
GEO_AttributeHandle at = gdp->getAttribute( GA_ATTRIB_VERTEX, "t" );
if ( auv.isAttributeValid() && as.isAttributeValid() && at.isAttributeValid() )
{
GA_GBPrimitiveIterator it( *gdp );
GA_Primitive *p = it.getPrimitive();
while ( p )
{
for (int i = 0; i < p->getVertexCount(); ++i)
{
GA_Offset v = p->getVertexOffset(i);
as.setVertex(v);
at.setVertex(v);
auv.setVertex(v);
auv.setF( as.getF(0), 0 );
auv.setF( ((at.getF(0) * -1.0f) + 1.0f), 1 ); // wat, t arrives upside down for some reason.
auv.setF( 0.0f, 2 );
}
++it;
p = it.getPrimitive();
}
}
}
if ( m_renderer->m_motionType == RendererImplementation::Geometry )
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Geometry" );
if ( !m_renderer->m_motionTimes.empty() )
{
if ( (size_t)m_renderer->m_motionSize == m_renderer->m_motionTimes.size() )
{
openGeometryObject();
}
addGeometry(gdp, m_renderer->m_motionTimes.front());
m_renderer->m_motionTimes.pop_front();
if ( m_renderer->m_motionTimes.empty() )
{
applySettings();
closeObject();
}
}
}
else if ( m_renderer->m_motionType == RendererImplementation::ConcatTransform ||
m_renderer->m_motionType == RendererImplementation::SetTransform )
{
// It isn't clear that this will give correct results.
// ConcatTransform may need to interpolate transform snapshots.
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Transform" );
openGeometryObject();
addGeometry(gdp, 0.0f);
while ( !m_renderer->m_motionTimes.empty() )
{
setPreTransform( convert< UT_Matrix4T<float> >(m_renderer->m_motionTransforms.front()),
m_renderer->m_motionTimes.front() );
m_renderer->m_motionTimes.pop_front();
m_renderer->m_motionTransforms.pop_front();
}
applySettings();
closeObject();
m_renderer->m_motionType = RendererImplementation::Unknown;
}
else if ( m_renderer->m_motionType == RendererImplementation::Velocity )
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:Velocity" );
openGeometryObject();
addGeometry(gdp, 0.0f);
addVelocityBlurGeometry(gdp, m_preBlur, m_postBlur);
applySettings();
closeObject();
m_renderer->m_motionType = RendererImplementation::Unknown;
}
else
{
msg(Msg::Debug, "IECoreMantra::ProceduralPrimitive::addVisibleRenderable", "MotionBlur:None" );
openGeometryObject();
addGeometry( gdp, 0.0f );
setPreTransform( convert< UT_Matrix4T<float> >(m_renderer->m_transformStack.top()), 0.0f);
applySettings();
closeObject();
}
}
// *****************************************************************************
int inputFromGto( const char *filename, bool ascii, bool verbose )
{
using namespace Gto;
GU_Detail gdp;
RawDataBaseReader reader;
if( verbose ) std::cerr << "Loading " << filename << "..." << std::flush;
if( ! reader.open( filename ) )
{
std::cerr << "Unable to load input geometry" << std::endl;
exit(1);
}
if( verbose ) std::cerr << "Done" << std::endl;
if( verbose ) std::cerr << "Building objects..." << std::flush;
const RawDataBase *db = reader.dataBase();
for( int oi = 0; oi < db->objects.size(); ++oi )
{
const Object *o = db->objects[oi];
if( o->protocol == GTO_PROTOCOL_PARTICLE ||
o->protocol == "warped particle")
{
HGto::Particle particle( o->name );
for( int ci = 0; ci < o->components.size(); ++ci )
{
const Component *c = o->components[ci];
for( int pi = 0; pi < c->properties.size(); ++pi )
{
Property *p = c->properties[pi];
if( c->name == GTO_COMPONENT_OBJECT )
{
if( p->name == GTO_PROPERTY_GLOBAL_MATRIX )
{
memcpy( &particle.globalMatrix(),
p->floatData,
p->size * p->width * sizeof(float) );
}
}
if( c->name == GTO_COMPONENT_POINTS )
{
if( p->name == GTO_PROPERTY_POSITION )
{
particle.positions().resize( p->size );
memcpy( &particle.positions().front(),
p->floatData,
p->size * p->width * sizeof(float) );
}
else
{
// For all other properties
HGto::GtoAttribute *attr = NULL;
if( p->type == Gto::Float && p->width == 1)
{
attr = new HGto::FloatAttribute(p->name, p->size);
HGto::FloatAttribute *fattr = (HGto::FloatAttribute*)attr;
memcpy(&fattr->data().front(),
p->floatData,
sizeof( float ) * p->size);
particle.attributes().push_back(attr);
}
else if( p->type == Gto::Float && p->width == 3)
{
attr = new HGto::VectorAttribute(p->name, p->size);
HGto::VectorAttribute *vattr = (HGto::VectorAttribute*)attr;
memcpy(&vattr->data().front(),
p->floatData,
sizeof( float ) * p->size * 3);
particle.attributes().push_back(attr);
}
else if( p->type == Gto::Int && p->width == 1)
{
attr = new HGto::IntAttribute(p->name, p->size);
HGto::IntAttribute *iattr = (HGto::IntAttribute*)attr;
memcpy(&iattr->data().front(),
p->int32Data,
sizeof( int ) * p->size * 1);
particle.attributes().push_back(attr);
}
}
}
}
}
particle.declareHoudini( gdp );
}
else if( o->protocol == GTO_PROTOCOL_POLYGON )
{
HGto::Poly polyObject( o->name );
for( int ci = 0; ci < o->components.size(); ++ci )
{
const Component *c = o->components[ci];
for( int pi = 0; pi < c->properties.size(); ++pi )
{
const Property *p = c->properties[pi];
if( c->name == GTO_COMPONENT_OBJECT )
{
if( p->name == GTO_PROPERTY_GLOBAL_MATRIX )
{
memcpy( &polyObject.globalMatrix(),
p->floatData,
p->size * p->width * sizeof(float) );
}
}
if( c->name == GTO_COMPONENT_POINTS )
{
if( p->name == GTO_PROPERTY_POSITION )
{
polyObject.positions().resize( p->size );
memcpy( &polyObject.positions().front(),
p->floatData,
p->size * p->width * sizeof(float) );
}
}
if( c->name == GTO_COMPONENT_ELEMENTS )
{
if( p->name == GTO_PROPERTY_TYPE )
{
polyObject.elementsType().resize( p->size );
memcpy( &polyObject.elementsType().front(),
p->uint8Data,
p->size * p->width * sizeof(char) );
}
if( p->name == GTO_PROPERTY_SIZE )
{
polyObject.elementsSize().resize( p->size );
memcpy( &polyObject.elementsSize().front(),
p->uint16Data,
p->size * p->width * sizeof(short) );
}
}
if( c->name == GTO_COMPONENT_INDICES )
{
if( p->name == GTO_PROPERTY_VERTEX )
{
polyObject.indicesVertex().resize( p->size );
memcpy( &polyObject.indicesVertex().front(),
p->int32Data,
p->size * p->width * sizeof(int) );
}
}
if( c->name == GTO_COMPONENT_SMOOTHING )
{
if( p->name == GTO_PROPERTY_METHOD )
{
polyObject.smoothingMethod() = *(p->int32Data);
}
}
}
}
polyObject.declareHoudini( gdp );
}
}
if( verbose ) std::cerr << "Done" << std::endl;
if( verbose ) std::cerr << "Writing to stdout..." << std::flush;
gdp.save( std::cout, ! ascii );
if( verbose ) std::cerr << "Done" << std::endl;
return 0;
}
OP_ERROR SOP_FluidSolver3D::cookMySop(OP_Context &context) {
oldf = f;
f = context.getFrame();
double t = context.getTime();
fluidSolver->fps = OPgetDirector()->getChannelManager()->getSamplesPerSec();
UT_Interrupt *boss;
GU_PrimVolume *volume;
GU_PrimVolume *velXVolume;
GU_PrimVolume *velYVolume;
GU_PrimVolume *velZVolume;
OP_Node::flags().timeDep = 1;
int newResX = RESX(t);
int newResY = RESY(t);
int newResZ = RESZ(t);
if ( newResX != fluidSolver->res.width || newResY != fluidSolver->res.height || newResZ != fluidSolver->res.depth) {
fluidSolver->changeFluidRes(newResX,newResY,newResZ);
}
UT_Vector3 fluidPos(POSX(t), POSY(t), POSZ(t));
UT_Vector3 fluidRot(ROTX(t), ROTY(t), ROTZ(t));
fluidRot.degToRad();
fluidSolver->fluidSize.x = FLUIDSIZEX(t);
fluidSolver->fluidSize.y = FLUIDSIZEY(t);
fluidSolver->fluidSize.z = FLUIDSIZEZ(t);
fluidSolver->borderNegX = BORDERNEGX(t);
fluidSolver->borderPosX = BORDERPOSX(t);
fluidSolver->borderNegY = BORDERNEGY(t);
fluidSolver->borderPosY = BORDERPOSY(t);
fluidSolver->borderNegZ = BORDERNEGZ(t);
fluidSolver->borderPosZ = BORDERPOSZ(t);
fluidSolver->substeps = SUBSTEPS(t);
fluidSolver->jacIter = JACITER(t);
fluidSolver->densDis = DENSDIS(t);
fluidSolver->densBuoyStrength = DENSBUOYSTRENGTH(t);
float ddirX = DENSBUOYDIRX(t);
float ddirY = DENSBUOYDIRY(t);
float ddirZ = DENSBUOYDIRZ(t);
fluidSolver->densBuoyDir = cu::make_float3(ddirX,ddirY,ddirZ);
fluidSolver->velDamp = VELDAMP(t);
fluidSolver->vortConf = VORTCONF(t);
fluidSolver->noiseStr = NOISESTR(t);
fluidSolver->noiseFreq = NOISEFREQ(t);
fluidSolver->noiseOct = NOISEOCT(t);
fluidSolver->noiseLacun = NOISELACUN(t);
fluidSolver->noiseSpeed = NOISESPEED(t);
fluidSolver->noiseAmp = NOISEAMP(t);
fluidSolver->preview = PREVIEW(t);
fluidSolver->drawCube = DRAWCUBE(t);
fluidSolver->opaScale = OPASCALE(t);
fluidSolver->stepMul = STEPMUL(t);
fluidSolver->displayRes = DISPLAYRES(t);
fluidSolver->doShadows = DOSHADOWS(t);
float lightPosX = LIGHTPOSX(t);
float lightPosY = LIGHTPOSY(t);
float lightPosZ = LIGHTPOSZ(t);
fluidSolver->lightPos = cu::make_float3(lightPosX,lightPosY,lightPosZ);
fluidSolver->shadowDens = SHADOWDENS(t);
fluidSolver->shadowStepMul = SHADOWSTEPMUL(t);
fluidSolver->shadowThres = SHADOWTHRES(t);
fluidSolver->displaySlice = DISPLAYSLICE(t);
fluidSolver->sliceType = SLICETYPE(t);
fluidSolver->sliceAxis = SLICEAXIS(t);
fluidSolver->slicePos = SLICEPOS(t);
fluidSolver->sliceBounds = SLICEBOUNDS(t);
if (error() < UT_ERROR_ABORT) {
boss = UTgetInterrupt();
gdp->clearAndDestroy();
// Start the interrupt server
if (boss->opStart("Building Volume")){
static float zero = 0.0;
GB_AttributeRef fluidAtt = gdp->addAttrib("cudaFluid3DPreview", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(fluidAtt, fluidSolver->preview);
GB_AttributeRef fluidSliceAtt = gdp->addAttrib("sliceDisplay", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(fluidSliceAtt, fluidSolver->displaySlice);
GB_AttributeRef solverIdAtt = gdp->addAttrib("solverId", sizeof(int), GB_ATTRIB_INT, &zero);
gdp->attribs().getElement().setValue<int>(solverIdAtt, fluidSolver->id);
GEO_AttributeHandle name_gah;
int def = -1;
gdp->addPrimAttrib("name", sizeof(int), GB_ATTRIB_INDEX, &def);
name_gah = gdp->getPrimAttribute("name");
UT_Matrix3 xform;
const UT_XformOrder volXFormOrder;
volume = (GU_PrimVolume *)GU_PrimVolume::build(gdp);
volume->getVertex().getPt()->getPos() = fluidPos;
xform.identity();
xform.scale(fluidSolver->fluidSize.x*0.5, fluidSolver->fluidSize.y*0.5, fluidSolver->fluidSize.z*0.5);
xform.rotate(fluidRot.x(), fluidRot.y(), fluidRot.z(), volXFormOrder);
volume->setTransform(xform);
name_gah.setElement(volume);
name_gah.setString("density");
velXVolume = (GU_PrimVolume *)GU_PrimVolume::build(gdp);
velXVolume->getVertex().getPt()->getPos() = fluidPos;
velXVolume->setTransform(xform);
name_gah.setElement(velXVolume);
name_gah.setString("vel.x");
velYVolume = (GU_PrimVolume *)GU_PrimVolume::build(gdp);
velYVolume->getVertex().getPt()->getPos() = fluidPos;
velYVolume->setTransform(xform);
name_gah.setElement(velYVolume);
name_gah.setString("vel.y");
velZVolume = (GU_PrimVolume *)GU_PrimVolume::build(gdp);
velZVolume->getVertex().getPt()->getPos() = fluidPos;
velZVolume->setTransform(xform);
name_gah.setElement(velZVolume);
name_gah.setString("vel.z");
xform.identity();
xform.rotate(fluidRot.x(), fluidRot.y(), fluidRot.z(), volXFormOrder);
xform.invert();
if(lockInputs(context) >= UT_ERROR_ABORT)
return error();
if(getInput(0)){
GU_Detail* emittersInput = (GU_Detail*)inputGeo(0, context);
GEO_PointList emittersList = emittersInput->points();
int numEmitters = emittersList.entries();
if (numEmitters != fluidSolver->nEmit) {
delete fluidSolver->emitters;
fluidSolver->nEmit = numEmitters;
fluidSolver->emitters = new VHFluidEmitter[numEmitters];
}
GEO_AttributeHandle radAh, amountAh;
radAh = emittersInput->getPointAttribute("radius");
amountAh = emittersInput->getPointAttribute("amount");
for (int i = 0; i < numEmitters; i++) {
UT_Vector4 emitPos = emittersList[i]->getPos();
UT_Vector3 emitPos3(emitPos);
emitPos3 -= fluidPos;
emitPos3 = emitPos3*xform;
fluidSolver->emitters[i].posX = emitPos3.x();
fluidSolver->emitters[i].posY = emitPos3.y();
fluidSolver->emitters[i].posZ = emitPos3.z();
radAh.setElement(emittersList[i]);
amountAh.setElement(emittersList[i]);
fluidSolver->emitters[i].radius = radAh.getF(0);
fluidSolver->emitters[i].amount = amountAh.getF(0);
}
} else {
fluidSolver->nEmit = 0;
}
if(getInput(1)) {
GU_Detail* collidersInput = (GU_Detail*)inputGeo(1, context);
GEO_PointList collidersList = collidersInput->points();
int numColliders = collidersList.entries();
if (numColliders != fluidSolver->nColliders) {
delete fluidSolver->colliders;
fluidSolver->nColliders = numColliders;
fluidSolver->colliders = new VHFluidCollider[numColliders];
}
GEO_AttributeHandle colRadAh;
colRadAh = collidersInput->getPointAttribute("radius");
for (int i = 0; i < numColliders; i++) {
UT_Vector4 colPos = collidersList[i]->getPos();
UT_Vector3 colPos3(colPos);
colPos3 -= fluidPos;
colPos3 = colPos3*xform;
if (f > STARTFRAME(t)) {
fluidSolver->colliders[i].oldPosX = fluidSolver->colliders[i].posX;
fluidSolver->colliders[i].oldPosY = fluidSolver->colliders[i].posY;
fluidSolver->colliders[i].oldPosZ = fluidSolver->colliders[i].posZ;
} else {
fluidSolver->colliders[i].oldPosX = colPos3.x();
fluidSolver->colliders[i].oldPosY = colPos3.y();
fluidSolver->colliders[i].oldPosZ = colPos3.z();
}
fluidSolver->colliders[i].posX = colPos3.x();
fluidSolver->colliders[i].posY = colPos3.y();
fluidSolver->colliders[i].posZ = colPos3.z();
colRadAh.setElement(collidersList[i]);
fluidSolver->colliders[i].radius = colRadAh.getF(0);
}
} else {
fluidSolver->nColliders = 0;
}
unlockInputs();
if (f <= STARTFRAME(t)) {
fluidSolver->resetFluid();
if (COPYDENS(t)) {
{
UT_VoxelArrayWriteHandleF handle = volume->getVoxelWriteHandle();
handle->constant(0);
UT_VoxelArrayWriteHandleF velXHandle = velXVolume->getVoxelWriteHandle();
velXHandle->constant(0);
UT_VoxelArrayWriteHandleF velYHandle = velYVolume->getVoxelWriteHandle();
velYHandle->constant(0);
UT_VoxelArrayWriteHandleF velZHandle = velZVolume->getVoxelWriteHandle();
velZHandle->constant(0);
}
}
} else {
if (f!=oldf) {
fluidSolver->solveFluid();
}
if (COPYDENS(t)) {
cu::cudaMemcpy( fluidSolver->host_dens, fluidSolver->dev_dens,
fluidSolver->res.width*fluidSolver->res.height*fluidSolver->res.depth*sizeof(float), cu::cudaMemcpyDeviceToHost );
{
UT_VoxelArrayWriteHandleF handle = volume->getVoxelWriteHandle();
handle->size(fluidSolver->res.width, fluidSolver->res.height, fluidSolver->res.depth);
for (int i = 0; i < fluidSolver->res.width; i++) {
for (int j = 0; j < fluidSolver->res.height; j++) {
for (int k = 0; k < fluidSolver->res.depth; k++) {
handle->setValue(i, j, k, fluidSolver->host_dens[k*fluidSolver->res.width*fluidSolver->res.height + j*fluidSolver->res.width + i]);
}
}
}
}
if (COPYVEL(t)) {
cu::cudaMemcpy( fluidSolver->host_vel, fluidSolver->dev_vel,
fluidSolver->res.width*fluidSolver->res.height*fluidSolver->res.depth*sizeof(cu::float4), cu::cudaMemcpyDeviceToHost );
{
UT_VoxelArrayWriteHandleF velXHandle = velXVolume->getVoxelWriteHandle();
velXHandle->size(fluidSolver->res.width, fluidSolver->res.height, fluidSolver->res.depth);
UT_VoxelArrayWriteHandleF velYHandle = velYVolume->getVoxelWriteHandle();
velYHandle->size(fluidSolver->res.width, fluidSolver->res.height, fluidSolver->res.depth);
UT_VoxelArrayWriteHandleF velZHandle = velZVolume->getVoxelWriteHandle();
velZHandle->size(fluidSolver->res.width, fluidSolver->res.height, fluidSolver->res.depth);
for (int i = 0; i < fluidSolver->res.width; i++) {
for (int j = 0; j < fluidSolver->res.height; j++) {
for (int k = 0; k < fluidSolver->res.depth; k++) {
velXHandle->setValue(i, j, k, fluidSolver->host_vel[4*(k*fluidSolver->res.width*fluidSolver->res.height + j*fluidSolver->res.width + i)]);
velYHandle->setValue(i, j, k, fluidSolver->host_vel[4*(k*fluidSolver->res.width*fluidSolver->res.height + j*fluidSolver->res.width + i)+1]);
velZHandle->setValue(i, j, k, fluidSolver->host_vel[4*(k*fluidSolver->res.width*fluidSolver->res.height + j*fluidSolver->res.width + i)+2]);
}
}
}
}
}
}
}
select(GU_SPrimitive);
}
// Tell the interrupt server that we've completed. Must do this
// regardless of what opStart() returns.
boss->opEnd();
}
gdp->notifyCache(GU_CACHE_ALL);
return error();
}
