void ObjMesh::Init()
{
ReadFromFile(filePath.c_str(), scale_factor);
ComputeNormal();
ApplyTransformation();
ComputeAABB();
}
void ProgressBar::Draw(Renderer & renderer)
{
ApplyTransformation(renderer);
renderer.SetColor(m_frameColor);
renderer.DrawShape(m_frameShape);
renderer.SetColor(m_innerColor);
renderer.DrawShape(m_innerShape);
}
double ComputeRMSD(int nCoords, const Vector * const *masterCoords,
const Vector * const *dependentCoords, const Matrix *transformDependentToMaster)
{
Vector x;
double rmsd = 0.0;
int n = 0;
for (int c=0; c<nCoords; ++c) {
if (!dependentCoords[c] || !masterCoords[c]) continue;
x = *(dependentCoords[c]);
if (transformDependentToMaster)
ApplyTransformation(&x, *transformDependentToMaster);
rmsd += (*(masterCoords[c]) - x).lengthSquared();
++n;
}
if (n == 0) {
WARNINGMSG("ComputeRMSD() - received no non-NULL coordinates");
return 0.0;
}
rmsd = sqrt(rmsd / n);
return rmsd;
}
AtNode * ProcessPointsBase(
IPoints & prim, ProcArgs & args,
SampleTimeSet & sampleTimes,
std::vector<AtPoint> & vidxs,
std::vector<float> & radius,
MatrixSampleMap * xformSamples )
{
if ( !prim.valid() )
{
return NULL;
}
Alembic::AbcGeom::IPointsSchema &ps = prim.getSchema();
TimeSamplingPtr ts = ps.getTimeSampling();
sampleTimes.insert( ts->getFloorIndex(args.frame / args.fps, ps.getNumSamples()).second );
std::string name = args.nameprefix + prim.getFullName();
AtNode * instanceNode = NULL;
std::string cacheId;
SampleTimeSet singleSampleTimes;
singleSampleTimes.insert( ts->getFloorIndex(args.frame / args.fps, ps.getNumSamples()).second );
ICompoundProperty arbGeomParams = ps.getArbGeomParams();
ISampleSelector frameSelector( *singleSampleTimes.begin() );
std::vector<std::string> tags;
//get tags
if ( arbGeomParams != NULL && arbGeomParams.valid() )
{
if (arbGeomParams.getPropertyHeader("mtoa_constant_tags") != NULL)
{
const PropertyHeader * tagsHeader = arbGeomParams.getPropertyHeader("mtoa_constant_tags");
if (IStringGeomParam::matches( *tagsHeader ))
{
IStringGeomParam param( arbGeomParams, "mtoa_constant_tags" );
if ( param.valid() )
{
IStringGeomParam::prop_type::sample_ptr_type valueSample =
param.getExpandedValue( frameSelector ).getVals();
if ( param.getScope() == kConstantScope || param.getScope() == kUnknownScope)
{
Json::Value jtags;
Json::Reader reader;
if(reader.parse(valueSample->get()[0], jtags))
for( Json::ValueIterator itr = jtags.begin() ; itr != jtags.end() ; itr++ )
{
tags.push_back(jtags[itr.key().asUInt()].asString());
}
}
}
}
}
}
if ( args.makeInstance )
{
std::ostringstream buffer;
AbcA::ArraySampleKey sampleKey;
for ( SampleTimeSet::iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I )
{
ISampleSelector sampleSelector( *I );
ps.getPositionsProperty().getKey(sampleKey, sampleSelector);
buffer << GetRelativeSampleTime( args, (*I) ) << ":";
sampleKey.digest.print(buffer);
buffer << ":";
}
cacheId = buffer.str();
instanceNode = AiNode( "ginstance" );
AiNodeSetStr( instanceNode, "name", name.c_str() );
args.createdNodes.push_back(instanceNode);
if ( args.proceduralNode )
{
AiNodeSetByte( instanceNode, "visibility",
AiNodeGetByte( args.proceduralNode, "visibility" ) );
}
else
{
AiNodeSetByte( instanceNode, "visibility", AI_RAY_ALL );
}
ApplyTransformation( instanceNode, xformSamples, args );
NodeCache::iterator I = g_meshCache.find(cacheId);
// parameters overrides
if(args.linkOverride)
ApplyOverrides(name, instanceNode, tags, args);
// shader assignation
if (nodeHasParameter( instanceNode, "shader" ) )
{
if(args.linkShader)
{
ApplyShaders(name, instanceNode, tags, args);
}
else
{
AtArray* shaders = AiNodeGetArray(args.proceduralNode, "shader");
if (shaders->nelements != 0)
AiNodeSetArray(instanceNode, "shader", AiArrayCopy(shaders));
}
}
if ( I != g_meshCache.end() )
{
AiNodeSetPtr(instanceNode, "node", (*I).second );
return NULL;
}
}
bool isFirstSample = true;
float radiusPoint = 0.1f;
if (AiNodeLookUpUserParameter(args.proceduralNode, "radiusPoint") !=NULL )
radiusPoint = AiNodeGetFlt(args.proceduralNode, "radiusPoint");
bool useVelocities = false;
if ((sampleTimes.size() == 1) && (args.shutterOpen != args.shutterClose))
{
// no sample, and motion blur needed, let's try to get velocities.
if(ps.getVelocitiesProperty().valid())
useVelocities = true;
}
for ( SampleTimeSet::iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I, isFirstSample = false)
{
ISampleSelector sampleSelector( *I );
Alembic::AbcGeom::IPointsSchema::Sample sample = ps.getValue( sampleSelector );
Alembic::Abc::P3fArraySamplePtr v3ptr = sample.getPositions();
size_t pSize = sample.getPositions()->size();
if(useVelocities && isFirstSample)
{
float scaleVelocity = 1.0f;
if (AiNodeLookUpUserParameter(args.proceduralNode, "scaleVelocity") !=NULL )
scaleVelocity = AiNodeGetFlt(args.proceduralNode, "scaleVelocity");
vidxs.resize(pSize*2);
Alembic::Abc::V3fArraySamplePtr velptr = sample.getVelocities();
float timeoffset = ((args.frame / args.fps) - ts->getFloorIndex((*I), ps.getNumSamples()).second) * args.fps;
for ( size_t pId = 0; pId < pSize; ++pId )
{
Alembic::Abc::V3f posAtOpen = ((*v3ptr)[pId] + (*velptr)[pId] * scaleVelocity *-timeoffset);
AtPoint pos1;
pos1.x = posAtOpen.x;
pos1.y = posAtOpen.y;
pos1.z = posAtOpen.z;
vidxs[pId]= pos1;
Alembic::Abc::V3f posAtEnd = ((*v3ptr)[pId] + (*velptr)[pId]* scaleVelocity *(1.0f-timeoffset));
AtPoint pos2;
pos2.x = posAtEnd.x;
pos2.y = posAtEnd.y;
pos2.z = posAtEnd.z;
vidxs[pId+pSize]= pos2;
radius.push_back(radiusPoint);
}
}
else
// not motion blur or correctly sampled particles
{
for ( size_t pId = 0; pId < pSize; ++pId )
{
AtPoint pos;
pos.x = (*v3ptr)[pId].x;
pos.y = (*v3ptr)[pId].y;
pos.z = (*v3ptr)[pId].z;
vidxs.push_back(pos);
radius.push_back(radiusPoint);
}
}
}
AtNode* pointsNode = AiNode( "points" );
if (!pointsNode)
{
AiMsgError("Failed to make points node for %s",
prim.getFullName().c_str());
return NULL;
}
args.createdNodes.push_back(pointsNode);
if ( instanceNode != NULL)
{
AiNodeSetStr( pointsNode, "name", (name + ":src").c_str() );
}
else
{
AiNodeSetStr( pointsNode, "name", name.c_str() );
}
if(!useVelocities)
{
AiNodeSetArray(pointsNode, "points",
AiArrayConvert( vidxs.size() / sampleTimes.size(),
sampleTimes.size(), AI_TYPE_POINT, (void*)(&(vidxs[0]))
));
AiNodeSetArray(pointsNode, "radius",
AiArrayConvert( vidxs.size() / sampleTimes.size(),
sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(radius[0]))
));
if ( sampleTimes.size() > 1 )
{
std::vector<float> relativeSampleTimes;
relativeSampleTimes.reserve( sampleTimes.size() );
for (SampleTimeSet::const_iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I )
{
chrono_t sampleTime = GetRelativeSampleTime( args, (*I) );
relativeSampleTimes.push_back(sampleTime);
}
AiNodeSetArray( pointsNode, "deform_time_samples",
AiArrayConvert(relativeSampleTimes.size(), 1,
AI_TYPE_FLOAT, &relativeSampleTimes[0]));
}
}
else
{
AiNodeSetArray(pointsNode, "points",
AiArrayConvert( vidxs.size() / 2,
2, AI_TYPE_POINT, (void*)(&(vidxs[0]))
));
AiNodeSetArray(pointsNode, "radius",
AiArrayConvert( vidxs.size() /2 / sampleTimes.size(),
sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(radius[0]))
));
AiNodeSetArray( pointsNode, "deform_time_samples",
AiArray(2, 1, AI_TYPE_FLOAT, 0.f, 1.f));
}
AddArbitraryGeomParams( arbGeomParams, frameSelector, pointsNode );
if ( instanceNode == NULL )
{
if ( xformSamples )
{
ApplyTransformation( pointsNode, xformSamples, args );
}
return pointsNode;
}
else
{
AiNodeSetByte( pointsNode, "visibility", 0 );
AiNodeSetInt( pointsNode, "mode", 1 );
AiNodeSetPtr(instanceNode, "node", pointsNode );
g_meshCache[cacheId] = pointsNode;
return pointsNode;
}
}
AtNode * ProcessPolyMeshBase(
primT & prim, ProcArgs & args,
SampleTimeSet & sampleTimes,
std::vector<AtUInt32> & vidxs,
int subdiv_iterations,
MatrixSampleMap * xformSamples,
const std::string & facesetName = "" )
{
if ( !prim.valid() )
{
return NULL;
}
typename primT::schema_type &ps = prim.getSchema();
TimeSamplingPtr ts = ps.getTimeSampling();
if ( ps.getTopologyVariance() != kHeterogenousTopology )
{
GetRelevantSampleTimes( args, ts, ps.getNumSamples(), sampleTimes );
}
else
{
sampleTimes.insert( args.frame / args.fps );
}
std::string name = args.nameprefix + prim.getFullName();
AtNode * instanceNode = NULL;
std::string cacheId;
if ( args.makeInstance )
{
std::ostringstream buffer;
AbcA::ArraySampleKey sampleKey;
for ( SampleTimeSet::iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I )
{
ISampleSelector sampleSelector( *I );
ps.getPositionsProperty().getKey(sampleKey, sampleSelector);
buffer << GetRelativeSampleTime( args, (*I) ) << ":";
sampleKey.digest.print(buffer);
buffer << ":";
}
buffer << "@" << subdiv_iterations;
buffer << "@" << facesetName;
cacheId = buffer.str();
instanceNode = AiNode( "ginstance" );
AiNodeSetStr( instanceNode, "name", name.c_str() );
args.createdNodes.push_back(instanceNode);
if ( args.proceduralNode )
{
AiNodeSetInt( instanceNode, "visibility",
AiNodeGetInt( args.proceduralNode, "visibility" ) );
}
else
{
AiNodeSetInt( instanceNode, "visibility", AI_RAY_ALL );
}
ApplyTransformation( instanceNode, xformSamples, args );
NodeCache::iterator I = g_meshCache.find(cacheId);
if ( I != g_meshCache.end() )
{
AiNodeSetPtr(instanceNode, "node", (*I).second );
return NULL;
}
}
SampleTimeSet singleSampleTimes;
singleSampleTimes.insert( args.frame / args.fps );
std::vector<AtByte> nsides;
std::vector<float> vlist;
std::vector<float> uvlist;
std::vector<AtUInt32> uvidxs;
// POTENTIAL OPTIMIZATIONS LEFT TO THE READER
// 1) vlist needn't be copied if it's a single sample
bool isFirstSample = true;
for ( SampleTimeSet::iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I, isFirstSample = false)
{
ISampleSelector sampleSelector( *I );
typename primT::schema_type::Sample sample = ps.getValue( sampleSelector );
if ( isFirstSample )
{
size_t numPolys = sample.getFaceCounts()->size();
nsides.reserve( sample.getFaceCounts()->size() );
for ( size_t i = 0; i < numPolys; ++i )
{
int32_t n = sample.getFaceCounts()->get()[i];
if ( n > 255 )
{
// TODO, warning about unsupported face
return NULL;
}
nsides.push_back( (AtByte) n );
}
size_t vidxSize = sample.getFaceIndices()->size();
vidxs.reserve( vidxSize );
vidxs.insert( vidxs.end(), sample.getFaceIndices()->get(),
sample.getFaceIndices()->get() + vidxSize );
}
vlist.reserve( vlist.size() + sample.getPositions()->size() * 3);
vlist.insert( vlist.end(),
(const float32_t*) sample.getPositions()->get(),
((const float32_t*) sample.getPositions()->get()) +
sample.getPositions()->size() * 3 );
}
ProcessIndexedBuiltinParam(
ps.getUVsParam(),
singleSampleTimes,
uvlist,
uvidxs,
2);
AtNode* meshNode = AiNode( "polymesh" );
if (!meshNode)
{
AiMsgError("Failed to make polymesh node for %s",
prim.getFullName().c_str());
return NULL;
}
args.createdNodes.push_back(meshNode);
if ( instanceNode != NULL)
{
AiNodeSetStr( meshNode, "name", (name + ":src").c_str() );
}
else
{
AiNodeSetStr( meshNode, "name", name.c_str() );
}
AiNodeSetArray(meshNode, "vidxs",
ArrayConvert(vidxs.size(), 1, AI_TYPE_UINT,
(void*)&vidxs[0]));
AiNodeSetArray(meshNode, "nsides",
ArrayConvert(nsides.size(), 1, AI_TYPE_BYTE,
&(nsides[0])));
AiNodeSetArray(meshNode, "vlist",
ArrayConvert( vlist.size() / sampleTimes.size(),
sampleTimes.size(), AI_TYPE_FLOAT, (void*)(&(vlist[0]))));
if ( !uvlist.empty() )
{
//TODO, option to disable v flipping
for (size_t i = 1, e = uvlist.size(); i < e; i += 2)
{
uvlist[i] = 1.0 - uvlist[i];
}
AiNodeSetArray(meshNode, "uvlist",
ArrayConvert( uvlist.size(), 1, AI_TYPE_FLOAT,
(void*)(&(uvlist[0]))));
if ( !uvidxs.empty() )
{
AiNodeSetArray(meshNode, "uvidxs",
ArrayConvert(uvidxs.size(), 1, AI_TYPE_UINT,
&(uvidxs[0])));
}
else
{
AiNodeSetArray(meshNode, "uvidxs",
ArrayConvert(vidxs.size(), 1, AI_TYPE_UINT,
&(vidxs[0])));
}
}
if ( sampleTimes.size() > 1 )
{
std::vector<float> relativeSampleTimes;
relativeSampleTimes.reserve( sampleTimes.size() );
for (SampleTimeSet::const_iterator I = sampleTimes.begin();
I != sampleTimes.end(); ++I )
{
relativeSampleTimes.push_back(
GetRelativeSampleTime( args, (*I) ) );
}
AiNodeSetArray( meshNode, "deform_time_samples",
ArrayConvert(relativeSampleTimes.size(), 1,
AI_TYPE_FLOAT, &relativeSampleTimes[0]));
}
// faceset visibility array
if ( !facesetName.empty() )
{
if ( ps.hasFaceSet( facesetName ) )
{
ISampleSelector frameSelector( *singleSampleTimes.begin() );
IFaceSet faceSet = ps.getFaceSet( facesetName );
IFaceSetSchema::Sample faceSetSample =
faceSet.getSchema().getValue( frameSelector );
std::set<int> facesToKeep;
facesToKeep.insert( faceSetSample.getFaces()->get(),
faceSetSample.getFaces()->get() +
faceSetSample.getFaces()->size() );
bool *faceVisArray = new bool(nsides.size());
for ( int i = 0; i < (int) nsides.size(); ++i )
{
faceVisArray[i] = facesToKeep.find( i ) != facesToKeep.end();
}
if ( AiNodeDeclare( meshNode, "face_visibility", "uniform BOOL" ) )
{
AiNodeSetArray( meshNode, "face_visibility",
ArrayConvert( nsides.size(), 1, AI_TYPE_BOOLEAN,
faceVisArray ) );
}
delete[] faceVisArray;
}
}
{
ICompoundProperty arbGeomParams = ps.getArbGeomParams();
ISampleSelector frameSelector( *singleSampleTimes.begin() );
AddArbitraryGeomParams( arbGeomParams, frameSelector, meshNode );
}
if ( instanceNode == NULL )
{
if ( xformSamples )
{
ApplyTransformation( meshNode, xformSamples, args );
}
return meshNode;
}
else
{
AiNodeSetInt( meshNode, "visibility", 0 );
AiNodeSetPtr(instanceNode, "node", meshNode );
g_meshCache[cacheId] = meshNode;
return meshNode;
}
}
void AbstractNode::RenderReflection(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection, Environment* environnement, const glm::vec4& clipPlane, glm::mat4 shadowModel)
{
ApplyTransformation(model);
ApplyTransformation(shadowModel);
model_->RenderReflection(model, view, projection, environnement, clipPlane,shadowModel);
}
void AbstractNode::RenderShadowMap(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection)
{
ApplyTransformation(model);
model_->RenderShadowMap(model, view, projection);
}
void AbstractNode::RenderFirstPass(glm::mat4 model, const glm::mat4& view, const glm::mat4& projection, glm::vec4& clipPlane)
{
ApplyTransformation(model);
model_->RenderFirstPass(model, view, projection, clipPlane);
}