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; }
// ***************************************************************************** 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; }
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; }
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); } };