本文整理汇总了C++中GEO_Point类的典型用法代码示例。如果您正苦于以下问题：C++ GEO_Point类的具体用法？C++ GEO_Point怎么用？C++ GEO_Point使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了GEO_Point类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: instancePoint
/* ******************************************************************************
* Function Name : instancePoint()
*
* Description : Instance a point
*
* Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp
*
* Return Value : int
*
***************************************************************************** */
int VRAY_clusterThis::instancePoint(GU_Detail * inst_gdp, GU_Detail * mb_gdp)
{
#ifdef DEBUG
std::cout << "VRAY_clusterThis::instancePoint()" << std::endl;
#endif
GEO_Point * ppt;
ppt = inst_gdp->appendPointElement();
ppt->setPos((float)myPointAttributes.myNewPos[0],
(float)myPointAttributes.myNewPos[1],
(float)myPointAttributes.myNewPos[2], 1.0);
VRAY_clusterThis::setPointInstanceAttributes(inst_gdp, ppt);
if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) {
ppt = mb_gdp->appendPointElement();
ppt->setPos((float)myPointAttributes.myMBPos[0],
(float)myPointAttributes.myMBPos[1],
(float)myPointAttributes.myMBPos[2], 1.0);
VRAY_clusterThis::setPointInstanceAttributes(mb_gdp, ppt);
}
if(myCVEX_Exec)
VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT);
return 0;
}示例2: instanceCube
/* ******************************************************************************
* Function Name : instanceCube()
*
* Description :
*
* Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp
*
* Return Value : int
*
***************************************************************************** */
int VRAY_clusterThis::instanceCube(GU_Detail * inst_gdp, GU_Detail * mb_gdp)
{
#ifdef DEBUG
std::cout << "VRAY_clusterThis::instanceCube()" << std::endl;
#endif
GEO_Primitive * myCube;
GEO_Point * ppt;
UT_Matrix4 xform(1.0);
// UT_XformOrder xformOrder(UT_XformOrder::TRS, UT_XformOrder::XYZ);
UT_Matrix3 rot_xform(1.0);
// UT_Vector3 myDir = myPointAttributes.N;
UT_Vector3 myUp = UT_Vector3(0,1,0);
rot_xform.orient(myPointAttributes.N, myUp);
xform = rot_xform;
myCube = (GEO_Primitive *) inst_gdp->cube(
myPointAttributes.myNewPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2),
myPointAttributes.myNewPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2),
myPointAttributes.myNewPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2),
myPointAttributes.myNewPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2),
myPointAttributes.myNewPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2),
myPointAttributes.myNewPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2));
for(int i=0; i < myCube->getVertexCount(); i++) {
ppt = myCube->getVertexElement(i).getPt();
UT_Vector4 P = ppt->getPos();
P *= xform;
ppt->setPos(P);
}
VRAY_clusterThis::setInstanceAttributes(myCube);
if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) {
myCube = (GEO_Primitive *) mb_gdp->cube(myPointAttributes.myMBPos[0] - ((mySize[0] * myPointAttributes.pscale) / 2),
myPointAttributes.myMBPos[0] + ((mySize[0] * myPointAttributes.pscale) / 2),
myPointAttributes.myMBPos[1] - ((mySize[1] * myPointAttributes.pscale) / 2),
myPointAttributes.myMBPos[1] + ((mySize[1] * myPointAttributes.pscale) / 2),
myPointAttributes.myMBPos[2] - ((mySize[2] * myPointAttributes.pscale) / 2),
myPointAttributes.myMBPos[2] + ((mySize[2] * myPointAttributes.pscale) / 2));
for(int i=0; i < myCube->getVertexCount(); i++) {
ppt = myCube->getVertexElement(i).getPt();
UT_Vector4 P = ppt->getPos();
P *= xform;
ppt->setPos(P);
}
VRAY_clusterThis::setInstanceAttributes(myCube);
}
if(myCVEX_Exec)
VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT);
if(myCVEX_Exec_prim)
VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM);
return 0;
}示例3: xformOrder
/* ******************************************************************************
* Function Name : instanceGrid()
*
* Description : Instance a grid
*
* Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp
*
* Return Value : int
*
***************************************************************************** */
int VRAY_clusterThis::instanceGrid(GU_Detail * inst_gdp, GU_Detail * mb_gdp)
{
#ifdef DEBUG
std::cout << "VRAY_clusterThis::instanceGrid()" << std::endl;
#endif
GEO_Primitive * myGrid;
GU_GridParms grid_parms;
UT_XformOrder xformOrder(UT_XformOrder::TRS, UT_XformOrder::XYZ);
UT_Matrix4 xform(1.0);
xform.rotate(myPointAttributes.N[0], myPointAttributes.N[1], myPointAttributes.N[2], xformOrder);
grid_parms.rows = 2;
grid_parms.cols = 2;
grid_parms.xsize = mySize[0] * myPointAttributes.pscale;
grid_parms.ysize = mySize[1] * myPointAttributes.pscale;
grid_parms.xcenter = myPointAttributes.myNewPos[0];
grid_parms.ycenter = myPointAttributes.myNewPos[1];
grid_parms.zcenter = myPointAttributes.myNewPos[2];
grid_parms.plane = GU_PLANE_XY;
myGrid = inst_gdp->buildGrid(grid_parms, GU_GRID_POLY);
for(int i = 0; i < myGrid->getVertexCount(); i++) {
GEO_Point * ppt = myGrid->getVertexElement(i).getPt();
UT_Vector4 P = ppt->getPos();
P *= xform;
ppt->setPos(P);
}
VRAY_clusterThis::setInstanceAttributes(myGrid);
if(myDoMotionBlur == CLUSTER_MB_DEFORMATION) {
grid_parms.xcenter = myPointAttributes.myMBPos[0];
grid_parms.ycenter = myPointAttributes.myMBPos[1];
grid_parms.zcenter = myPointAttributes.myMBPos[2];
myGrid = mb_gdp->buildGrid(grid_parms, GU_GRID_POLY);
for(int i = 0; i < myGrid->getVertexCount(); i++) {
GEO_Point * ppt = myGrid->getVertexElement(i).getPt();
UT_Vector4 P = ppt->getPos();
P *= xform;
ppt->setPos(P);
}
VRAY_clusterThis::setInstanceAttributes(myGrid);
}
if(myCVEX_Exec)
VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname, CLUSTER_CVEX_POINT);
if(myCVEX_Exec_prim)
VRAY_clusterThis::runCVEX(inst_gdp, mb_gdp, myCVEXFname_prim, CLUSTER_CVEX_PRIM);
return 0;
}示例4: setFileAttributes
/* ******************************************************************************
* Function Name : setFileAttributes()
*
* Description :
*
* Input Arguments : GEO_Point *ppt, GU_Detail *inst_gdp
*
* Return Value : int
*
***************************************************************************** */
inline int VRAY_clusterThis::setFileAttributes(GU_Detail * file_gdp)
{
#ifdef DEBUG
cout << "VRAY_clusterThis::setFileAttributes() " << endl;
#endif
GEO_Point * ppt;
#ifdef DEBUG
long int num_points = (long int) file_gdp->points().entries();
cout << "VRAY_clusterThis::setFileAttributes() - num points :" << num_points << endl;
#endif
// NOTE: File instanced geo should have normals already, do not set the normals to the source point normals
GA_FOR_ALL_GPOINTS(file_gdp, ppt) {
ppt->setValue<UT_Vector3>(myFileAttrOffsets.Cd, (const UT_Vector3)myPointAttributes.Cd);
ppt->setValue<float>(myFileAttrOffsets.Alpha, (const float)myPointAttributes.Alpha);
ppt->setValue<UT_Vector3>(myFileAttrOffsets.pointV, (const UT_Vector3)myPointAttributes.v);
ppt->setValue<int>(myFileAttrOffsets.pointId, (const int)myPointAttributes.id);
ppt->setString(myFileAttrOffsets.material, myPointAttributes.material);
}示例5: setInstanceAttributes
/* ******************************************************************************
* Function Name : setInstanceAttributes()
*
* Description : Set the attributes of the instanced primitive
*
* Input Arguments : GEO_Primitive *myGeoPrim
*
* Return Value : void
*
***************************************************************************** */
inline void VRAY_clusterThis::setInstanceAttributes(GEO_Primitive * myGeoPrim)
{
#ifdef DEBUG
cout << "VRAY_clusterThis::setInstanceAttributes() " << endl;
#endif
GEO_Point * ppt;
myGeoPrim->setValue<UT_Vector3>(myInstAttrRefs.Cd, (const UT_Vector3)myPointAttributes.Cd);
myGeoPrim->setValue<fpreal>(myInstAttrRefs.Alpha, (const fpreal)myPointAttributes.Alpha);
myGeoPrim->setValue<UT_Vector3>(myInstAttrRefs.v, (const UT_Vector3)myPointAttributes.v);
myGeoPrim->setValue<UT_Vector3>(myInstAttrRefs.N, (const UT_Vector3)myPointAttributes.N);
// myGeoPrim->setValue<UT_Vector4>(myInstAttrRefs.orient (const UT_Vector4)myPointAttributes.orient);
myGeoPrim->setValue<fpreal>(myInstAttrRefs.pscale, (const fpreal)myPointAttributes.pscale);
myGeoPrim->setValue<int>(myInstAttrRefs.id, (const int)myPointAttributes.id);
myGeoPrim->setValue<int>(myInstAttrRefs.inst_id, (const int)myInstanceNum);
myGeoPrim->setValue<fpreal>(myInstAttrRefs.weight, (const fpreal)myPointAttributes.weight);
myGeoPrim->setValue<fpreal>(myInstAttrRefs.width, (const fpreal)myPointAttributes.width);
myGeoPrim->setString(myInstAttrRefs.material, myPointAttributes.material);
// apply attribues to each vertex
for (int i=0; i < myGeoPrim->getVertexCount(); i++) {
ppt = myGeoPrim->getVertexElement(i).getPt();
ppt->setValue<UT_Vector3>(myInstAttrRefs.pointCd, (const UT_Vector3)myPointAttributes.Cd);
ppt->setValue<float>(myInstAttrRefs.pointAlpha, (const float)myPointAttributes.Alpha);
ppt->setValue<UT_Vector3>(myInstAttrRefs.pointV, (const UT_Vector3)myPointAttributes.v);
ppt->setValue<UT_Vector3>(myInstAttrRefs.pointN, (const UT_Vector3)myPointAttributes.N);
ppt->setValue<float>(myInstAttrRefs.pointPscale, (const float)myPointAttributes.pscale);
ppt->setValue<int>(myInstAttrRefs.pointId, (const int)myPointAttributes.id);
ppt->setValue<int>(myInstAttrRefs.pointInstId, (const int)myInstanceNum);
ppt->setString(myInstAttrRefs.pointMaterial, myPointAttributes.material);
}
}示例6: cleanUp
/* ******************************************************************************
* Function Name : runCVEX()
*
* Description : Run VEX code on the instanced geometry from an external .vex file
*
* Input Arguments : GU_Detail *inst_gdp, GU_Detail *mb_gdp
*
* Return Value : int
*
***************************************************************************** */
int VRAY_clusterThis::runCVEX(GU_Detail * inst_gdp, GU_Detail * mb_gdp, UT_String theCVEXFname, uint method)
{
if (myVerbose == CLUSTER_MSG_DEBUG) {
std::cout << "VRAY_clusterThis::runCVEX() - Processing CVEX arrays - points: " << inst_gdp->points().entries()
<< " primitives: " << inst_gdp->primitives().entries() << std::endl;
}
UT_Vector3 * P = NULL, *POut = NULL, *N = NULL, *NOut = NULL, *v = NULL, *vOut = NULL, *Cd = NULL, *CdOut = NULL;
fpreal * weight = NULL, *weightOut = NULL, *Alpha = NULL, *AlphaOut = NULL, *pscale = NULL, *pscaleOut = NULL;
int * id = NULL, *inst_id = NULL;
// helper local class to clean up memory
class cleanUpCVEXMem {
public:
void cleanUp(UT_Vector3 * P, UT_Vector3 * POut, UT_Vector3 * N, UT_Vector3 * NOut,
UT_Vector3 * v, UT_Vector3 * vOut, UT_Vector3 * Cd, UT_Vector3 * CdOut,
fpreal * weight, fpreal * weightOut, fpreal * Alpha, fpreal * AlphaOut,
fpreal * pscale, fpreal * pscaleOut,
int * id, int * inst_id) {
if (P) delete []P;
if (POut) delete []POut;
if (Cd) delete []Cd;
if (CdOut) delete []CdOut;
if (Alpha) delete []Alpha;
if (AlphaOut) delete []AlphaOut;
if (N) delete []N;
if (NOut) delete []NOut;
if (v) delete []v;
if (vOut) delete []vOut;
if (pscale) delete []pscale;
if (pscaleOut) delete []pscaleOut;
if (weight) delete []weight;
if (weightOut) delete []weightOut;
if (id) delete []id;
if (inst_id) delete []inst_id;
return;
};
} memCleaner;
try {
uint32 num_inst = 0, num_points = 0, num_prim = 0;
long int num = 0;
GEO_Point * ppt;
GEO_Primitive * prim;
UT_Vector4 pos;
CVEX_Context cvex;
GU_Detail * cvex_gdp;
uint32 num_passes = 1;
uint32 mb_pass = 0;
fpreal time = myCurrentTime;
// std::cout << "VRAY_clusterThis::runCVEX() - time: " << time << endl;
if (myDoMotionBlur == CLUSTER_MB_DEFORMATION)
num_passes = 2;
if (myPrimType == CLUSTER_POINT) {
num_inst = myInstanceNum;
// num_inst = inst_gdp->points().entries();
num_points = inst_gdp->points().entries();
// std::cout << "VRAY_clusterThis::runCVEX() - num_inst: " << num_inst << std::endl;
} else {
num_inst = myInstanceNum;
num_prim = inst_gdp->primitives().entries();
num_points = inst_gdp->points().entries();
num_inst = num_points;
// std::cout << "VRAY_clusterThis::runCVEX() - num_inst: " << num_inst << " num_points: " << num_points << " num_prim: " << num_prim << std::endl;
}
UT_Vector3 primAttr, ptAttr;
GA_RWAttributeRef primN_ref, primV_ref, primCd_ref, primAlpha_ref, primPscale_ref, primId_ref, primWeight_ref;
GA_RWAttributeRef ptN_ref, ptV_ref, ptCd_ref, ptAlpha_ref, ptPscale_ref, ptId_ref, ptInstId_ref;
if (myPrimType == CLUSTER_POINT) {
// Allocate the space for the point positions
P = new UT_Vector3[num_points];
POut = new UT_Vector3[num_points];
if (myCVEXPointVars.cvex_Cd_pt) {
Cd = new UT_Vector3[num_points];
CdOut = new UT_Vector3[num_points];
//.........这里部分代码省略.........
示例7: LogInfo
Geo2Emp::ErrorCode Geo2Emp::loadParticleShape( const Nb::Body* pBody )
{
if (!_gdp)
{
//If we don't have a GDP for writing data into Houdini, return error.
return EC_NULL_WRITE_GDP;
}
const Nb::ParticleShape* pShape;
LogInfo() << "=============== Loading particle shape ===============" << std::endl;
pShape = pBody->queryConstParticleShape();
if (!pShape)
{
//std::cout << "Received NULL particle shape!" << std::endl;
return EC_NO_PARTICLE_SHAPE;
}
//Attribute Lookup Tables
std::vector< GEO_AttributeHandle > attribLut;
std::vector<GeoAttributeInfo> attribInfo; //houdini types for the naiad channels.
GeoAttributeInfo* pInfo;
std::string attrName;
//We have a valid particle shape. Start copying particle data over to the GDP
int64_t size = pShape->size();
int channelCount = pShape->channelCount();
GEO_Point *ppt;
GEO_AttributeHandle attr;
GU_PrimParticle *pParticle;
std::vector<std::string> houdiniNames; //houdini names that correspond to naiad channels.
std::vector<GB_AttribType> houdiniTypes; //houdini types for the naiad channels.
//Default values for attributes
float zero3f[3] = {0,0,0};
float zero1f = 0;
//int zero3i[3] = {0,0,0};
int zero1i = 0;
const void* data;
LogVerbose() << "Particle shape size: " << size << std::endl;
LogVerbose() << "Particle shape channel count: " << channelCount << std::endl;
LogVerbose() << "Building particle primitive...";
pParticle = GU_PrimParticle::build(_gdp, 0);
LogVerbose() << "done." << std::endl;
attribLut.clear();
attribInfo.clear();
attribLut.resize( channelCount );
attribInfo.resize( channelCount );
//Prepare for a blind copy of Naiad channels to Houdini attributes.
//Iterate over the channels and create the corresponding attributes in the GDP
for (int i = 0; i < channelCount; i++)
{
//std::cout << "channel: " << i << std::endl;
const Nb::ChannelCowPtr& chan = pShape->channel(i);
if ( _empAttribMangle.find( chan->name() ) != _empAttribMangle.end() )
attrName = _empAttribMangle[ chan->name() ];
else
attrName = chan->name();
LogDebug() << "Processing EMP Channel: " << chan->name() << "; mangled: " << attrName << std::endl;
//Determine the attribute type, and store it
pInfo = &(attribInfo[ i ]);
pInfo->supported = false;
pInfo->size = 0;
pInfo->use64 = false;
if (attrName.compare("P") == 0)
//Don't treat position as an attribute. This needs to be handled separately.
continue;
switch ( chan->type() )
{
case Nb::ValueBase::IntType:
pInfo->type = GB_ATTRIB_INT;
pInfo->entries = 1;
pInfo->size = sizeof(int);
pInfo->supported = true;
data = &zero1i;
break;
case Nb::ValueBase::Int64Type: //NOTE: This might need to be handled differently ... just remember this 'hack'
pInfo->type = GB_ATTRIB_INT;
pInfo->entries = 1;
pInfo->size = sizeof(int);
pInfo->supported = true;
pInfo->use64 = true;
data = &zero1i;
break;
case Nb::ValueBase::FloatType:
pInfo->type = GB_ATTRIB_FLOAT;
pInfo->size = sizeof(float);
pInfo->entries = 1;
pInfo->supported = true;
data = &zero1f;
//.........这里部分代码省略.........
示例8: exportParticlesDetail
//.........这里部分代码省略.........
//I add the new item to the deque, THEN initialize it since a deque will not move the object around and this allows
//me to allocate the float array and not have to worry about the object getting deleted too early.
switch( node->getStorageClass() ){
case GA_STORECLASS_FLOAT:
if( node->getTupleSize()==3 ){
m_vectorAttrs.push_back( bound_attribute<float>() );
m_vectorAttrs.back().attr = gdp->findPointAttribute(node->getName());
m_vectorAttrs.back().count = node->getTupleSize();
m_vectorAttrs.back().data = new float[m_vectorAttrs.back().count];
type = prtio::data_types::type_float16;
if( channelIsDesired ){
type = itChannel->second.first;
if( itChannel->second.second != m_vectorAttrs.back().count )
continue;
}
ostream.bind( channelName, m_vectorAttrs.back().data, m_vectorAttrs.back().count, type );
} else {
m_floatAttrs.push_back( bound_attribute<float>() );
m_floatAttrs.back().attr = gdp->findPointAttribute( node->getName() );
m_floatAttrs.back().count = node->getTupleSize();
m_floatAttrs.back().data = new float[m_floatAttrs.back().count];
type = prtio::data_types::type_float16;
if( channelIsDesired ){
type = itChannel->second.first;
if( itChannel->second.second != m_floatAttrs.back().count )
continue;
}
ostream.bind( channelName, m_floatAttrs.back().data, m_floatAttrs.back().count, type );
}
break;
case GA_STORECLASS_INT:
m_intAttrs.push_back( bound_attribute<int>() );
m_intAttrs.back().attr = gdp->findPointAttribute( node->getName() );
m_intAttrs.back().count = node->getTupleSize();
m_intAttrs.back().data = new int[m_intAttrs.back().count];
type = prtio::data_types::type_int32;
if( channelIsDesired ){
type = itChannel->second.first;
if( itChannel->second.second != m_intAttrs.back().count )
continue;
}
ostream.bind( channelName, m_intAttrs.back().data, m_intAttrs.back().count, type );
break;
default:
break;
}
}
}
try{
ostream.open( filePath );
} catch( const std::ios::failure& e ) {
std::cerr << e.what() << std::endl;
throw HOM_OperationFailed( "Failed to open the file" );
}
GA_IndexMap map = gdp->getPointMap();
UT_Vector3 p;
GEO_Point* pt;
GA_Index indexSize = map.indexSize();
GA_Offset offset;
for( int i = 0 ; i < indexSize; i++ ) {
offset = map.offsetFromIndex( i );
p = gdp->getPos3( offset );
posVal[0] = p.x();
posVal[1] = p.y();
posVal[2] = -1 * p.z();
//TODO: Remove the GEO_Point object that is now deprecated.
pt = ( GEO_Point* )gdp->getGBPoint( offset );
//TODO: Convert this into appropriate time values. Is it seconds or frames or what?!
if( lifeAttrib.isValid() )
pt->get( lifeAttrib, lifeVal, 2 );
for( std::deque< bound_attribute<float> >::iterator it = m_floatAttrs.begin(), itEnd = m_floatAttrs.end(); it != itEnd; ++it )
pt->get( it->attr, it->data, it->count );
for( std::deque< bound_attribute<float> >::iterator it = m_vectorAttrs.begin(), itEnd = m_vectorAttrs.end(); it != itEnd; ++it ) {
pt->get( it->attr, it->data, it->count );
//TODO: Optionally transform into some consistent world space for PRT files.
}
for( std::deque< bound_attribute<int> >::iterator it = m_intAttrs.begin(), itEnd = m_intAttrs.end(); it != itEnd; ++it )
pt->get( it->attr, it->data, it->count );
ostream.write_next_particle();
}
ostream.close();
}示例9: srand
void GR_rmanPtc::renderWire( GU_Detail *gdp,
RE_Render &ren,
const GR_AttribOffset &ptinfo,
const GR_DisplayOption *dopt,
float lod,
const GU_PrimGroupClosure *hidden_geometry
)
{
int i, nprim;
GEO_Primitive *prim;
UT_Vector3 v3;
rmanPtcSop::rmanPtcDetail *detail = dynamic_cast<rmanPtcSop::rmanPtcDetail*>(gdp);
if ( !detail )
return;
// rebuild our display list
if ( detail->redraw )
{
srand(0);
GEO_PointList &points = detail->points();
int display_channel = detail->display_channel;
// render as points
GEO_Point *pt = 0;
UT_Vector4 pos;
float col[3] = {1.0,1.0,1.0};
if ( !detail->use_disk )
{
ren.pushPointSize(detail->point_size);
ren.beginPoint();
}
for ( unsigned int i=0; i<points.entries(); ++i )
{
if ( rand()/(float)RAND_MAX<=detail->display_probability )
{
// point position
pt = points[i];
pos = pt->getPos();
// display colour
float *ptr = NULL;
if (detail->attributes.size() >0) {
ptr = pt->castAttribData<float>(
detail->attributes[display_channel] );
if (ptr) {
if ( detail->attribute_size[display_channel]==1)
col[0] = col[1] = col[2] = ptr[0];
else
{
col[0] = ptr[0];
col[1] = ptr[1];
col[2] = ptr[2];
}
}
}
// draw point
if ( !detail->use_cull_bbox ||
detail->cull_bbox.isInside( pos ) )
{
if ( !detail->use_disk )
{
// render as points
ren.setColor( col[0], col[1], col[2], 1 );
ren.vertex3DW( pos.x(), pos.y(), pos.z() );
}
else
{
// render as disks
UT_Vector3 n = *pt->castAttribData<UT_Vector3>(detail->N_attrib);
float r = *pt->castAttribData<float>(detail->R_attrib);
n.normalize();
UT_Vector3 ref(1,0,0);
UT_Vector3 up = ref;
up.cross(n);
up.normalize();
UT_Vector3 right = up;
right.cross(n);
right.normalize();
UT_DMatrix4 mat(
right.x(), right.y(), right.z(), 0,
up.x(), up.y(), up.z(), 0,
n.x(), n.y(), n.z(), 0,
pos.x(), pos.y(), pos.z(), 1 );
ren.pushMatrix();
ren.multiplyMatrix(mat);
ren.pushColor( UT_Color( UT_RGB, col[0], col[1], col[2] ) );
ren.circlefW( 0, 0, detail->point_size * r, 8 );
ren.popColor();
ren.popMatrix();
}
}
}
}
if ( !detail->use_disk )
{
//.........这里部分代码省略.........
示例10: SUBSTEPS
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);
//.........这里部分代码省略.........
示例11: render
/* ******************************************************************************
* Function Name : render()
*
* Description : Render VRAY_clusterThis object
*
* Input Arguments : None
*
* Return Value : None
*
***************************************************************************** */
void VRAY_clusterThis::render()
{
GU_Detail * gdp, *inst_gdp, *mb_gdp, *file_gdp;
GEO_Point * ppt;
// GEO_AttributeHandle attrHandleVelocity, attrHandleForce, attrHandleVorticity, attrHandleNormal, attrHandleNumNeighbors,
// attrHandleTextureUV, attrHandleMass, attrHandleAge, attrHandleTemperature, attrHandleID,
// attrHandleDensity, attrHandleViscosity, attrHandlePressure, attrHandlePscale;
long int point_num = 0;
static bool rendered = false;
if(myVerbose > CLUSTER_MSG_QUIET) {
std::cout << "VRAY_clusterThis::render() - Version: " << DCA_VERSION << std::endl;
std::cout << "VRAY_clusterThis::render() - Built for Houdini Version: " << UT_MAJOR_VERSION
<< "." << UT_MINOR_VERSION << "." << UT_BUILD_VERSION_INT << std::endl;
std::cout << "VRAY_clusterThis::render() - Instancing ..." << endl;
}
try {
// cout << "VM_GEO_clusterThis OTL version: " << myOTLVersion << endl;
// if(myOTLVersion != DCA_VERSION) {
// cout << "VM_GEO_clusterThis OTL is wrong version: " << myOTLVersion << ", should be version: " << DCA_VERSION << ", please install correct version." << endl;
// throw VRAY_clusterThis_Exception ( "VRAY_clusterThis::render() VM_GEO_clusterThis OTL is wrong version!", 1 );
// }
if(!rendered || !myUseTempFile) {
void * handle = VRAY_Procedural::queryObject(0);
gdp = VRAY_Procedural::allocateGeometry();
if(myUseGeoFile) {
// If the file failed to load, throw an exception
if(!(gdp->load((const char *)mySrcGeoFname).success()))
throw VRAY_clusterThis_Exception("VRAY_clusterThis::render() - Failed to read source geometry file ", 1);
if(myVerbose > CLUSTER_MSG_INFO)
cout << "VRAY_clusterThis::render() - Successfully loaded source geo file: " << mySrcGeoFname << endl;
}
else {
gdp->copy(*VRAY_Procedural::queryGeometry(handle, 0));
if(myVerbose > CLUSTER_MSG_INFO)
cout << "VRAY_clusterThis::render() - Copied incoming geometry" << endl;
}
gdp->getBBox(&myBox);
// std::cout << "VRAY_clusterThis::render() - gdp->getBBox(&myBox): " << myBox << std::endl;
VRAY_Procedural::querySurfaceShader(handle, myMaterial);
myMaterial.harden();
// myPointAttributes.material = myMaterial;
// const char ** getSParm (int token) const
// cout << "VRAY_clusterThis::render() getSParm: " << *getSParm (0) << endl;
#ifdef DEBUG
cout << "VRAY_clusterThis::render() myMaterial: " << myMaterial << endl;
#endif
myLOD = getLevelOfDetail(myBox);
if(myVerbose > CLUSTER_MSG_INFO)
cout << "VRAY_clusterThis::render() myLOD: " << myLOD << endl;
// Get the number if points of the incoming geometery, calculate an interval for reporting the status of the instancing to the user
long int num_points = (long int) gdp->points().entries();
long int stat_interval = (long int)(num_points * 0.10) + 1;
if(myVerbose > CLUSTER_MSG_QUIET)
cout << "VRAY_clusterThis::render() Number of points of incoming geometry: " << num_points << endl;
myObjectName = VRAY_Procedural::queryObjectName(handle);
// cout << "VRAY_clusterThis::render() Object Name: " << myObjectName << endl;
// cout << "VRAY_clusterThis::render() Root Name: " << queryRootName() << endl;
// DEBUG stuff ...
// changeSetting("object:geo_velocityblur", "on");
UT_String str;
int vblur = 0;
import("object:velocityblur", &vblur, 0);
//.........这里部分代码省略.........
示例12: preProcess
void VRAY_clusterThis::preProcess(GU_Detail * gdp)
{
GEO_Point * ppt;
long int num_points = (long int) gdp->points().entries();
long int stat_interval = (long int)(num_points * 0.10) + 1;
for(uint32 i = gdp->points().entries(); i-- > 0;) {
ppt = gdp->points()(i);
myPointList.append(i);
}
// If the user wants to build grids for pre processing
// TODO: Should this be an option? There may be functions/features that will depend on this ... discuss!
if(!myPreProcess)
return;
if(myVerbose > CLUSTER_MSG_INFO)
cout << "VRAY_clusterThis::preProcess() Pre Processing Voxels" << std::endl;
// openvdb::ScalarGrid::Accessor accessor;
// openvdb::FloatTree myTree;
openvdb::FloatTree::ConstPtr myGeoTreePtr;
openvdb::VectorTree::ConstPtr myGeoGradTreePtr;
ParticleList paGeoList(gdp, myPreVDBRadiusMult, myPreVDBVelocityMult);
openvdb::tools::PointSampler myGeoSampler, geoGradSampler;
// openvdb::tools::GridSampling<openvdb::FloatTree> myGridSampler;
if(myVerbose == CLUSTER_MSG_DEBUG)
std::cout << "VRAY_clusterThis::preProcess() paGeoList.size() ... " << paGeoList.size() << std::endl;
if(paGeoList.size() != 0) {
hvdb::Interrupter boss("VRAY_clusterThis::preProcess() Converting particles to level set");
Settings settings;
settings.mRadiusMin = myPreRadiusMin;
settings.mRasterizeTrails = myPreRasterType;
settings.mDx = myPreDx; // only used for rasterizeTrails()
settings.mFogVolume = myPreFogVolume;
settings.mGradientWidth = myPreGradientWidth; // only used for fog volume
float background;
// background in WS units
if(myPreWSUnits)
background = myPreBandWidth;
// background NOT in WS units
else
background = myPreVoxelSize * myPreBandWidth;
// Construct a new scalar grid with the specified background value.
openvdb::math::Transform::Ptr transform =
openvdb::math::Transform::createLinearTransform(myPreVoxelSize);
// openvdb::ScalarGrid::Ptr myGeoGrid = openvdb::ScalarGrid::create(background);
myGeoGrid = openvdb::ScalarGrid::create(background);
myGeoGrid->setTransform(transform);
myGeoGrid->setGridClass(openvdb::GRID_LEVEL_SET);
// Perform the particle conversion.
this->convert(myGeoGrid, paGeoList, settings, boss);
if(myVerbose == CLUSTER_MSG_DEBUG) {
std::cout << "VRAY_clusterThis::preProcess() - activeVoxelCount(): "
<< myGeoGrid->activeVoxelCount() << std::endl;
std::cout << "VRAY_clusterThis::preProcess() - background: "
<< myGeoGrid->background() << std::endl;
}
// Insert the new grid into the ouput detail.
UT_String gridNameStr = "ClusterGrid";
myGeoGrid->insertMeta("float type", openvdb::StringMetadata("averaged_velocity"));
myGeoGrid->insertMeta("name", openvdb::StringMetadata((const char *)gridNameStr));
myGeoGrid->insertMeta("VoxelSize", openvdb::FloatMetadata(myPreVoxelSize));
myGeoGrid->insertMeta("background", openvdb::FloatMetadata(background));
UT_Vector3 pos, seed_pos, currVel;
// const GA_PointGroup * sourceGroup = NULL;
long int pt_counter = 0;
float radius = 5.0f;
if(myVerbose > CLUSTER_MSG_INFO)
std::cout << "VRAY_clusterThis::preProcess() - Massaging data ... " << std::endl;
long int pointsFound = 0;
GEO_AttributeHandle inst_vel_gah = gdp->getPointAttribute("v");
GEO_AttributeHandle source_vel_gah = gdp->getPointAttribute("v");
GEO_AttributeHandle inst_N_gah = gdp->getPointAttribute("N");
//.........这里部分代码省略.........
示例13: error
OP_ERROR
SOP_IntersectRay::cookMySop(OP_Context &context)
{
double t;
float edgelength, primarea, generatepoints;
int verbose;
// We optionally add points in self-penetration places:
GB_PointGroup *hitPointsGroup;
UT_RefArray<UT_Vector3> hitPoints;
if (lockInputs(context) >= UT_ERROR_ABORT)
return error();
t = context.getTime();
duplicatePointSource(0, context);
edgelength = EDGELENGTH(t);
primarea = PRIMAREA(t);
verbose = VERBOSE(t);
generatepoints = GENERATEPOINTS(t);
// Normals:
GEO_AttributeHandle nH;
GEO_AttributeHandle cdH;
nH = gdp->getAttribute(GEO_POINT_DICT, "N");
cdH = gdp->getAttribute(GEO_POINT_DICT, "Cd");
// RayInfo parms:
//float max = 1E18f; // Max specified by edge length...
float min = 0.0f;
float tol = 1e-1F;
// Rayhit objects:
GU_RayFindType itype = GU_FIND_ALL;
GU_RayIntersect intersect = GU_RayIntersect(gdp);
// Profile:
//Timer timer = Timer();
//float rayhit_time = 0;
//float vertex_time = 0;
// Here we determine which groups we have to work on.
if (error() < UT_ERROR_ABORT && cookInputGroups(context) < UT_ERROR_ABORT)
{
UT_AutoInterrupt progress("Checking for self-intersections...");
const GEO_Primitive *ppr;
FOR_ALL_GROUP_PRIMITIVES(gdp, myGroup, ppr)
{
// Check if user requested abort
if (progress.wasInterrupted())
break;
// Get rid of primitives smaller than primarea:
if ( ppr->calcArea() < primarea )
continue;
for (int j = 0; j < ppr->getVertexCount() - 1; j++)
{
// Get data;
// TODO: This is extremally inefficent.
// TODO: Why do we crash with uv vetrex attributes!?
const GEO_Vertex ppv1 = ppr->getVertex(j);
const GEO_Vertex ppv2 = ppr->getVertex(j+1);
const GEO_Point *ppt1 = ppv1.getPt();
const GEO_Point *ppt2 = ppv2.getPt();
// Vertices positions:
UT_Vector3 p1 = ppt1->getPos();
UT_Vector3 p2 = ppt2->getPos();
// Ray direction:
p2 = p2 - p1;
// Get rid of edges shorter than edgelength:
if (p2.length() < edgelength)
continue;
// hit info with max distance equal edge length:
GU_RayInfo hitinfo = GU_RayInfo(p2.length(), min, itype, tol);
p2.normalize();
// Send ray:
if (intersect.sendRay(p1, p2, hitinfo))
{
UT_RefArray<GU_RayInfoHit> hits = *(hitinfo.myHitList);
for(int j = 0; j < hits.entries(); j++)
{
const GEO_Primitive *prim = hits[j].prim;
const GEO_PrimPoly *poly = (const GEO_PrimPoly *) prim; //TODO: Prims only?
// We are interested only ff points are not part of prims...:
if (poly->find(*ppt1) == -1 && poly->find(*ppt2)== -1)
{
if (verbose)
printf("Edge: %i-%i intersects with prim:%d \n",ppt1->getNum(), ppt2->getNum(), prim->getNum());
// Save hit position as points:
if (generatepoints)
{
UT_Vector4 pos;
float u = hits[j].u;
//.........这里部分代码省略.........
示例14: inputGeo
//.........这里部分代码省略.........
}
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;
GA_RWHandleI cntt(gdp->addIntTuple(GA_ATTRIB_POINT, "count", 4, GA_Defaults(1.0)));
GB_AttributeRef dt(gdp->addDiffuseAttribute(GEO_POINT_DICT));
gdp->addVariableName("Cd","Cd");
UT_Vector3 current(0,0,0);
float C[3] = { 0,0,0 };
float R=1.0f;
bool trackRadii = (evalInt("trackradii",0,now)!=0);
float rScale = evalFloat("radiiscale",0,now);
GB_AttributeRef rt;
if(trackRadii)
{
float one=1.0f;
rt = gdp->addPointAttrib("width",4,GB_ATTRIB_FLOAT,&one);
if(!GBisAttributeRefValid(rt)) trackRadii=false;
else gdp->addVariableName("width","WIDTH");
};
float zero=0.0f;
GB_AttributeRef pt = gdp->addPointAttrib("parameter",4,GB_ATTRIB_FLOAT,&zero);
if(GBisAttributeRefValid(pt)) gdp->addVariableName("parameter","PARAMETER");
float param=0.0f;
srand(0);
UT_Interrupt* boss = UTgetInterrupt();
boss->opStart("Computing...");
for(int i=-50;i<total;i++)
{
bool ok = false;
if (boss->opInterrupt()) break;
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(clip)
{
if(!bbox.isInside(current)) continue;
};
if(ok)
{
GEO_Point* p = gdp->appendPoint();
p->setPos(current);
float* Cd=p->castAttribData<float>(dt);
if(useRamp)
{
ramp.rampLookup(param,C);
}
memcpy(Cd,C,12);
if(trackRadii)
{
float* _R = p->castAttribData<float>(rt);
*_R=rScale*R;
};
if(GBisAttributeRefValid(pt))
{
float* _p = p->castAttribData<float>(pt);
*_p=param;
}
};
};
boss->opEnd();
delete [] daemons;
return error();
};示例15: error
OP_ERROR
SOP_Ocean::cookMySop(OP_Context &context)
{
float now = context.getTime();
//std::cout << "cook ocean, t = " << now << std::endl;
// lock inputs
if (lockInputs(context) >= UT_ERROR_ABORT )
{
return error();
}
GEO_Point *ppt;
UT_Interrupt *boss;
// Check to see that there hasn't been a critical error in cooking the SOP.
if (error() < UT_ERROR_ABORT)
{
boss = UTgetInterrupt();
// Start the interrupt server
boss->opStart("Updating Ocean");
duplicatePointSource(0,context);
int gridres = 1 << int(GRID_RES(now));
float stepsize = GRID_SIZE(now) / (float)gridres;
bool do_chop = CHOP(now);
bool do_jacobian = JACOBIAN(now);
bool do_normals = NORMALS(now) && !do_chop;
if (!_ocean || _ocean_needs_rebuild)
{
if (_ocean)
{
delete _ocean;
}
if (_ocean_context)
{
delete _ocean_context;
}
_ocean = new drw::Ocean(gridres,gridres,stepsize,stepsize,
V(0),L(0),1.0,W(0),1-DAMP(0),ALIGN(0),
DEPTH(0),SEED(0));
_ocean_scale = _ocean->get_height_normalize_factor();
_ocean_context = _ocean->new_context(true,do_chop,do_normals,do_jacobian);
_ocean_needs_rebuild = false;
// std::cout << "######### SOP, rebuilt ocean, norm_factor = " << _ocean_scale
// << " chop = " << do_chop
// << " norm = " << do_normals
// << " jacobian = " << do_jacobian
// << std::endl;
}
float chop_amount = CHOPAMOUNT(now);
// sum up the waves at this timestep
_ocean->update(TIME(now),*_ocean_context,true,do_chop,do_normals,do_jacobian,
_ocean_scale * SCALE(now),chop_amount);
bool linterp = ! INTERP(now);
// get our attribute indices
GA_RWAttributeRef normal_index;
GA_RWAttributeRef jminus_index;
GA_RWAttributeRef eminus_index;
if (do_normals)
{
normal_index = gdp->addNormalAttribute(GEO_POINT_DICT);
}
if (do_jacobian)
{
// jminus_index = gdp->addPointAttrib("mineigval",sizeof(float),GB_ATTRIB_FLOAT,0);
// eminus_index = gdp->addPointAttrib("mineigvec",sizeof(UT_Vector3),GB_ATTRIB_VECTOR,0);
jminus_index = gdp->addTuple(GA_STORE_REAL32,GA_ATTRIB_POINT,"mineigval",1,GA_Defaults(0));
eminus_index = gdp->addFloatTuple(GA_ATTRIB_POINT,"mineigvec",1,GA_Defaults(0));
}
// this is not that fast, can it be done quicker ???
GA_FOR_ALL_GPOINTS(gdp, ppt)
{
UT_Vector4 p = ppt->getPos();
if (linterp)
{
_ocean_context->eval_xz(p(0),p(2));
}
else
{
_ocean_context->eval2_xz(p(0),p(2));
//.........这里部分代码省略.........