liqRibData::~liqRibData()
{
// clean up and additional data
LIQDEBUGPRINTF("[liqRibData] freeing additional ribdata: %s\n", objDagPath.fullPathName().asChar() );
// Class destructor should be called
tokenPointerArray.clear();
LIQDEBUGPRINTF("[liqRibData] finished freeing additional ribdata: %s\n", objDagPath.fullPathName().asChar() );
}
static void _write(liqRibSurfaceData* pData, const structJob ¤tJob__)
{
CM_TRACE_FUNC("rm_writeSurfaceData.cpp::_write("<<pData->getFullPathName().asChar()<<","<<currentJob__.name.asChar()<<",...)");
LIQDEBUGPRINTF( "-> writing nurbs surface\n" );
LIQDEBUGPRINTF( "-> writing nurbs surface trims\n" );
if ( pData->hasTrims )
{
RiTrimCurve( pData->nloops,
const_cast< RtInt* >( &pData->ncurves[ 0 ] ),
const_cast< RtInt* >( &pData->order[ 0 ] ),
const_cast< RtFloat* >( &pData->knot[ 0 ] ),
const_cast< RtFloat* >( &pData->minKnot[ 0 ] ),
const_cast< RtFloat* >( &pData->maxKnot[ 0 ] ),
const_cast< RtInt* >( &pData->numCVs[ 0 ] ),
const_cast< RtFloat* >( &pData->u[ 0 ] ),
const_cast< RtFloat* >( &pData->v[ 0 ] ),
const_cast< RtFloat* >( &pData->w[ 0 ] ) );
}
if ( !pData->tokenPointerArray.empty() )
{
unsigned numTokens( pData->tokenPointerArray.size() );
boost::scoped_array< RtToken > tokenArray( new RtToken[ numTokens ] );
boost::scoped_array< RtPointer > pointerArray( new RtPointer[ numTokens ] );
assignTokenArraysV( pData->tokenPointerArray, tokenArray.get(), pointerArray.get() );
RiNuPatchV(
pData->nu,
pData->uorder,
pData->uknot.get(),
pData->umin,
pData->umax,
pData->nv,
pData->vorder,
pData->vknot.get(),
pData->vmin,
pData->vmax,
numTokens,
tokenArray.get(),
pointerArray.get() );
}
else
{
LIQDEBUGPRINTF( "-> ignoring nurbs surface\n" );
}
LIQDEBUGPRINTF( "-> done writing nurbs surface\n" );
}
/** Bump reference count down by one and delete if necessary.
*/
void liqRibObj::unref()
{
LIQDEBUGPRINTF("-> unreferencing ribobj.\n" );
LIQDEBUGPRINTF("-> number of ribobj references prior: %d\n", referenceCount );
assert ( referenceCount >= 0 );
referenceCount--;
if ( referenceCount <= 0 )
{
LIQDEBUGPRINTF( "-> deleting this ribobj.\n" );
//delete this;
}
}
/** Bump reference count up by one.
*/
void liqRibObj::ref()
{
//printf("-> referencing ribobj: %s\n", data->objDagPath.fullPathName().asChar() );
LIQDEBUGPRINTF( "-> number of ribobj references prior: %d\n", referenceCount );
referenceCount++;
}
/** Write the RIB for this coordinate system.
*/
void liqRibCoordData::_write(const structJob ¤tJob)
{
CM_TRACE_FUNC("liqRibCoordData::_write("<<currentJob.name<<")");
LIQDEBUGPRINTF("-> writing coord");
RiCoordinateSystem( const_cast<char *> ( name.asChar() ) );
}
static void _write(liqRibCoordData* pData, const structJob ¤tJob__)
{
CM_TRACE_FUNC("rm_writeCoordData.cpp::_write("<<pData->getFullPathName().asChar()<<","<<currentJob__.name.asChar()<<",...)");
LIQDEBUGPRINTF("-> writing coord");
RiCoordinateSystem( const_cast<char *> ( pData->getName().asChar() ) );
}
/** Compare this coordinate system to otherObj.
* The purpose is usually to determe if the coordinate system is animated.
*/
bool liqRibCoordData::compare( const liqRibData & otherObj ) const
{
CM_TRACE_FUNC("liqRibCoordData::compare("<<otherObj.getFullPathName()<<")");
LIQDEBUGPRINTF("-> comparing coord\n");
return ( otherObj.type() != MRT_Coord )? false : true;
}
/** Create a RIB compatible representation of a Maya coordinate system.
*/
liqRibCoordData::liqRibCoordData( MObject coord )
{
LIQDEBUGPRINTF("-> creating coord\n");
MFnDependencyNode fnNode( coord );
this->name = fnNode.name();
//cout <<"created coord "<<this->name.asChar()<<endl;
}
liqRibData::~liqRibData()
{
// clean up and additional data
LIQDEBUGPRINTF("-> freeing additional ribdata: " );
LIQDEBUGPRINTF(objDagPath.fullPathName().asChar());
LIQDEBUGPRINTF("\n" );
// Class destructor should be called
#if 0
std::vector<rTokenPointer>::iterator iter = tokenPointerArray.begin();
while ( iter != tokenPointerArray.end() ) {
LIQDEBUGPRINTF( "-> freeing addition ribdata: %s\n", iter->tokenName );
if ( iter->tokenFloats != NULL ) {
lfree( iter->tokenFloats );
iter->tokenFloats = NULL;
}
if ( iter->tokenString != NULL ) {
lfree( iter->tokenString );
iter->tokenString = NULL;
}
++iter;
}
#endif
tokenPointerArray.clear();
LIQDEBUGPRINTF("-> finished freeing additional ribdata: " );
LIQDEBUGPRINTF(objDagPath.fullPathName().asChar());
LIQDEBUGPRINTF("\n" );
}
/** Compare the two object's geometry.
*
* This comparision is used to determine if motion blurring should be done.
*/
AnimType liqRibObj::compareBody( const liqRibObjPtr o ) const
{
LIQDEBUGPRINTF( "-> comparing rib node handle body\n");
//cout <<"-> comparing rib node handle body"<<endl;
AnimType cmp( MRX_Const );
if ( !data || !o->data ) cmp = MRX_Const;
else if ( !data->compare( *( o->data.get() ) ) ) cmp = MRX_Animated;
return cmp;
}
/** Return the RenderMan handle handle for this light.
*/
RtLightHandle liqRibObj::lightHandle() const
{
LIQDEBUGPRINTF( "-> creating light node handle rep\n");
//assert( type == MRT_Light );
RtLightHandle lHandle( NULL );
if ( type == MRT_Light )
{
liqRibLightData* light( ( liqRibLightData* )data.get() );
lHandle = light->lightHandle();
}
return lHandle;
}
/** Compare this curve to the other for the purpose of determining
* if it is animated.
*/
bool liqRibPfxToonData::compare( const liqRibData & otherObj ) const
{
LIQDEBUGPRINTF( "-> comparing pfxToon curves\n");
if ( otherObj.type() != MRT_PfxToon ) return false;
//const liqRibPfxToonData & other = (liqRibPfxToonData&)otherObj;
// // Check CVs
// last = nverts[0] * 3;
// for ( i = 0; i < last; ++i ) {
// if ( !equiv( CVs[i], other.CVs[i] ) ) return false;
// }
return true;
}
/** Write the RIB for this paint effects toon line.
*/
void liqRibPfxToonData::write()
{
LIQDEBUGPRINTF( "-> writing pfxToon curve\n" );
if ( 0 < ncurves )
{
unsigned numTokens( tokenPointerArray.size() );
scoped_array< RtToken > tokenArray( new RtToken[ numTokens ] );
scoped_array< RtPointer > pointerArray( new RtPointer[ numTokens ] );
assignTokenArraysV( tokenPointerArray, tokenArray.get(), pointerArray.get() );
RiCurvesV( "linear", ncurves, nverts.get(), "nonperiodic", numTokens, tokenArray.get(), pointerArray.get() );
} else
RiIdentity(); // Make sure we don't create empty motion blocks
}
liqGenericShader &liqShaderFactory::getShader( MObject shaderObj, bool withAllParameters )
{
MString rmShaderStr;
MFnDependencyNode shaderNode( shaderObj );
MPlug rmanShaderNamePlug = shaderNode.findPlug( MString( "rmanShaderLong" ) );
rmanShaderNamePlug.getValue( rmShaderStr );
LIQDEBUGPRINTF( "-> Using Renderman Shader %s\n", rmShaderStr.asChar() );
vector<liqGenericShader*>::iterator iter = m_shaders.begin();
while ( iter != m_shaders.end() )
{
//string shaderNodeName = shaderNode.name().asChar();
if ( (*iter)->m_mObject == shaderObj )
{
// Already got it : nothing to do
return **iter;
}
++iter;
}
liqGenericShader *currentShader = NULL;
MTypeId typeId = shaderNode.typeId();
if( typeId==liqSurfaceNode::id ||
typeId==liqDisplacementNode::id ||
typeId==liqVolumeNode::id ||
typeId==liqLightNode::id ||
typeId==liqCoShaderNode::id
) // classic shader
{
currentShader = new liqShader( shaderObj, withAllParameters );
}
else // switcher
{
currentShader = new liqSwitcher( shaderObj, withAllParameters );
}
if( currentShader->hasErrors )
{
printf("[liqShaderFactory] error while creating liqObject for node '%s'\n", shaderNode.name().asChar() );
}
m_shaders.push_back( currentShader );
//fflush(stdout);
//fflush(stderr);
return *(m_shaders.back());
}
/** Compare the two object's world transform matrices.
*
* This method also works with instanced objects.
* This comparision is used to determine if motion blurring should be done.
*/
AnimType liqRibObj::compareMatrix( const liqRibObjPtr o, int instance ) const
{
LIQDEBUGPRINTF( "-> comparing rib node handle rep matrix\n");
return ( matrix( instance ) == o->matrix( instance ) ? MRX_Const : MRX_Animated );
}
static void _write(liqRibParticleData* pData, const structJob ¤tJob__)
{
CM_TRACE_FUNC("rm_writeParticleData.cpp::write("<<pData->getFullPathName().asChar()<<","<<currentJob__.name.asChar()<<",...)");
LIQDEBUGPRINTF( "-> writing particles\n");
#ifdef DEBUG
RiArchiveRecord( RI_COMMENT, "Number of Valid Particles: %d", pData->m_numValidParticles );
RiArchiveRecord( RI_COMMENT, "Number of Discarded Particles: %d", pData->m_numParticles - pData->m_numValidParticles );
#endif
MString notes("Make sure the particle is generated(e.g. sometimes particle is not generated, drag the time slider from frame0 to generate particles.)");
if(pData->m_numValidParticles <= 0 ){
RiArchiveRecord( RI_COMMENT, "Number of Valid Particles: %d. %s", pData->m_numValidParticles, notes.asChar() );
liquidMessage2(messageError, "%s. [%s]", notes.asChar(), pData->getFullPathName().asChar());
return;
}
unsigned numTokens( pData->tokenPointerArray.size() );
boost::scoped_array< RtToken > tokenArray( new RtToken[ numTokens ] );
boost::scoped_array< RtPointer > pointerArray( new RtPointer[ numTokens ] );
assignTokenArraysV( pData->tokenPointerArray, tokenArray.get(), pointerArray.get() );
switch( pData->particleType )
{
case liqRibParticleData::MPTBlobbies:
{
// Build an array that can be given to RiBlobby
std::vector< RtString > stringArray;
for( int i(0); i < pData->m_stringArray.size(); i++ )
{
stringArray.push_back( const_cast<char *>( pData->m_stringArray[i].c_str()) );
}
RiBlobbyV( pData->m_numValidParticles,
pData->m_codeArray.size(), const_cast< RtInt* >( &pData->m_codeArray[0] ),
pData->m_floatArray.size(), const_cast< RtFloat* >( &pData->m_floatArray[0] ),
stringArray.size(), const_cast< RtString* >( &stringArray[0] ),
numTokens,
tokenArray.get(),
const_cast< RtPointer* >( pointerArray.get() ) );
pData->grain = 0;
}
break;
case liqRibParticleData::MPTMultiPoint:
case liqRibParticleData::MPTPoints:
RiArchiveRecord( RI_COMMENT, "normal has to be reversed to show the MultiPoint/Points particles. // [10/9/2012 yaoyansi]" );
RiReverseOrientation();
#ifdef DELIGHT
case liqRibParticleData::MPTSpheres:
case liqRibParticleData::MPTSprites:
#endif
{
RiPointsV( pData->m_numValidParticles * pData->m_multiCount, numTokens, tokenArray.get(), pointerArray.get() );
}
break;
case liqRibParticleData::MPTMultiStreak:
case liqRibParticleData::MPTStreak:
{
unsigned nStreaks( pData->m_numValidParticles * pData->m_multiCount / 2 );
std::vector< RtInt > verts( nStreaks, 2 );
// Alternatively:
// scoped_array< RtInt >verts( new RtInt[ nStreaks ] );
// fill( verts.get(), verts.get() + nStreaks, ( RtInt )2 );
// Both ways are way faster than the frickin for() lop that was here before -- Moritz
RiCurvesV( "linear", nStreaks, &verts[ 0 ], "nonperiodic", numTokens, tokenArray.get(), pointerArray.get() );
}
break;
#ifndef DELIGHT
case liqRibParticleData::MPTSpheres:
{
int posAttr = -1,
radAttr = -1,
colAttr = -1,
opacAttr = -1;
for ( unsigned i = 0; i < pData->tokenPointerArray.size(); i++ )
{
const std::string tokenName( pData->tokenPointerArray[i].getTokenName() );
if ( "P" == tokenName )
{
posAttr = i;
}
else if ( "radius" == tokenName )
{
radAttr = i;
}
else if ( "Cs" == tokenName )
{
colAttr = i;
}
else if ( "Os" == tokenName )
{
opacAttr = i;
}
}
for ( unsigned i = 0; i < pData->m_numValidParticles; i++)
{
RiAttributeBegin();
if ( colAttr != -1 )
{
RiColor( &((RtFloat*)pointerArray[colAttr])[i*3] );
}
if ( opacAttr != -1 )
{
RiOpacity( &((RtFloat*)pointerArray[opacAttr])[i*3] );
}
RiTransformBegin();
RiTranslate(((RtFloat*)pointerArray[posAttr])[i*3+0],
((RtFloat*)pointerArray[posAttr])[i*3+1],
((RtFloat*)pointerArray[posAttr])[i*3+2]);
RtFloat radius = ((RtFloat*)pointerArray[radAttr])[i];
RiSphere(radius, -radius, radius, 360, RI_NULL);
RiTransformEnd();
RiAttributeEnd();
}
}
break;
case liqRibParticleData::MPTSprites:
{
int posAttr = -1,
numAttr = -1,
twistAttr = -1,
scaleXAttr = -1,
scaleYAttr = -1,
colAttr = -1,
opacAttr = -1;
for ( unsigned i( 0 ); i < pData->tokenPointerArray.size(); i++ )
{
const std::string tokenName( pData->tokenPointerArray[i].getTokenName() );
if ( "P" == tokenName )
{
posAttr = i;
}
else if ( "spriteNum" == tokenName )
{
numAttr = i;
}
else if ( "spriteTwist" == tokenName )
{
twistAttr = i;
}
else if ( "spriteScaleX" == tokenName )
{
scaleXAttr = i;
}
else if ( "spriteScaleY" == tokenName )
{
scaleYAttr = i;
}
else if ( "Cs" == tokenName )
{
colAttr = i;
}
else if ( "Os" == tokenName )
{
opacAttr = i;
}
}
MVector camUp( 0, 1, 0 );
MVector camRight( 1, 0, 0 );
MVector camEye( 0, 0, 1 );
camUp *= currentJob__.camera[0].mat.inverse();
camRight *= currentJob__.camera[0].mat.inverse();
camEye *= currentJob__.camera[0].mat.inverse();
for( unsigned ui( 0 ); ui < pData->m_numValidParticles; ui++ )
{
MVector up( camUp );
MVector right( camRight );
float spriteRadiusX( 0.5 );
float spriteRadiusY( 0.5 );
RiAttributeBegin();
RiArchiveRecord( RI_COMMENT, "normal has to be reversed to show the Sprite particles. // [10/9/2012 yaoyansi]" );
RiReverseOrientation();
if ( -1 != colAttr )
RiColor( &( ( RtFloat* )pointerArray[ colAttr ] )[ ui * 3 ] );
if ( -1 != opacAttr )
RiOpacity( &( ( RtFloat* )pointerArray[ opacAttr ] )[ ui * 3 ] );
if ( -1 != twistAttr )
{
float twist( -( ( RtFloat* )pointerArray[ twistAttr ] )[ ui ] * M_PI / 180 );
MQuaternion twistQ( twist, camEye );
right = camRight.rotateBy( twistQ );
up = camUp.rotateBy( twistQ );
}
if ( scaleXAttr != -1 )
spriteRadiusX *= ( ( RtFloat* )pointerArray[ scaleXAttr ] )[ ui ];
if ( scaleYAttr != -1 )
spriteRadiusY *= ( ( RtFloat* )pointerArray[ scaleYAttr ] )[ ui ];
if ( posAttr != -1 )
{
float *P( &( ( RtFloat* ) pointerArray[ posAttr ] )[ ui * 3 ] );
float spriteNumPP = 0;
if ( numAttr != -1 )
spriteNumPP = ( ( RtFloat* )pointerArray[ numAttr ] )[ ui ];
float x0 = P[ 0 ] - spriteRadiusX * right[ 0 ] + spriteRadiusY * up[ 0 ];
float y0 = P[ 1 ] - spriteRadiusX * right[ 1 ] + spriteRadiusY * up[ 1 ];
float z0 = P[ 2 ] - spriteRadiusX * right[ 2 ] + spriteRadiusY * up[ 2 ];
float x1 = P[ 0 ] + spriteRadiusX * right[ 0 ] + spriteRadiusY * up[ 0 ];
float y1 = P[ 1 ] + spriteRadiusX * right[ 1 ] + spriteRadiusY * up[ 1 ];
float z1 = P[ 2 ] + spriteRadiusX * right[ 2 ] + spriteRadiusY * up[ 2 ];
float x2 = P[ 0 ] - spriteRadiusX * right[ 0 ] - spriteRadiusY * up[ 0 ];
float y2 = P[ 1 ] - spriteRadiusX * right[ 1 ] - spriteRadiusY * up[ 1 ];
float z2 = P[ 2 ] - spriteRadiusX * right[ 2 ] - spriteRadiusY * up[ 2 ];
float x3 = P[ 0 ] + spriteRadiusX * right[ 0 ] - spriteRadiusY * up[ 0 ];
float y3 = P[ 1 ] + spriteRadiusX * right[ 1 ] - spriteRadiusY * up[ 1 ];
float z3 = P[ 2 ] + spriteRadiusX * right[ 2 ] - spriteRadiusY * up[ 2 ];
float patch[ 12 ] = { x0, y0, z0,
x1, y1, z1,
x2, y2, z2,
x3, y3, z3 };
// !!! if not GENERIC_RIBLIB use RiPatch( "bilinear", "P", &patch, "float spriteNum", &spriteNum, RI_NULL );
// RiPatch( "bilinear", "P", &patch, "float spriteNum", (RtFloat*)&spriteNumPP, RI_NULL );
// Patch "bilinear" "P" [0.446265 0.316269 -0.647637 1.27725 0.316269 -1.20393 0.615752 -0.636188 -0.39446 1.44674 -0.636188 -0.950756 ] "float spriteNum" [2 0 0 0 ]
RiArchiveRecord( RI_VERBATIM, "Patch \"bilinear\" \"P\" [%f %f %f %f %f %f %f %f %f %f %f %f] \"float spriteNum\" [%f]",
x0, y0, z0,x1, y1, z1, x2, y2, z2,x3, y3, z3,
spriteNumPP );
}
else {
RiIdentity();
}
RiAttributeEnd();
}//for
}
break;
#endif // #ifndef DELIGHT
case liqRibParticleData::MPTCloudy:
{
int posAttr = -1,
radAttr = -1,
colAttr = -1,
opacAttr = -1,
rotAttr = -1;
for ( unsigned i = 0; i < pData->tokenPointerArray.size(); i++ )
{
const std::string tokenName( pData->tokenPointerArray[i].getTokenName() );
if ( "P" == tokenName )
{
posAttr = i;
}
else if ( "radius" == tokenName )
{
radAttr = i;
}
else if ( "Cs" == tokenName )
{
colAttr = i;
}
else if ( "Os" == tokenName )
{
opacAttr = i;
}
else if ( "rotation" == tokenName )
{
rotAttr = i;
}
}
// Build an array that can be given to RiBlobby
std::vector< RtString > stringArray;
for( unsigned int i(0); i < pData->m_stringArray.size(); i++ ) {
stringArray.push_back( const_cast<char *>( pData->m_stringArray[i].c_str()) );
}
if(stringArray.size()==0)//added by yaoyansi, or it leads a crash on windows
stringArray.push_back( "" );
boost::scoped_array< RtToken > ithTokenArray( new RtToken[ numTokens ] );
boost::scoped_array< RtPointer > ithPointerArray( new RtPointer[ numTokens ] );
for ( unsigned i = 0; i < pData->m_numValidParticles; i++)
{
assignIthTokenArraysV( pData->tokenPointerArray, ithTokenArray.get(), ithPointerArray.get(), i );
RiAttributeBegin();
if ( colAttr != -1 )
{
RiColor( &((RtFloat*)pointerArray[colAttr])[i*3] );
}
if ( opacAttr != -1 )
{
RiOpacity( &((RtFloat*)pointerArray[opacAttr])[i*3] );
}
RiTransformBegin();
RiTranslate(((RtFloat*)pointerArray[posAttr])[i*3+0],
((RtFloat*)pointerArray[posAttr])[i*3+1],
((RtFloat*)pointerArray[posAttr])[i*3+2]);
if ( rotAttr != -1 )
{
RiRotate( (( RtFloat *) pointerArray[rotAttr])[i*3] * 360.0, 1.0, 0.0, 0.0 );
RiRotate( (( RtFloat *) pointerArray[rotAttr])[i*3+1] * 360.0, 0.0, 1.0, 0.0 );
RiRotate( (( RtFloat *) pointerArray[rotAttr])[i*3+2] * 360.0, 0.0, 0.0, 1.0 );
}
RtFloat radius = ((RtFloat*)pointerArray[radAttr])[i];
RiScale( radius, radius, radius );
//RiSphere(radius, -radius, radius, 360, RI_NULL);
float dummy[] = { 0.0, 0.0, 0.0 }; // Worst case : three floats are needed
RiBlobbyV( 1,
pData->m_codeArray.size(), const_cast< RtInt* >( &pData->m_codeArray[0] ),
pData->m_floatArray.size(), const_cast< RtFloat* >( &pData->m_floatArray[0] ),
stringArray.size(), const_cast< RtString* >( &stringArray[0] ),
numTokens, ithTokenArray.get(), ithPointerArray.get() );
// "vertex color incandescence", (RtPointer *)( dummy ),
// "vertex color Cs", (RtPointer *)( dummy ),
// "vertex float selfshadow", (RtPointer *)( dummy ),
// RI_NULL );
RiTransformEnd();
RiAttributeEnd();
}
break;
}
case liqRibParticleData::MPTNumeric:
RiArchiveRecord( RI_COMMENT, "Numeric Particles are not supported" );
break;
case liqRibParticleData::MPTTube:
RiArchiveRecord( RI_COMMENT, "Tube Particles are not supported" );
break;
break;
}
}
void tShadowRibWriterMgr::framePrologue_display(const structJob ¤tJob)
{
CM_TRACE_FUNC("tShadowRibWriterMgr::framePrologue_display(job="<<currentJob.name.asChar()<<")");
//refactor 14-1 begin from liqRibTranslator::framePrologue()
if( currentJob.pass != rpShadowMap && liqglo.liqglo_rotateCamera == true )
{
// philippe : Rotated Camera Case
RiFormat( currentJob.height, currentJob.width, currentJob.aspectRatio );
}else{
RiFormat( currentJob.width, currentJob.height, currentJob.aspectRatio );
}
//refactor 14-1 end
if( currentJob.pass != rpShadowMap )
{
//refactor 14 begin to tHeroRibWriterMgr::framePrologue_display()
// Smooth Shading
RiShadingInterpolation( "smooth" );
// Quantization
// overriden to floats when in rendering to Maya's renderView
if( !liqglo.m_renderView && liqglo.quantValue != 0 )
{
int whiteValue = (int) pow( 2.0, liqglo.quantValue ) - 1;
RiQuantize( RI_RGBA, whiteValue, 0, whiteValue, 0.5 );
}
else
{
RiQuantize( RI_RGBA, 0, 0, 0, 0 );
}
if( liqglo.m_rgain != 1.0 || liqglo.m_rgamma != 1.0 )
{
RiExposure( liqglo.m_rgain, liqglo.m_rgamma );
}
//refactor 14 end
}
if( currentJob.pass == rpShadowMap &&(currentJob.shadowType != stDeep || currentJob.samples == 1 ) )
{
//refactor 15
if( liqglo.liquidRenderer.renderName == MString("Pixie") )
{
liqFloat zero = 0;
RiHider( "hidden", "jitter", &zero, RI_NULL );
}
else
{
liqInt zero = 0;
RiHider( "hidden", "int jitter", &zero, RI_NULL );
}
//refactor 15
}
if( currentJob.pass == rpShadowMap && currentJob.shadowType == stMidPoint )
{
//refactor 16
liqString midPoint = "midpoint";
liqFloat midRatio = /*liqglo.liqglo_*/currentJob.midPointRatio;
RiHider( "hidden", "depthfilter", &midPoint, RI_NULL );
if ( /*liqglo.liqglo_*/currentJob.midPointRatio != 0 )
RiHider( "hidden", "midpointratio", &midRatio, RI_NULL ); // Output to rib jami
//refactor 16
}
//-----------------------------------------------------
LIQDEBUGPRINTF( "-> Setting Display Options\n" );
//if( currentJob.pass == rpShadowMap )
//MString relativeShadowName( liquidSanitizePath( liquidGetRelativePath( liqglo_relativeFileNames, liqglo_currentJob.imageName, liqglo_projectDir ) ) );
//refactor 17 begin
if( currentJob.shadowType != stMinMax )
{
if( currentJob.shadowType == stDeep )
{
// RiDeclare( "volumeinterpretation", "string" );
liqString volume = "continuous";
if ( currentJob.volume != viContinuous )
volume = "discrete";
if( liqglo.liquidRenderer.renderName == MString("3Delight") )
{
RiArchiveRecord( RI_COMMENT, "Display 1");
RiDisplay( const_cast< char* >( /*liqglo.liqglo_*/currentJob.imageName.asChar()),
const_cast< char* >( /*liqglo.liqglo_*/currentJob.format.asChar() ),
(liqToken)/*liqglo.liqglo_*/currentJob.imageMode.asChar(),
"string volumeinterpretation", &volume,
RI_NULL );
}
else
{
// Deep shadows cannot be the primary output driver in PRMan & co.
// We need to create a null output zfile first, and use the deep
// shadows as a secondary output.
//
if( liqglo.liquidRenderer.renderName != MString("Pixie") )
{
RiArchiveRecord( RI_COMMENT, "Display 2");
RiDisplay( "null", "null", "z", RI_NULL );
}
MString deepFileImageName = "+" + /*liqglo.liqglo_*/currentJob.imageName;
RiArchiveRecord( RI_COMMENT, "Display 3");
RiDisplay( const_cast< char* >( deepFileImageName.asChar() ),
const_cast< char* >( /*liqglo.liqglo_*/currentJob.format.asChar() ),
(liqToken)/*liqglo.liqglo_*/currentJob.imageMode.asChar(),
"string volumeinterpretation", &volume,
RI_NULL );
}
}//if( liqglo.liqglo_currentJob.deepShadows )
else
{
RiArchiveRecord( RI_COMMENT, "Display 4");
liqInt aggregate( /*liqglo.liqglo_*/currentJob.shadowAggregation );
RiDisplay( const_cast< char* >( /*liqglo.liqglo_*/currentJob.imageName.asChar() ),
const_cast< char* >( /*liqglo.liqglo_*/currentJob.format.asChar() ),
(liqToken)/*liqglo.liqglo_*/currentJob.imageMode.asChar(),
"int aggregate", &aggregate,
RI_NULL );
}
}//if( !liqglo.liqglo_currentJob.isMinMaxShadow )
else
{
RiArchiveRecord( RI_COMMENT, "Display 5");
RiArchiveRecord( RI_COMMENT, "Display Driver:" );
liqInt minmax = 1;
RiDisplay( const_cast< char* >( (/*liqglo.liqglo_*/currentJob.imageName+(int)liqglo.liqglo_lframe).asChar() ),//const_cast< char* >( parseString(liqglo_currentJob.imageName).asChar() ),
const_cast< char* >(/*liqglo.liqglo_*/currentJob.format.asChar()),
(liqToken)/*liqglo.liqglo_*/currentJob.imageMode.asChar(),
"minmax", &minmax,
RI_NULL );
}
exportJobCamera( currentJob, currentJob.camera );
//refactor 17 end
//}
}
/** Return the geometry type
*/
ObjectType liqRibPfxToonData::type() const
{
LIQDEBUGPRINTF( "-> returning pfxToon curve type\n" );
return MRT_PfxToon;
}
void liqRibData::addAdditionalSurfaceParameters( MObject node )
{
LIQDEBUGPRINTF("-> scanning for additional rman surface attributes \n");
MStatus status = MS::kSuccess;
unsigned i;
// work out how many elements there would be in a facevarying array if a mesh or subD
// faceVaryingCount is a private data member
if ( ( type() == MRT_Mesh ) || ( type() == MRT_Subdivision ) ) {
faceVaryingCount = 0;
MFnMesh fnMesh( node );
for ( uint pOn = 0; pOn < fnMesh.numPolygons(); pOn++ ) {
faceVaryingCount += fnMesh.polygonVertexCount( pOn );
}
}
// find how many additional
MFnDependencyNode nodeFn( node );
// find the attributes
MStringArray floatAttributesFound = findAttributesByPrefix( "rmanF", nodeFn );
MStringArray pointAttributesFound = findAttributesByPrefix( "rmanP", nodeFn );
MStringArray vectorAttributesFound = findAttributesByPrefix( "rmanV", nodeFn );
MStringArray normalAttributesFound = findAttributesByPrefix( "rmanN", nodeFn );
MStringArray colorAttributesFound = findAttributesByPrefix( "rmanC", nodeFn );
MStringArray stringAttributesFound = findAttributesByPrefix( "rmanS", nodeFn );
if ( floatAttributesFound.length() > 0 ) {
for ( i = 0; i < floatAttributesFound.length(); i++ ) {
liqTokenPointer tokenPointerPair;
MString cutString = floatAttributesFound[i].substring(5, floatAttributesFound[i].length());
MPlug fPlug = nodeFn.findPlug( floatAttributesFound[i] );
MObject plugObj;
status = fPlug.getValue( plugObj );
if ( plugObj.apiType() == MFn::kDoubleArrayData ) {
MFnDoubleArrayData fnDoubleArrayData( plugObj );
MDoubleArray doubleArrayData = fnDoubleArrayData.array( &status );
tokenPointerPair.set( cutString.asChar(),
rFloat,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
true,
false,
doubleArrayData.length() );
for( unsigned int kk = 0; kk < doubleArrayData.length(); kk++ ) {
tokenPointerPair.setTokenFloat( kk, doubleArrayData[kk] );
}
if ( ( type() == MRT_NuCurve ) && ( cutString == MString( "width" ) ) ) {
tokenPointerPair.setDetailType( rVarying);
} else if ( ( ( type() == MRT_Mesh ) || ( type() == MRT_Subdivision ) ) && ( doubleArrayData.length() == faceVaryingCount ) ) {
tokenPointerPair.setDetailType( rFaceVarying);
} else {
tokenPointerPair.setDetailType( rVertex );
}
} else {
if( fPlug.isArray() ) {
int nbElts = fPlug.evaluateNumElements();
float floatValue;
tokenPointerPair.set( cutString.asChar(),
rFloat,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
false,
true, // philippe :passed as uArray, otherwise it will think it is a single float
nbElts );
MPlug elementPlug;
for( unsigned int kk = 0; kk < nbElts; kk++ ) {
elementPlug = fPlug.elementByPhysicalIndex(kk);
elementPlug.getValue( floatValue );
tokenPointerPair.setTokenFloat( kk, floatValue );
}
tokenPointerPair.setDetailType( rConstant );
} else {
float floatValue;
tokenPointerPair.set( cutString.asChar(),
rFloat,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
false,
false,
0 );
fPlug.getValue( floatValue );
tokenPointerPair.setTokenFloat( 0, floatValue );
tokenPointerPair.setDetailType( rConstant );
}
}
tokenPointerArray.push_back( tokenPointerPair );
}
}
if ( pointAttributesFound.length() > 0 ) {
for ( i = 0; i < pointAttributesFound.length(); i++ ) {
liqTokenPointer tokenPointerPair;
MString cutString = pointAttributesFound[i].substring(5, pointAttributesFound[i].length());
MPlug pPlug = nodeFn.findPlug( pointAttributesFound[i] );
MObject plugObj;
status = pPlug.getValue( plugObj );
if ( plugObj.apiType() == MFn::kPointArrayData ) {
MFnPointArrayData fnPointArrayData( plugObj );
MPointArray pointArrayData = fnPointArrayData.array( &status );
tokenPointerPair.set( cutString.asChar(),
rPoint,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
true,
false,
pointArrayData.length() );
if ( type() == MRT_Nurbs || type() == MRT_NuCurve ) {
for ( int kk = 0; kk < pointArrayData.length(); kk++ ) {
tokenPointerPair.setTokenFloat( kk, pointArrayData[kk].x, pointArrayData[kk].y, pointArrayData[kk].z, pointArrayData[kk].w );
}
} else {
for ( int kk = 0; kk < pointArrayData.length(); kk++ ) {
tokenPointerPair.setTokenFloat( kk, pointArrayData[kk].x, pointArrayData[kk].y, pointArrayData[kk].z );
}
}
tokenPointerPair.setDetailType( rVertex );
} else {
// Hmmmm float ? double ?
float x, y, z;
tokenPointerPair.set(
cutString.asChar(),
rPoint,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
false,
false,
0 );
// Hmmm should check as for arrays if we are in nurbs mode : 4 values
pPlug.child(0).getValue( x );
pPlug.child(1).getValue( y );
pPlug.child(2).getValue( z );
tokenPointerPair.setTokenFloat( 0, x, y, z );
tokenPointerPair.setDetailType( rConstant );
}
tokenPointerArray.push_back( tokenPointerPair );
}
}
parseVectorAttributes( nodeFn, vectorAttributesFound, rVector );
parseVectorAttributes( nodeFn, normalAttributesFound, rNormal );
parseVectorAttributes( nodeFn, colorAttributesFound, rColor );
if ( stringAttributesFound.length() > 0 ) {
for ( i = 0; i < stringAttributesFound.length(); i++ ) {
liqTokenPointer tokenPointerPair;
MString cutString = stringAttributesFound[i].substring(5, stringAttributesFound[i].length());
MPlug sPlug = nodeFn.findPlug( stringAttributesFound[i] );
MObject plugObj;
status = sPlug.getValue( plugObj );
tokenPointerPair.set(
cutString.asChar(),
rString,
( type() == MRT_Nurbs || type() == MRT_NuCurve ) ? true : false,
false,
false,
0 );
MString stringVal;
sPlug.getValue( stringVal );
tokenPointerPair.setTokenString( 0, stringVal.asChar(), stringVal.length() );
tokenPointerPair.setDetailType( rConstant );
tokenPointerArray.push_back( tokenPointerPair );
}
}
}
/** Return the geometry type.
*/
ObjectType liqRibClipPlaneData::type() const
{
LIQDEBUGPRINTF("-> returning clipPlane type\n");
return MRT_Coord;
}
/** Compare this coordinate system to otherObj.
* The purpose is usually to determe if the coordinate system is animated.
*/
bool liqRibCoordData::compare( const liqRibData & otherObj ) const
{
LIQDEBUGPRINTF("-> comparing coord\n");
return ( otherObj.type() != MRT_Coord )? false : true;
}
/** Create a RIB compatible representation of a Maya pfxToon node as RiCurves.
*/
liqRibPfxToonData::liqRibPfxToonData( MObject pfxToon )
: nverts(),
CVs(),
curveWidth(),
cvColor(),
cvOpacity()
{
LIQDEBUGPRINTF( "-> creating pfxToon curves\n" );
MStatus status( MS::kSuccess );
// Update the pfxToon node with the renderCamera's position
// otherwise the resulting outline might be incorrect
MDagPath cameraPath;
MSelectionList camList;
camList.add( liqglo_renderCamera );
camList.getDagPath( 0, cameraPath );
MMatrix cam_mat( cameraPath.inclusiveMatrix() );
MFnDependencyNode pfxToonNode( pfxToon );
pfxToonNode.findPlug( "cameraPointX" ).setValue( cam_mat( 3, 0 ) );
pfxToonNode.findPlug( "cameraPointY" ).setValue( cam_mat( 3, 1 ) );
pfxToonNode.findPlug( "cameraPointZ" ).setValue( cam_mat( 3, 2 ) );
MFnPfxGeometry pfxtoon( pfxToon, &status );
if ( status == MS::kSuccess )
{
MRenderLineArray profileArray;
MRenderLineArray creaseArray;
MRenderLineArray intersectionArray;
bool doLines = true;
bool doTwist = false;
bool doWidth = true;
bool doFlatness = false;
bool doParameter = false;
bool doColor = true;
bool doIncandescence = false;
bool doTransparency = true;
bool doWorldSpace = false;
status = pfxtoon.getLineData( profileArray, creaseArray, intersectionArray, doLines, doTwist, doWidth, doFlatness, doParameter, doColor, doIncandescence, doTransparency, doWorldSpace );
if ( status == MS::kSuccess )
{
// Het the lines and fill the arrays.
ncurves = profileArray.length();
{
MFnDependencyNode pfxNode( pfxToon );
MString info( "[liquid] pfxToon node " );
info += pfxNode.name() + " : " + ncurves + " curves.";
cout << info << endl << flush;
}
unsigned totalNumberOfVertices( 0 );
if ( ncurves > 0 )
{
nverts = shared_array< RtInt >( new RtInt[ ncurves ] );
// Calculate storage requirments.
// This is a lot more efficient than all those reallocs()
// (or resize()s if we used a vector) that were done before
// in the main loop below.
for ( unsigned i( 0 ); i < ncurves; i++ )
{
MRenderLine theLine( profileArray.renderLine( i, &status ) );
if ( MS::kSuccess == status )
{
MVectorArray vertices( theLine.getLine() );
totalNumberOfVertices += vertices.length();
}
}
// Allocate memory
CVs = shared_array< RtFloat >( new RtFloat[ totalNumberOfVertices * 3 ] );
if ( !CVs )
{
MString err( "liqRibPfxToonData failed to allocate CV memory!" );
cout << err << endl << flush;
throw( err );
return;
}
curveWidth = shared_array< RtFloat >( new RtFloat[ totalNumberOfVertices ] );
if ( !curveWidth )
{
MString err( "liqRibPfxToonData failed to allocate per vertex width memory!" );
cout << err << endl << flush;
throw( err );
return;
}
cvColor = shared_array< RtFloat >( new RtFloat[ totalNumberOfVertices * 3 ] );
if ( !cvColor )
{
MString err( "liqRibPfxToonData failed to allocate CV color memory!" );
cout << err << endl << flush;
throw(err);
return;
}
cvOpacity = shared_array< RtFloat >( new RtFloat[ totalNumberOfVertices * 3 ] );
if ( !cvOpacity )
{
MString err("liqRibPfxToonData failed to allocate CV opacity memory !");
cout << err << endl << flush;
throw( err );
return;
}
RtFloat* cvPtr;
RtFloat* widthPtr;
RtFloat* colorPtr;
RtFloat* opacityPtr;
totalNumberOfVertices = 0;
for ( unsigned i( 0 ); i < ncurves; i++ )
{
MRenderLine theLine( profileArray.renderLine( i, &status ) );
if ( MS::kSuccess == status ) {
const MVectorArray& vertices( theLine.getLine() );
const MDoubleArray& width( theLine.getWidth() );
const MVectorArray& vertexColor( theLine.getColor() );
const MVectorArray& vertexTransparency( theLine.getTransparency() );
//cout <<"line "<<i<<" contains "<<vertices.length()<<" vertices."<<endl;
//cout <<vertexColor<<endl;
nverts[i] = vertices.length();
totalNumberOfVertices += vertices.length();
cvPtr = CVs.get() + ( totalNumberOfVertices * 3 - nverts[ i ] * 3 ) ;
widthPtr = curveWidth.get() + ( totalNumberOfVertices - nverts[ i ] ) ;
colorPtr = cvColor.get() + ( totalNumberOfVertices * 3 - nverts[ i ] * 3 ) ;
opacityPtr = cvOpacity.get() + ( totalNumberOfVertices * 3 - nverts[ i ] * 3 ) ;
for ( unsigned vertIndex( 0 ); vertIndex < vertices.length(); vertIndex++ )
{
*cvPtr++ = ( RtFloat ) vertices[ vertIndex ].x;
*cvPtr++ = ( RtFloat ) vertices[ vertIndex ].y;
*cvPtr++ = ( RtFloat ) vertices[ vertIndex ].z;
*widthPtr++ = ( RtFloat )width[ vertIndex ];
*colorPtr++ = ( RtFloat )vertexColor[ vertIndex ].x ;
*colorPtr++ = ( RtFloat )vertexColor[ vertIndex ].y ;
*colorPtr++ = ( RtFloat )vertexColor[ vertIndex ].z ;
*opacityPtr++ = ( RtFloat )( 1.0f - vertexTransparency[ vertIndex ].x ) ;
*opacityPtr++ = ( RtFloat )( 1.0f - vertexTransparency[ vertIndex ].y ) ;
*opacityPtr++ = ( RtFloat )( 1.0f - vertexTransparency[ vertIndex ].z ) ;
}
}
}
// Store for output
liqTokenPointer points_pointerPair;
if ( !points_pointerPair.set( "P", rPoint, true, false, totalNumberOfVertices ) )
{
MString err( "liqRibPfxToonData: liqTokenPointer failed to allocate CV memory !" );
cout << err << endl;
throw(err);
return;
}
points_pointerPair.setDetailType( rVertex );
points_pointerPair.setTokenFloats( CVs );
tokenPointerArray.push_back( points_pointerPair );
// Store width params
liqTokenPointer width_pointerPair;
if ( !width_pointerPair.set( "width", rFloat, true, false, totalNumberOfVertices ) )
{
MString err("liqRibPfxToonData: liqTokenPointer failed to allocate width memory !");
cout <<err<<endl;
throw(err);
return;
}
width_pointerPair.setDetailType( rVarying );
width_pointerPair.setTokenFloats( curveWidth );
tokenPointerArray.push_back( width_pointerPair );
// Store color params
liqTokenPointer color_pointerPair;
if ( !color_pointerPair.set( "pfxToon_vtxColor", rColor, true, false, totalNumberOfVertices ) )
{
MString err("liqRibPfxToonData: liqTokenPointer failed to allocate color memory !");
cout <<err<<endl;
throw(err);
return;
}
color_pointerPair.setDetailType( rVertex );
color_pointerPair.setTokenFloats( cvColor );
tokenPointerArray.push_back( color_pointerPair );
// Store opacity params
liqTokenPointer opacity_pointerPair;
if ( !opacity_pointerPair.set( "pfxToon_vtxOpacity", rColor, true, false, totalNumberOfVertices ) )
{
MString err("liqRibPfxToonData: liqTokenPointer failed to allocate opacity memory !");
cout <<err<<endl<<flush;
throw(err);
return;
}
opacity_pointerPair.setDetailType( rVertex );
opacity_pointerPair.setTokenFloats( cvOpacity );
tokenPointerArray.push_back( opacity_pointerPair );
addAdditionalSurfaceParameters( pfxToon );
}
}
}
}
/** Create a RIB representation of the given node in the DAG as a ribgen.
*/
liqRibObj::liqRibObj( const MDagPath &path, ObjectType objType )
:
written( 0 ),
instanceMatrices(),
objectHandle( NULL ),
referenceCount( 0 ),
data()
{
LIQDEBUGPRINTF( "-> creating dag node handle rep\n");
MStatus status;
MObject obj( path.node() );
MObject skip;
//lightSources = NULL;
MFnDagNode nodeFn( obj );
// Store the matrices for all instances of this node at this time
// so that they can be used to determine if this node's transformation
// is animated. This information is used for doing motion blur.
MDagPathArray instanceArray;
nodeFn.getAllPaths( instanceArray );
unsigned last( instanceArray.length() );
instanceMatrices.resize( last );
for ( unsigned i( 0 ); i < last; i++ ) instanceMatrices[ i ] = instanceArray[ i ].inclusiveMatrix();
LIQDEBUGPRINTF( "-> checking handles display status\n");
ignore = !areObjectAndParentsVisible( path );
if ( !ignore ) ignore = !areObjectAndParentsTemplated( path );
if ( !ignore ) ignore = !isObjectPrimaryVisible( path );
// check that the shape's transform does not a have a liqIgnoreShapes attribute.
ignoreShapes = false;
MDagPath searchPath( path );
while ( searchPath.apiType() != ( MFn::kTransform ) && searchPath.length() > 1 ) searchPath.pop();
MFnDagNode transformDN( searchPath );
status.clear();
MPlug ignorePlug = transformDN.findPlug( "liqIgnoreShapes", &status );
if ( status == MS::kSuccess ) ignorePlug.getValue( ignoreShapes );
ignoreShadow = !isObjectCastsShadows( path );
if ( !ignoreShadow ) ignoreShadow = !areObjectAndParentsVisible( path );
if ( !ignoreShadow ) ignoreShadow = !areObjectAndParentsTemplated( path );
receiveShadow = isObjectReceivesShadows( path );
// don't bother storing it if it's not going to be visible!
LIQDEBUGPRINTF( "-> about to create rep\n");
if ( !ignore || !ignoreShadow )
{
if ( objType == MRT_RibGen )
{
type = MRT_RibGen;
data = liqRibDataPtr( new liqRibGenData( obj, path ) );
}
else
{
// check to see if object's class is derived from liqCustomNode
liqCustomNode *customNode( NULL );
MFnDependencyNode mfnDepNode( obj, &status );
if ( status )
{
MPxNode *mpxNode( mfnDepNode.userNode() );
if ( mpxNode )
customNode = dynamic_cast< liqCustomNode* >( mpxNode ); // will be NULL if cast is not invalid
}
// Store the geometry/light/shader data for this object in RIB format
if ( customNode )
{
type = MRT_Custom;
data = liqRibDataPtr( new liqRibCustomNode( (( !ignoreShapes )? obj : skip ), customNode ) );
}
else if ( obj.hasFn(MFn::kNurbsSurface) )
{
type = MRT_Nurbs;
data = liqRibDataPtr( new liqRibSurfaceData( ( !ignoreShapes )? obj : skip ) );
}
else if ( obj.hasFn(MFn::kSubdiv) )
{
type = MRT_Subdivision;
data = liqRibDataPtr( new liqRibMayaSubdivisionData( ( !ignoreShapes )? obj : skip ) );
}
else if ( obj.hasFn(MFn::kNurbsCurve) )
{
type = MRT_NuCurve;
data = liqRibDataPtr( new liqRibNuCurveData( ( !ignoreShapes )? obj : skip ) );
}
else if ( obj.hasFn(MFn::kPfxGeometry) )
{
type = objType;
data = liqRibDataPtr( new liqRibPfxData( (( !ignoreShapes )? obj : skip), objType ) );
}
else if ( obj.hasFn( MFn::kPfxToon ) )
{
type = MRT_PfxToon;
data = liqRibDataPtr( new liqRibPfxToonData( ( !ignoreShapes )? obj : skip ) );
}
else if ( obj.hasFn( MFn::kPfxHair ) )
{
type = MRT_PfxHair;
//LIQDEBUGPRINTF( "--> new liqRibPfxHairData\n");
data = liqRibDataPtr( new liqRibPfxHairData( ( !ignoreShapes )? obj : skip ) );
}
else if ( obj.hasFn( MFn::kParticle ) || obj.hasFn( MFn::kNParticle ) )
{
type = MRT_Particles;
data = liqRibDataPtr( new liqRibParticleData( ( !ignoreShapes )? obj : skip ) );
}
// if you want to use plugin shapes as placeholders for example
// i.e. you want to use shave & haircut and attach a custom shader to it
else if ( obj.hasFn( MFn::kPluginShape ) )
{
type = MRT_Weirdo; // lets use this at least once :)
data = liqRibDataPtr( new liqRibSurfaceData( skip ) ); // you could use any here
}
else if ( obj.hasFn( MFn::kMesh ) )
{
float areaIntensity;
// may be explicit "areaLight" attribute would be better ...
liquidGetPlugValue( nodeFn, "areaIntensity", areaIntensity, status );
if ( status == MS::kSuccess )
{
// it should be AreaLight ( until better solution...)
type = MRT_Light;
data = liqRibDataPtr( new liqAreaLightData( ( !ignoreShapes )? obj : skip ) );
}
else
{
// we know we are dealing with a mesh here, now we check to see if it
// needs to be handled as a subdivision surface
bool usingSubdiv ( false );
liquidGetPlugValue( nodeFn, "liqSubdiv", usingSubdiv, status );
bool usingSubdivOld ( false );
liquidGetPlugValue( nodeFn, "subDMesh", usingSubdivOld, status );
// make Liquid understand MTOR subdiv attribute
bool usingSubdivMtor ( false );
if ( liqglo_useMtorSubdiv )
liquidGetPlugValue( nodeFn, "mtorSubdiv", usingSubdivMtor, status );
usingSubdiv |= usingSubdivMtor | usingSubdivOld;
if ( usingSubdiv )
{
// we've got a subdivision surface
bool useHierarchicalSubdiv ( false );
liquidGetPlugValue( nodeFn, "liqHierarchicalSubdiv", useHierarchicalSubdiv, status );
type = MRT_Subdivision;
if ( useHierarchicalSubdiv )
data = liqRibDataPtr( new liqRibHierarchicalSubdivisionData( ( !ignoreShapes )? obj : skip ) );
else
data = liqRibDataPtr( new liqRibSubdivisionData( ( !ignoreShapes )? obj : skip ) );
}
else
{
// it's a regular mesh
type = MRT_Mesh;
data = liqRibDataPtr( new liqRibMeshData( ( !ignoreShapes )? obj : skip ) );
}
}
}
else if ( obj.hasFn( MFn::kLight ) )
{
type = MRT_Light;
data = liqRibDataPtr( new liqRibLightData( path ) );
}
else if ( obj.hasFn( MFn::kLocator ) )
{
if ( mfnDepNode.typeName() == "liquidCoordSys" )
{
MStatus status;
int coordSysType = 0;
MPlug typePlug( mfnDepNode.findPlug( "type", &status ) );
if ( MS::kSuccess == status ) typePlug.getValue( coordSysType );
if ( coordSysType == 5 )
{
type = MRT_ClipPlane;
data = liqRibDataPtr( new liqRibClipPlaneData( obj ) );
}
else
{
type = MRT_Coord;
data = liqRibDataPtr( new liqRibCoordData( obj ) );
}
}
else
{
bool isCurveGroup( false );
if ( mfnDepNode.typeName() == "liqBoundingBoxLocator" )
{
liquidGetPlugValue( mfnDepNode, "liquidCurveGroup", isCurveGroup, status );
if ( isCurveGroup )
{
type = MRT_Curves;
//if ( liqglo_renderAllCurves ) data = liqRibDataPtr( new liqRibCurvesData( obj ) );
//else data = liqRibDataPtr( new liqRibCurvesData( skip ) );
data = liqRibDataPtr( new liqRibCurvesData( obj ) );
}
}
if ( !isCurveGroup )
{
type = MRT_Locator;
data = liqRibDataPtr( new liqRibLocatorData( obj ) );
}
}
}
else if ( obj.hasFn( MFn::kImplicitSphere ) )
{
type = MRT_ImplicitSphere;
if ( !ignoreShapes ) data = liqRibDataPtr( new liqRibImplicitSphereData( obj ) );
else data = liqRibDataPtr( new liqRibImplicitSphereData( skip ) );
}
}
data->objDagPath = path;
}
LIQDEBUGPRINTF( "==> done creating rep %s\n", path.fullPathName().asChar() );
}
/** Write the RIB for this coordinate system.
*/
void liqRibCoordData::write()
{
LIQDEBUGPRINTF("-> writing coord");
RiCoordinateSystem( const_cast<char *> ( name.asChar() ) );
}
static void _write(liqRibMeshData* pData, const structJob ¤tJob)
{
CM_TRACE_FUNC("rm_writeMeshData.cpp::_write("<<pData->getFullPathName().asChar()<<","<<currentJob.name.asChar()<<")");
if( pData->isEmpty() )
{
liquidMessage( "Could not export degenerate mesh", messageError );
return;
}
//
//RiArchiveRecord( RI_COMMENT, "Sometimes the polygon cant be rendered correctly, so I try to reverse the normal. //- yaoyansi" );
//RiReverseOrientation();
if(pData->isAreaLight())
{
RtLightHandle handle = INVALID_LIGHT_INDEX;
{ // What happens if we're inside a motion block????? This whole approach of Liquid is flawed...
LIQDEBUGPRINTF( "-> mesh is area light\n" );
// RiAttributeBegin();
RtString ribname = const_cast< char* >( pData->getFullPathName().asChar() );
RiAttribute( "identifier", "name", &ribname, RI_NULL );
RtMatrix tmp;
memcpy( tmp, pData->getTransformationMatrixPtr(), sizeof( RtMatrix ) );
RiTransform( tmp );
float areaIntensity = pData->getAreaIntensity();
handle = RiAreaLightSource( "arealight", "intensity", &areaIntensity, RI_NULL );
}
//
//mesh data begin
//
// Each loop has one polygon, so we just want an array of 1's of
// the correct size. Stack version.
//vector< RtInt > nloops( numFaces, 1 );
// Alternatively (heap version):
boost::scoped_array< RtInt > nloops( new RtInt[ pData->getNumFaces() ] );
std::fill( nloops.get(), nloops.get() + pData->getNumFaces(), ( RtInt )1 );
unsigned numTokens( pData->tokenPointerArray.size() );
boost::scoped_array< RtToken > tokenArray( new RtToken[ numTokens ] );
boost::scoped_array< RtPointer > pointerArray( new RtPointer[ numTokens ] );
assignTokenArraysV( pData->tokenPointerArray, tokenArray.get(), pointerArray.get() );
RiPointsGeneralPolygonsV( pData->getNumFaces(),
&nloops[ 0 ],
pData->getNverts().get(),
pData->getVerts().get(),
numTokens,
tokenArray.get(),
pointerArray.get() );
//mesh data end
{
// RiAttributeEnd();
RiIlluminate( handle, 1 );
}
}else{
//mesh data begin
//
// Each loop has one polygon, so we just want an array of 1's of
// the correct size. Stack version.
//vector< RtInt > nloops( numFaces, 1 );
// Alternatively (heap version):
boost::scoped_array< RtInt > nloops( new RtInt[ pData->getNumFaces() ] );
std::fill( nloops.get(), nloops.get() + pData->getNumFaces(), ( RtInt )1 );
unsigned numTokens( pData->tokenPointerArray.size() );
boost::scoped_array< RtToken > tokenArray( new RtToken[ numTokens ] );
boost::scoped_array< RtPointer > pointerArray( new RtPointer[ numTokens ] );
assignTokenArraysV( pData->tokenPointerArray, tokenArray.get(), pointerArray.get() );
RiPointsGeneralPolygonsV( pData->getNumFaces(),
&nloops[ 0 ],
pData->getNverts().get(),
pData->getVerts().get(),
numTokens,
tokenArray.get(),
pointerArray.get() );
//mesh data end//
}
}
/** Return the geometry type.
*/
ObjectType liqRibCoordData::type() const
{
LIQDEBUGPRINTF("-> returning coord type\n");
return MRT_Coord;
}
/** Write the RIB for this coordinate system.
*/
void liqRibClipPlaneData::write()
{
LIQDEBUGPRINTF("-> writing clipPlane");
RiArchiveRecord( RI_VERBATIM, "ClippingPlane 0 0 -1 0 0 0\n" );
}
