/*! Check if the Material (i.e. any of its materials) is transparent..
*/
bool MultiPassMaterial::isTransparent(void) const
{
Int32 tm = getTransparencyMode();
if(tm != Material::TransparencyAutoDetection)
{
return (tm == Material::TransparencyForceTransparent);
}
MFMaterialPtr::const_iterator it = _mfMaterials.begin();
MFMaterialPtr::const_iterator matsEnd = _mfMaterials.end();
// ok just check the first (base) material.
if(it != matsEnd && (*it) != NullFC && (*it)->isTransparent())
return true;
return false;
}
bool ChunkMaterial::isTransparent(void) const
{
Int32 tm = getTransparencyMode();
if(tm != Material::TransparencyAutoDetection)
{
return (tm == Material::TransparencyForceTransparent);
}
bool returnValue = false;
MFChunksType::const_iterator chunksIt = _mfChunks.begin();
MFChunksType::const_iterator chunksEnd = _mfChunks.end ();
for(; chunksIt != chunksEnd && returnValue == false; ++chunksIt)
{
returnValue = (*chunksIt)->isTransparent();
}
return returnValue;
}
int runApp( int argc, char *argv[], options::variables_map const& opts )
{
QApplication app( argc, argv );
// Create rendering engine
dp::sg::renderer::rix::gl::SceneRendererSharedPtr renderer = dp::sg::renderer::rix::gl::SceneRenderer::create
(
opts["renderengine"].as<std::string>().c_str()
, getShaderManager( opts["shadermanager"].as<std::string>() )
, getCullingMode( opts["cullingengine"].as<std::string>() )
, getTransparencyMode( opts["transparency"].as<std::string>() )
);
renderer->setCullingEnabled( opts["culling"].as<bool>() );
renderer->setDepthPass( opts["depthPass"].as<bool>() );
if ( !opts["effectlibrary"].empty() )
{
dp::fx::EffectLibrary::instance()->loadEffects( opts["effectlibrary"].as<std::string>() );
}
if ( !opts["environment"].empty() )
{
dp::sg::core::TextureSharedPtr texture = dp::sg::core::TextureFile::create( opts["environment"].as<std::string>() );
dp::sg::core::SamplerSharedPtr sampler = dp::sg::core::Sampler::create( texture );
renderer->setEnvironmentSampler( sampler );
}
dp::sg::ui::ViewStateSharedPtr viewState = loadScene( opts["filename"].as<std::string>() );
if ( opts.count("replace") )
{
// process replacements
std::vector< std::string> replacementStrings = opts["replace"].as< std::vector<std::string > >();
dp::sg::algorithm::ReplacementMapNames replacements;
for ( std::vector<std::string>::iterator it = replacementStrings.begin(); it != replacementStrings.end(); ++it )
{
size_t equalChar = it->find_first_of(':');
if ( equalChar != std::string::npos && equalChar < it->size() - 1)
{
std::string str1 = it->substr( 0, equalChar );
std::string str2 = it->substr( equalChar + 1, it->size() - equalChar - 1);
replacements[str1] = str2;
}
else
{
std::cerr << "invalid replacement token: " << *it << std::endl;
}
}
dp::sg::algorithm::replaceEffectDatas( viewState->getScene(), replacements );
}
else if ( !opts["replaceAll"].empty() )
{
dp::sg::core::EffectDataSharedPtr replacement = dp::sg::core::EffectData::create( dp::fx::EffectLibrary::instance()->getEffectData( opts["replaceAll"].as<std::string>() ) );
DP_ASSERT( replacement );
DP_ASSERT( viewState && viewState->getScene() && viewState->getScene()->getRootNode() );
const std::vector<dp::sg::core::ObjectSharedPtr> vp = dp::sg::algorithm::searchClass( viewState->getScene()->getRootNode(), "class dp::sg::core::GeoNode", true );
for ( size_t i=0 ; i<vp.size() ; i++ )
{
vp[i].inplaceCast<dp::sg::core::GeoNode>()->setMaterialEffect( replacement );
}
}
if ( !opts["generateTexCoords"].empty() )
{
dp::sg::core::TextureCoordType tct = getTextureCoordType( opts["generateTexCoords"].as<std::string>() );
DP_ASSERT( viewState && viewState->getScene() && viewState->getScene()->getRootNode() );
const std::vector<dp::sg::core::ObjectSharedPtr> vp = dp::sg::algorithm::searchClass( viewState->getScene()->getRootNode(), "class dp::sg::core::Primitive", true );
for ( size_t i=0 ; i<vp.size() ; i++ )
{
vp[i].inplaceCast<dp::sg::core::Primitive>()->generateTexCoords( tct, dp::sg::core::VertexAttributeSet::DP_SG_TEXCOORD0, false );
// don't overwrite if there already are some texture coordinate ^^^^^
}
}
if ( !opts["generateTangentSpace"].empty() )
{
DP_ASSERT( viewState && viewState->getScene() && viewState->getScene()->getRootNode() );
const std::vector<dp::sg::core::ObjectSharedPtr> vp = dp::sg::algorithm::searchClass( viewState->getScene()->getRootNode(), "class dp::sg::core::Primitive", true );
for ( size_t i=0 ; i<vp.size() ; i++ )
{
vp[i].inplaceCast<dp::sg::core::Primitive>()->generateTangentSpace( dp::sg::core::VertexAttributeSet::DP_SG_TEXCOORD0
, dp::sg::core::VertexAttributeSet::DP_SG_TANGENT
, dp::sg::core::VertexAttributeSet::DP_SG_BINORMAL
, false );
// don't overwrite if there already are some texture coordinate ^^^^^
}
}
if ( opts.count("gridSize") )
{
DP_ASSERT( viewState && viewState->getScene() && viewState->getScene()->getRootNode() );
std::vector<unsigned int> gridSizes = opts["gridSize"].as<std::vector<unsigned int> >();
dp::math::Vec3ui gridSize;
int i;
for ( i=0 ; i<3 && i<gridSizes.size() ; i++ )
{
gridSize[i] = gridSizes[i];
}
for ( ; i<3 ; i++ )
{
gridSize[i] = 1;
}
dp::math::Vec3f gridSpacing = dp::math::Vec3f( 1.0f, 1.0f, 1.0f );
if ( opts.count("gridSpacing") )
{
std::vector<float> gridSpacings = opts["gridSpacing"].as<std::vector<float> >();
for ( int i=0 ; i<3 && i<gridSpacings.size() ; i++ )
{
gridSpacing[i] = gridSpacings[i];
}
}
viewState->getScene()->setRootNode( dp::sg::generator::replicate( viewState->getScene()->getRootNode(), gridSize, gridSpacing, opts["gridClone"].as<bool>() ) );
}
if ( !opts["statistics"].empty() )
{
showStatistics( viewState );
}
dp::sg::ui::setupDefaultViewState( viewState );
if ( !opts["combineVertexAttributes"].empty() )
{
combineVertexAttributes( viewState );
}
{
// Replace MatrixCamera by PerspectiveCamera to get all manipulator features
if ( viewState->getCamera()->getObjectCode() == dp::sg::core::OC_MATRIXCAMERA )
{
dp::sg::core::PerspectiveCameraSharedPtr perspectiveCamera = dp::sg::core::PerspectiveCamera::create();
perspectiveCamera->setOrientation(viewState->getCamera()->getOrientation());
perspectiveCamera->setDirection((viewState->getCamera()->getDirection()));
perspectiveCamera->setPosition(viewState->getCamera()->getPosition());
viewState->setAutoClipPlanes(true);
viewState->setCamera(perspectiveCamera);
}
}
viewState->setAutoClipPlanes( opts["autoclipplanes"].as<bool>() );
if ( !opts["zoom"].empty() )
{
DP_ASSERT( viewState && viewState->getCamera() );
viewState->getCamera()->zoom( opts["zoom"].as<float>() );
}
if ( !opts["headlight"].empty() )
{
if ( viewState && viewState->getScene() && !dp::sg::algorithm::containsLight( viewState->getScene() )
&& viewState->getCamera() && ( viewState->getCamera()->getNumberOfHeadLights() == 0 ) )
{
// Use the defaults! Note that LightSource ambientColor is black.
viewState->getCamera()->addHeadLight( dp::sg::core::createStandardPointLight() );
}
}
// Setup default OpenGL format descriptor
// We need to create a default format first to be able to check if a stereo pixelformat is available later.
// (An unfortunate RenderContextFormat.isAvailable() interface due to Linux.)
dp::gl::RenderContextFormat format;
// create a widget which shows the scene
QtMinimalWidget w( format );
w.setSceneName( opts["filename"].as<std::string>() );
w.setViewState( viewState );
w.setSceneRenderer( renderer );
if ( opts["multiSample"].as<unsigned int>() != 0 )
{
unsigned int samples = opts["multiSample"].as<unsigned int>();
unsigned int coverage = std::max( samples, opts["multiSampleCoverage"].as<unsigned int>() );
format.setMultisampleCoverage( samples, coverage );
if ( !w.setFormat( format ) )
{
std::cout << "Warning: No Coverage Sampling Antialiasing ( " << samples << "/" << coverage << " ) pixelformat available." << std::endl;
if ( samples != coverage )
{
format.setMultisample( samples );
if ( !w.setFormat( format ) )
{
std::cout << "Warning: No Multisample Antialiasing ( " << samples << " ) pixelformat available." << std::endl;
}
}
}
}
if ( !opts["stereo"].empty() )
{
format.setStereo( true );
if ( !w.setFormat( format ) ) // This automatically checks if the format is available.
{
std::cout << "Warning: No stereo pixelformat available." << std::endl;
}
}
if( opts["frames"].as<unsigned int>() != ~0 )
{
w.setNumberOfFrames( opts["frames"].as<unsigned int>() );
}
w.setDuration( opts["duration"].as<double>() );
if ( !opts["continuous"].empty() )
{
w.setContinuousUpdate( true );
w.setShowFrameRate( true );
}
if ( !opts["orbit"].empty() )
{
w.setOrbit( opts["orbit"].as<float>() );
}
if ( !opts["fullscreen"].empty() )
{
w.showFullScreen();
}
else if ( !opts["maximized"].empty() )
{
w.showMaximized();
}
else
{
int width = 640;
int height = 480;
if ( opts.count("windowSize") )
{
std::vector<unsigned int> sizes = opts["windowSize"].as<std::vector<unsigned int> >();
if ( 1 <= sizes.size() )
{
width = sizes[0];
if ( 2 <= sizes.size() )
{
height = sizes[1];
}
}
}
w.resize( width, height );
}
w.show();
// Keep only once reference to the renderer in the widget. This is necessary since the OpenGL resources
// used by the renderer must be deleted before the window gets destroyed.
renderer.reset();
int result = app.exec();
return result;
}
