void ScriptNode::plugSet( Plug *plug )
{
if( plug == frameStartPlug() )
{
frameEndPlug()->setValue( std::max( frameEndPlug()->getValue(), frameStartPlug()->getValue() ) );
}
else if( plug == frameEndPlug() )
{
frameStartPlug()->setValue( std::min( frameStartPlug()->getValue(), frameEndPlug()->getValue() ) );
}
else if( plug == framesPerSecondPlug() )
{
context()->setFramesPerSecond( framesPerSecondPlug()->getValue() );
}
else if( plug == variablesPlug() )
{
IECore::CompoundDataMap values;
variablesPlug()->fillCompoundData( values );
for( IECore::CompoundDataMap::const_iterator it = values.begin(), eIt = values.end(); it != eIt; ++it )
{
context()->set( it->first, it->second.get() );
}
}
else if( plug == fileNamePlug() )
{
boost::filesystem::path fileName( fileNamePlug()->getValue() );
context()->set( "script:name", boost::filesystem::basename( fileName ) );
}
}
void IECoreArnold::RendererImplementation::light( const std::string &name, const std::string &handle, const IECore::CompoundDataMap ¶meters )
{
const char *unprefixedName = name.c_str();
if( name.find( ':' ) != string::npos )
{
if( boost::starts_with( name, "ai:" ) )
{
unprefixedName += 3;
}
else
{
return;
}
}
AtNode *l = AiNode( unprefixedName );
if( !l )
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::light", boost::format( "Couldn't load light \"%s\"" ) % unprefixedName );
return;
}
for( CompoundDataMap::const_iterator parmIt=parameters.begin(); parmIt!=parameters.end(); parmIt++ )
{
ParameterAlgo::setParameter( l, parmIt->first.value().c_str(), parmIt->second.get() );
}
applyTransformToNode( l );
addNode( l );
}
void setParameters( AtNode *node, const IECore::CompoundDataMap &values )
{
for( CompoundDataMap::const_iterator it=values.begin(); it!=values.end(); it++ )
{
setParameter( node, it->first.value().c_str(), it->second.get() );
}
}
ParameterList::ParameterList( const IECore::CompoundDataMap ¶meters, const std::map<std::string, std::string> *typeHints )
{
reserve( parameters );
CompoundDataMap::const_iterator it;
for( it=parameters.begin(); it!=parameters.end(); it++ )
{
appendParameter( it->first, it->second.get(), typeHints );
}
}
ParameterList::ParameterList( const IECore::CompoundDataMap ¶meters, const std::string &prefix,
const std::map<std::string, std::string> *typeHints )
{
reserve( parameters );
CompoundDataMap::const_iterator it;
for( it=parameters.begin(); it!=parameters.end(); it++ )
{
if( 0==it->first.value().compare( 0, prefix.size(), prefix ) )
{
appendParameter( string( it->first, prefix.size() ), it->second.get(), typeHints );
}
}
}
void ParameterList::reserve( const IECore::CompoundDataMap ¶meters )
{
size_t numStrings = 0;
size_t numCharPtrs = 0;
size_t numInts = 0;
size_t numFloats = 0;
for( IECore::CompoundDataMap::const_iterator it=parameters.begin(); it!=parameters.end(); it++ )
{
accumulateReservations( it->second.get(), numStrings, numCharPtrs, numInts, numFloats );
}
m_strings.reserve( numStrings );
m_charPtrs.reserve( numCharPtrs );
m_ints.reserve( numInts );
m_floats.reserve( numFloats );
}
void IECoreRI::SXRendererImplementation::shader( const std::string &type, const std::string &name, const IECore::CompoundDataMap ¶meters )
{
if( type=="displacement" || type=="ri:displacement" )
{
m_stateStack.top().displacementShader = createShader( name.c_str(), 0, parameters );
}
else if( type=="surface" || type=="ri:surface" )
{
m_stateStack.top().surfaceShader = createShader( name.c_str(), 0, parameters );
}
else if( type=="atmosphere" || type=="ri:atmosphere" )
{
m_stateStack.top().atmosphereShader = createShader( name.c_str(), 0, parameters );
}
else if( type=="imager" || type=="ri:imager" )
{
m_stateStack.top().imagerShader = createShader( name.c_str(), 0, parameters );
}
else if( type=="shader" || type=="ri:shader" )
{
const StringData *handleData = 0;
CompoundDataMap::const_iterator it = parameters.find( "__handle" );
if( it!=parameters.end() )
{
handleData = runTimeCast<const StringData>( it->second );
}
if( !handleData )
{
msg( Msg::Error, "IECoreRI::SXRendererImplementation::shader", "Must specify StringData \"__handle\" parameter for coshaders." );
}
else
{
SxShader s = createShader( name.c_str(), handleData->readable().c_str(), parameters );
if( s )
{
m_stateStack.top().coshaders.push_back( s );
}
}
}
else
{
msg( Msg::Error, "IECoreRI::SXRendererImplementation::shader", boost::format( "Unsupported shader type \"%s\"" ) % type );
}
}
void ScriptNode::plugSet( Plug *plug )
{
if( plug == frameStartPlug() )
{
frameEndPlug()->setValue( std::max( frameEndPlug()->getValue(), frameStartPlug()->getValue() ) );
}
else if( plug == frameEndPlug() )
{
frameStartPlug()->setValue( std::min( frameStartPlug()->getValue(), frameEndPlug()->getValue() ) );
}
else if( plug == framePlug() )
{
context()->setFrame( framePlug()->getValue() );
}
else if( plug == framesPerSecondPlug() )
{
context()->setFramesPerSecond( framesPerSecondPlug()->getValue() );
}
else if( plug == variablesPlug() )
{
IECore::CompoundDataMap values;
variablesPlug()->fillCompoundData( values );
for( IECore::CompoundDataMap::const_iterator it = values.begin(), eIt = values.end(); it != eIt; ++it )
{
context()->set( it->first, it->second.get() );
}
}
else if( plug == fileNamePlug() )
{
const boost::filesystem::path fileName( fileNamePlug()->getValue() );
context()->set( "script:name", fileName.stem().string() );
MetadataAlgo::setReadOnly(
this,
boost::filesystem::exists( fileName ) && 0 != access( fileName.c_str(), W_OK ),
/* persistent = */ false
);
}
}
void IECoreArnold::RendererImplementation::shader( const std::string &type, const std::string &name, const IECore::CompoundDataMap ¶meters )
{
if(
type=="shader" || type=="ai:shader" ||
type=="surface" || type=="ai:surface" ||
type=="displacement" || type=="ai:displacement"
)
{
AtNode *s = 0;
if( 0 == name.compare( 0, 10, "reference:" ) )
{
s = AiNodeLookUpByName( name.c_str() + 10 );
if( !s )
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::shader", boost::format( "Couldn't find shader \"%s\"" ) % name );
return;
}
}
else
{
s = AiNode( name.c_str() );
if( !s )
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::shader", boost::format( "Couldn't load shader \"%s\"" ) % name );
return;
}
for( CompoundDataMap::const_iterator parmIt=parameters.begin(); parmIt!=parameters.end(); parmIt++ )
{
if( parmIt->second->isInstanceOf( IECore::StringDataTypeId ) )
{
const std::string &potentialLink = static_cast<const StringData *>( parmIt->second.get() )->readable();
if( 0 == potentialLink.compare( 0, 5, "link:" ) )
{
std::string linkHandle = potentialLink.c_str() + 5;
AttributeState::ShaderMap::const_iterator shaderIt = m_attributeStack.top().shaders.find( linkHandle );
if( shaderIt != m_attributeStack.top().shaders.end() )
{
AiNodeLinkOutput( shaderIt->second, "", s, parmIt->first.value().c_str() );
}
else
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::shader", boost::format( "Couldn't find shader handle \"%s\" for linking" ) % linkHandle );
}
continue;
}
}
ParameterAlgo::setParameter( s, parmIt->first.value().c_str(), parmIt->second.get() );
}
addNode( s );
}
if( type=="shader" || type == "ai:shader" )
{
CompoundDataMap::const_iterator handleIt = parameters.find( "__handle" );
if( handleIt != parameters.end() && handleIt->second->isInstanceOf( IECore::StringDataTypeId ) )
{
const std::string &handle = static_cast<const StringData *>( handleIt->second.get() )->readable();
m_attributeStack.top().shaders[handle] = s;
}
else
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::shader", "No __handle parameter specified." );
}
}
else if( type=="surface" || type == "ai:surface" )
{
m_attributeStack.top().surfaceShader = s;
}
else
{
m_attributeStack.top().displacementShader = s;
}
}
else
{
if( type.find( ':' ) == string::npos )
{
msg( Msg::Warning, "IECoreArnold::RendererImplementation::shader", boost::format( "Unsupported shader type \"%s\"" ) % type );
}
}
}
SxShader IECoreRI::SXRendererImplementation::createShader( const char *name, const char *handle, const IECore::CompoundDataMap ¶meters ) const
{
// create a shader which we'll use just for getting information from. we have to do this
// in a temporary context created just for the purpose, so that we don't end up making two shaders
// in the context we actually care about.
boost::shared_ptr<void> tmpContext( SxCreateContext( m_stateStack.top().context.get() ), SxDestroyContext );
SxShader shaderInfo = SxCreateShader( tmpContext.get(), 0, name, 0 );
if( !shaderInfo )
{
// 3delight will have printed a warning already.
return 0;
}
// convert the parameter list for the shader
SxParameterList parameterList = SxCreateParameterList( m_stateStack.top().context.get(), 1, "shader" );
for( IECore::CompoundDataMap::const_iterator it=parameters.begin(); it!=parameters.end(); it++ )
{
if( it->first=="__handle" )
{
// skip the special handle parameter intended for use as the coshader handle
continue;
}
switch( it->second->typeId() )
{
case FloatDataTypeId :
SxSetParameter( parameterList, it->first.value().c_str(), SxFloat, (void *)&(static_cast<const FloatData *>( it->second.get() )->readable() ) );
break;
case IntDataTypeId :
{
float value = static_cast<const IntData *>( it->second.get() )->readable();
SxSetParameter( parameterList, it->first.value().c_str(), SxFloat, &value );
break;
}
case BoolDataTypeId :
{
float value = static_cast<const BoolData *>( it->second.get() )->readable() ? 1.0f : 0.0f;
SxSetParameter( parameterList, it->first.value().c_str(), SxFloat, &value );
break;
}
case V3fDataTypeId :
{
unsigned numParameters = SxGetNumParameters( shaderInfo );
SxType type = SxInvalid;
unsigned arraySize;
for( unsigned i=0; i<numParameters; i++ )
{
bool varying;
SxData defaultValue;
const char *name = SxGetParameterInfo( shaderInfo, i, &type, &varying, &defaultValue, &arraySize );
if( 0==strcmp( name, it->first.value().c_str() ) )
{
break;
}
else
{
type = SxInvalid;
}
}
if( type==SxPoint || type==SxVector || type==SxNormal )
{
SxSetParameter( parameterList, it->first.value().c_str(), type, (void *)&(static_cast<const V3fData *>( it->second.get() )->readable() ) );
}
else if( type==SxFloat && arraySize==3 )
{
SxSetParameter( parameterList, it->first.value().c_str(), type, (void *)&(static_cast<const V3fData *>( it->second.get() )->readable() ), false, arraySize );
}
else
{
msg( Msg::Warning, "IECoreRI::SXRendererImplementation::createShader", boost::format( "Parameter \"%s\" is not a point, vector, normal or float[3] and will be ignored" ) % it->second->typeName() );
}
break;
}
case Color3fDataTypeId :
SxSetParameter( parameterList, it->first.value().c_str(), SxColor, (void *)&(static_cast<const Color3fData *>( it->second.get() )->readable() ) );
break;
case M33fDataTypeId :
SxSetParameter( parameterList, it->first.value().c_str(), SxMatrix, (void *)&(static_cast<const M33fData *>( it->second.get() )->readable() ) );
break;
case StringDataTypeId :
{
const char *s = static_cast<const StringData *>( it->second.get() )->readable().c_str();
SxSetParameter( parameterList, it->first.value().c_str(), SxString, &s );
break;
}
case StringVectorDataTypeId :
{
const std::vector<std::string> &strings = static_cast<const StringVectorData *>( it->second.get() )->readable();
std::vector<const char *> charPtrs; charPtrs.resize( strings.size() );
for( unsigned i=0; i<strings.size(); i++ )
{
charPtrs[i] = strings[i].c_str();
}
SxSetParameter( parameterList, it->first.value().c_str(), SxString, &(charPtrs[0]), false, strings.size() );
break;
}
case SplineffDataTypeId :
{
const IECore::Splineff &spline = static_cast<const SplineffData *>( it->second.get() )->readable();
size_t size = spline.points.size();
if( size )
{
vector<float> positions( size );
vector<float> values( size );
size_t i = 0;
for( IECore::Splineff::PointContainer::const_iterator sIt=spline.points.begin(); sIt!=spline.points.end(); sIt++ )
{
positions[i] = sIt->first;
values[i] = sIt->second;
i++;
}
string positionsName = it->first.value() + "Positions";
string valuesName = it->first.value() + "Values";
SxSetParameter( parameterList, positionsName.c_str(), SxFloat, &(positions[0]), false, size );
SxSetParameter( parameterList, valuesName.c_str(), SxFloat, &(values[0]), false, size );
}
else
{
msg( Msg::Warning, "IECoreRI::SXRendererImplementation::createShader", boost::format( "SplinefColor3f parameter \"%s\" has no points and will be ignored" ) % it->second->typeName() );
}
break;
}
case SplinefColor3fDataTypeId :
{
const IECore::SplinefColor3f &spline = static_cast<const SplinefColor3fData *>( it->second.get() )->readable();
size_t size = spline.points.size();
if( size )
{
vector<float> positions( size );
vector<Color3f> values( size );
size_t i = 0;
for( IECore::SplinefColor3f::PointContainer::const_iterator sIt=spline.points.begin(); sIt!=spline.points.end(); sIt++ )
{
positions[i] = sIt->first;
values[i] = sIt->second;
i++;
}
string positionsName = it->first.value() + "Positions";
string valuesName = it->first.value() + "Values";
SxSetParameter( parameterList, positionsName.c_str(), SxFloat, &(positions[0]), false, size );
SxSetParameter( parameterList, valuesName.c_str(), SxColor, &(values[0]), false, size );
}
else
{
msg( Msg::Warning, "IECoreRI::SXRendererImplementation::createShader", boost::format( "SplinefColor3f parameter \"%s\" has no points and will be ignored" ) % it->second->typeName() );
}
break;
}
default :
msg( Msg::Warning, "IECoreRI::SXRendererImplementation::createShader", boost::format( "Unsupported parameter type \"%s\"" ) % it->second->typeName() );
}
}
return SxCreateShader( m_stateStack.top().context.get(), parameterList, name, handle );
}