Overlay( QWidget *parent, Editor *editor ):
QwtWidgetOverlay( parent ),
d_editor( editor )
{
switch( editor->mode() )
{
case Editor::NoMask:
{
setMaskMode( QwtWidgetOverlay::NoMask );
setRenderMode( QwtWidgetOverlay::AutoRenderMode );
break;
}
case Editor::Mask:
{
setMaskMode( QwtWidgetOverlay::MaskHint );
setRenderMode( QwtWidgetOverlay::AutoRenderMode );
break;
}
case Editor::AlphaMask:
{
setMaskMode( QwtWidgetOverlay::AlphaMask );
setRenderMode( QwtWidgetOverlay::AutoRenderMode );
break;
}
case Editor::AlphaMaskRedraw:
{
setMaskMode( QwtWidgetOverlay::AlphaMask );
setRenderMode( QwtWidgetOverlay::DrawOverlay );
break;
}
case Editor::AlphaMaskCopyMask:
{
setMaskMode( QwtWidgetOverlay::AlphaMask );
setRenderMode( QwtWidgetOverlay::CopyAlphaMask );
break;
}
}
}
GlWindow::GlWindow (mxWindow *parent, int x, int y, int w, int h, const char *label, int style)
: mxGlWindow (parent, x, y, w, h, label, style)
{
d_rotX = d_rotY = 0;
d_transX = d_transY = 0;
d_transZ = 50;
d_models[0] = 0;
d_models[1] = 0;
d_textureNames[0] = 0;
d_textureNames[1] = 0;
d_textureNames[2] = 0;
d_textureNames[3] = 0;
setFrameInfo (0, 0);
setRenderMode (0);
setFlag (F_WATER, false);
setFlag (F_LIGHT, true);
setFlag (F_SHININESS, true);
setFlag (F_INTERPOLATE, true);
setFlag (F_GLCOMMANDS, true);
setFlag (F_PAUSE, false);
setFlag (F_BACKGROUND, false);
setPitch (125.0f);
setBGColor (0.0f, 0.0f, 0.0f);
setFGColor (1.0f, 1.0f, 1.0f);
setWFColor (1.0f, 1.0f, 1.0f);
setLightColor (1.0f, 1.0f, 1.0f);
setBrightness (5);
setTextureLimit (256);
loadTexture ("water.pcx", TEXTURE_WATER);
glCullFace (GL_FRONT);
mx::setIdleWindow (this);
#ifdef FULLSCREEN
setVisible (true);
#endif
}
LocalInitData& LocalInitData::operator = ( const LocalInitData& from )
{
_maxFrames = from._maxFrames;
_color = from._color;
_isResident = from._isResident;
_filenames = from._filenames;
_pathFilename = from._pathFilename;
setWindowSystem( from.getWindowSystem( ));
setRenderMode( from.getRenderMode( ));
if( from.useGLSL( ))
enableGLSL();
if( from.useInvertedFaces( ))
enableInvertedFaces();
if( !from.showLogo( ))
disableLogo();
if( !from.useROI( ))
disableROI();
return *this;
}
void HxGLSLVertexView::update()
{
if (portDrawStyle.isNew())
{
setRenderMode((DrawStyles)portDrawStyle.getValue());
portSphereScale.setVisible( portDrawStyle.getValue() != POINTS );
}
if (portData.isNew())
{
HxVertexSet* data = hxconnection_cast<HxVertexSet>(portData);
if (data)
{
const McVec3f size = data->getBoundingBoxSize();
float min_size = MC_MIN3(size[0], size[1],size[2]) / 30.0f;
portSphereScale.setMinMax(0, min_size);
portSphereScale.setValue( min_size / 2.0f);
}
}
}
inline void toggleRenderMode(render_mode in_rm) {
setRenderMode(in_rm, !isRenderModeEnabled(in_rm));
}
void LocalInitData::parseArguments( const int argc, char** argv )
{
try
{
std::string wsHelp = "Window System API ( one of: ";
#ifdef AGL
wsHelp += "AGL ";
#endif
#ifdef GLX
wsHelp += "glX ";
#endif
#ifdef WGL
wsHelp += "WGL ";
#endif
wsHelp += ")";
const std::string& desc = EqPly::getHelp();
TCLAP::CmdLine command( desc, ' ', eq::Version::getString( ));
TCLAP::MultiArg<std::string> modelArg( "m", "model",
"ply model file name or directory",
false, "string", command );
TCLAP::ValueArg<std::string> portArg( "p", "port",
"tracking device port",
false, "/dev/ttyS0", "string",
command );
TCLAP::SwitchArg colorArg( "b", "blackAndWhite",
"Don't use colors from ply file",
command, false );
TCLAP::SwitchArg residentArg( "r", "resident",
"Keep client resident (see resident node documentation on website)",
command, false );
TCLAP::ValueArg<uint32_t> framesArg( "n", "numFrames",
"Maximum number of rendered frames",
false, 0xffffffffu, "unsigned",
command );
TCLAP::ValueArg<std::string> wsArg( "w", "windowSystem", wsHelp,
false, "auto", "string", command );
TCLAP::ValueArg<std::string> modeArg( "c", "renderMode",
"Rendering Mode (immediate, displayList, VBO)",
false, "auto", "string",
command );
TCLAP::SwitchArg glslArg( "g", "glsl", "Enable GLSL shaders",
command, false );
TCLAP::SwitchArg invFacesArg( "i", "invertFaces",
"Invert faces (valid during binary file creation)",
command, false );
TCLAP::ValueArg<std::string> pathArg( "a", "cameraPath",
"File containing camera path animation",
false, "", "string", command );
TCLAP::SwitchArg overlayArg( "o", "noOverlay", "Disable overlay logo",
command, false );
TCLAP::VariableSwitchArg ignoreEqArgs( "eq",
"Ignored Equalizer options",
command );
TCLAP::UnlabeledMultiArg< std::string >
ignoreArgs( "ignore", "Ignored unlabeled arguments", false, "any",
command );
TCLAP::SwitchArg roiArg( "d", "disableROI", "Disable ROI", command,
false );
command.parse( argc, argv );
if( modelArg.isSet( ))
{
_filenames.clear();
_filenames = modelArg.getValue();
}
if( portArg.isSet( ))
_trackerPort = portArg.getValue();
if( wsArg.isSet( ))
{
std::string windowSystem = wsArg.getValue();
transform( windowSystem.begin(), windowSystem.end(),
windowSystem.begin(), (int(*)(int))std::toupper );
setWindowSystem( windowSystem );
}
_color = !colorArg.isSet();
if( framesArg.isSet( ))
_maxFrames = framesArg.getValue();
if( residentArg.isSet( ))
_isResident = true;
if( modeArg.isSet() )
{
std::string mode = modeArg.getValue();
transform( mode.begin(), mode.end(), mode.begin(),
(int(*)(int))std::tolower );
if( mode == "immediate" )
setRenderMode( mesh::RENDER_MODE_IMMEDIATE );
else if( mode == "displaylist" )
setRenderMode( mesh::RENDER_MODE_DISPLAY_LIST );
else if( mode == "vbo" )
setRenderMode( mesh::RENDER_MODE_BUFFER_OBJECT );
}
if( pathArg.isSet( ))
_pathFilename = pathArg.getValue();
if( glslArg.isSet() )
enableGLSL();
if( invFacesArg.isSet() )
enableInvertedFaces();
if( overlayArg.isSet( ))
disableLogo();
if( roiArg.isSet( ))
disableROI();
}
catch( const TCLAP::ArgException& exception )
{
LBERROR << "Command line parse error: " << exception.error()
<< " for argument " << exception.argId() << std::endl;
::exit( EXIT_FAILURE );
}
}
DRReturn InfiniteSphere::init(int gridSize, DRVector3 edgePoints[4])
{
//! memory allocation
// size = gridSize
// vertexCount = 4 +(size-1)*2 + (size-1)*2 + (size-1)*(size-1)*1 => 2*size + size*size + 1
u32 vertexCount = 2*gridSize + gridSize*gridSize +1;
// indexCount = (size-1) * (4 +(size-1)*2) + 2*size+2 => 2*size + 2*(size*size)
u32 indexCount = 2*(gridSize*gridSize)+2*gridSize;
//if(init(vertexCount, indexCount, textureCount, color, normals))
if(DRGeometrie::init(vertexCount, indexCount, 0, false, false))
LOG_ERROR("no memory allocated for geometrie!", DR_ERROR);
DRVector3 xVectorPart = (edgePoints[1]-edgePoints[0])/gridSize;
DRVector3 yVectorPart = (edgePoints[2]-edgePoints[0])/gridSize;
for(u32 j = 1; j < gridSize+1; j++)
{
for(u32 i = 0; i < gridSize+1; i++)
{
mIndices[mIndexCount++] = mVertexCount;
mVertices[mVertexCount++] = edgePoints[0] + xVectorPart*i + yVectorPart*j;
if(j == 1)
{
mIndices[mIndexCount++] = mVertexCount;
mVertices[mVertexCount++] = edgePoints[0] + xVectorPart*i;
}
else if(j == 2)
mIndices[mIndexCount++] = i*2;
else
mIndices[mIndexCount++] = (gridSize*2+2)+i+(j-3)*(gridSize+1);
}
}
DRLog.writeToLog("vertexCount: %d, indexCount: %d", mVertexCount, mIndexCount);
/*
for(u32 i = 0; i < mVertexCount; i++)
{
if(mSphericalCenter != DRVector3(0.0f))
{
DRVector3 dir = DRVector3(mVertices[i]-mSphericalCenter);
float length = dir.length();
//printf("length: %f, newSize: %f, vertex: %d: %f, %f, %f", length, 1.0f-length, i, mVertices[i].x, mVertices[i].y, mVertices[i].z);
//printf(" dir: %f, %f, %f ", dir.x, dir.y, dir.z);
//mVertices[i] += (dir / length) * (1.0f-length);
//printf(" newvertex: %f, %f, %f\n", mVertices[i].x, mVertices[i].y, mVertices[i].z);
//mVertices[i] = dir.normalize();
if(mHeightValues)
{
mColors[i] = mHeightValues->getColorValue(mHeightValues->getHeightValue(dir));
}
}
else
{
if(mHeightValues)
{
mColors[i] = mHeightValues->getColorValue(mHeightValues->getHeightValue(mVertices[i]));
}
}
}
* */
setRenderMode(GL_TRIANGLE_STRIP);
copyDataToVertexBuffer(GL_STATIC_DRAW_ARB, true);
return DR_OK;
}
int
GlWindow::handleEvent (mxEvent *event)
{
static float oldrx = 0, oldry = 0, oldtz = 50, oldtx = 0, oldty = 0;
static int oldx, oldy;
switch (event->event)
{
case mxEvent::MouseDown:
oldrx = d_rotX;
oldry = d_rotY;
oldtx = d_transX;
oldty = d_transY;
oldtz = d_transZ;
oldx = event->x;
oldy = event->y;
//setFlag (F_PAUSE, false);
break;
case mxEvent::MouseDrag:
if (event->buttons & mxEvent::MouseLeftButton)
{
if (event->modifiers & mxEvent::KeyShift)
{
d_transX = oldtx - (float) (event->x - oldx);
d_transY = oldty + (float) (event->y - oldy);
}
else
{
d_rotX = oldrx + (float) (event->y - oldy);
d_rotY = oldry + (float) (event->x - oldx);
}
}
else if (event->buttons & mxEvent::MouseRightButton)
{
d_transZ = oldtz + (float) (event->y - oldy);
}
redraw ();
break;
case mxEvent::Idle:
{
static int timer = 0, lastTimer = 0;
if (getFlag (F_PAUSE))
return 0;
lastTimer = timer;
timer = mx::getTickCount ();
float diff = (float) (timer - lastTimer);
fps = 1/ (diff / 1000.0f);
d_pol += diff / d_pitch;
if (d_pol > 1.0f)
{
d_pol = 0.0f;
d_currFrame++;
d_currFrame2++;
if (d_currFrame > d_endFrame)
d_currFrame = d_startFrame;
if (d_currFrame2 > d_endFrame)
d_currFrame2 = d_startFrame;
}
redraw ();
}
break;
case mxEvent::KeyDown:
{
#ifdef FULLSCREEN
switch (event->key)
{
case 27:
delete this;
mx::quit ();
break;
case 36: // Home
{
if (getModel (0))
{
float minmax[6];
md2_getBoundingBox (getModel (0), minmax);
// center vertically
d_transY = (minmax[3] + minmax[2]) / 2;
// adjust distance
float dx = minmax[1] - minmax[0];
float dy = minmax[3] - minmax[2];
float dz = minmax[5] - minmax[4];
float d = dx;
if (dy > d)
d = dy;
if (dz > d)
d = dz;
d_transZ = d * 1.2f;
d_transX = 0;
d_rotX = d_rotY = 0.0f;
redraw ();
}
}
break;
case '+':
d_pitch -= 10.0f;
if (d_pitch < 1.0f)
d_pitch = 1.0f;
break;
case '-':
d_pitch += 10.0f;
break;
case 'l':
setFlag (F_LIGHT, !getFlag (F_LIGHT));
redraw ();
break;
case 'w':
setFlag (F_WATER, !getFlag (F_WATER));
redraw ();
break;
case 's':
setFlag (F_SHININESS, !getFlag (F_SHININESS));
redraw ();
break;
case 'p':
setFlag (F_PAUSE, !getFlag (F_PAUSE));
break;
case 'b':
setFlag (F_BACKGROUND, !getFlag (F_BACKGROUND));
redraw ();
break;
case '1':
case '2':
case '3':
case '4':
setRenderMode (event->key - '1');
redraw ();
break;
}
#endif
}
break;
}
return 1;
}
PD_UI_Dialogue::PD_UI_Dialogue(BulletWorld * _world, PD_UI_Bubble * _uiBubble) :
NodeUI(_world),
uiBubble(_uiBubble),
textBubble(new NodeUI_NineSliced(world, dynamic_cast<Texture_NineSliced *>(PD_ResourceManager::scenario->getTexture("NPC-BUBBLE")->texture))),
text(new TextArea(world, PD_ResourceManager::scenario->getFont("FONT")->font, uiBubble->textShader)),
currentSpeaker(nullptr),
speechTimeout(nullptr),
hadNextDialogue(false)
{
text->setWrapMode(kWORD);
setRenderMode(kTEXTURE);
VerticalLinearLayout * vl = new VerticalLinearLayout(world);
vl->setRationalWidth(1.f, this);
vl->setRationalHeight(1.f, this);
vl->horizontalAlignment = kCENTER;
vl->verticalAlignment = kTOP;
VerticalLinearLayout * vl2 = new VerticalLinearLayout(world);
vl2->horizontalAlignment = kCENTER;
vl2->verticalAlignment = kMIDDLE;
addChild(vl);
vl->addChild(textBubble);
textBubble->setMargin(15,15,0,15);
textBubble->setBorder(PD_ResourceManager::scenario->getFont("FONT")->font->getLineHeight());
textBubble->setRationalWidth(0.9f, vl);
textBubble->setRationalHeight(0.25f, vl);
textBubble->addChild(vl2);
vl2->setRationalWidth(1.f, textBubble);
vl2->setRationalHeight(1.f, textBubble);
vl2->addChild(text);
vl2->setPadding(0.03f, 0.f);
text->setRationalWidth(1.f, vl2);
text->verticalAlignment = kMIDDLE;
background->setVisible(false);
// disable and hide by default
setVisible(false);
speechTimeout = new Timeout(0.15, [this](sweet::Event * _event){
if(speechBuffer.size() > 0) {
std::wstring word = speechBuffer.front();
char fc = tolower(word.at(word.size()/2));
speechBuffer.pop();
if(currentSpeaker != nullptr){
auto sound = currentSpeaker->voice;
if(sweet::CharacterUtils::isLetter(fc) || sweet::CharacterUtils::isDigit(fc)){
sound->setPitch((fc-100.f)/100.f+1.0f);
sound->play();
}
}
speechTimeout->restart();
}else {
if(currentSpeaker != nullptr) {
currentSpeaker->pr->talking = false;
}
}
});
}
PD_UI_Task::PD_UI_Task(BulletWorld * _world, Font * _font, ComponentShaderText * _textShader):
NodeUI(_world)
{
setRenderMode(kTEXTURE);
background->setVisible(false);
setAlpha(0.f);
NodeUI * container = new NodeUI(_world);
addChild(container);
container->setRationalWidth(1.f, this);
container->setRationalHeight(1.f, this);
container->background->setVisible(false);
VerticalLinearLayout * checkContainer = checkBox = new VerticalLinearLayout(world);
container->addChild(checkContainer);
checkContainer->horizontalAlignment = kCENTER;
checkContainer->verticalAlignment = kMIDDLE;
checkContainer->setWidth(PD_ResourceManager::scenario->getFont("FONT")->font->getLineHeight());
checkContainer->setRationalHeight(1.f, container);
checkContainer->background->setVisible(false);
checkBox = new VerticalLinearLayout(world);
checkBox->horizontalAlignment = kCENTER;
checkBox->verticalAlignment = kMIDDLE;
checkContainer->addChild(checkBox);
checkBox->setRationalWidth(0.75f, checkContainer);
checkBox->setSquareHeight(1.f);
checkBox->background->mesh->pushTexture2D(PD_ResourceManager::scenario->getTexture("JOURNAL-CHECK-BOX")->texture);
checkBox->background->mesh->setScaleMode(GL_NEAREST);
checkBox->setBackgroundColour(1.f, 1.f, 1.f, 1.f);
checkBox->background->setVisible(true);
checkMark = new NodeUI(world);
checkBox->addChild(checkMark);
checkMark->setRationalWidth(0.f, checkBox);
checkMark->setSquareHeight(1.f);
checkMark->background->mesh->pushTexture2D(PD_ResourceManager::scenario->getTexture("JOURNAL-CHECK-MARK")->texture);
checkMark->background->mesh->setScaleMode(GL_NEAREST);
checkMark->setVisible(false);
text = new TextArea(world, _font, _textShader);
text->setWrapMode(kWORD);
text->verticalAlignment = kMIDDLE;
container->addChild(text);
text->setRationalWidth(1.f, container);
text->setRationalHeight(1.f, container);
text->marginLeft.setRationalSize(1.f, &checkContainer->width);
text->background->setVisible(false);
addTimeout = new Timeout(1.f, [this](sweet::Event * _event){
setAlpha(1.f);
});
addTimeout->eventManager->addEventListener("start", [this](sweet::Event * _event){
setAlpha(0.f);
});
addTimeout->eventManager->addEventListener("progress", [this](sweet::Event * _event){
float p = _event->getFloatData("progress");
setAlpha(p);
});
childTransform->addChild(addTimeout, false);
checkTimeout = new Timeout(0.5f, [this](sweet::Event * _event){
checkMark->setRationalWidth(1.f, checkMark->nodeUIParent);
invalidateLayout();
invalidateRenderFrame();
});
checkTimeout->eventManager->addEventListener("start", [this](sweet::Event * _event){
checkMark->setVisible(true);
invalidateLayout();
invalidateRenderFrame();
});
checkTimeout->eventManager->addEventListener("progress", [this](sweet::Event * _event){
float p = _event->getFloatData("progress");
p = Easing::easeOutElastic(p, 0.f, 1.f, checkTimeout->targetSeconds, -1, 4.f);
checkMark->setRationalWidth(p, checkMark->nodeUIParent);
invalidateLayout();
invalidateRenderFrame();
});
childTransform->addChild(checkTimeout, false);
}
int
ControlPanel::handleEvent (mxEvent *event)
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
int iret = 0;
if ( HandleToolEvent( event ) )
{
return iret;
}
switch ( event->event )
{
case mxEvent::Size:
{
PositionControls( event->width, event->height );
iret = 1;
}
break;
case mxEvent::Action:
{
iret = 1;
switch (event->action)
{
case IDC_TOOLSDRIVEMOUTH:
{
g_viewerSettings.faceposerToolsDriveMouth = ((mxCheckBox *)event->widget)->isChecked();
}
break;
case IDC_TAB:
{
g_viewerSettings.showTexture = (tab->getSelectedIndex() == 3);
}
break;
case IDC_RENDERMODE:
{
int index = cRenderMode->getSelectedIndex();
if (index >= 0)
{
setRenderMode (index);
}
}
break;
case IDC_GROUND:
setShowGround (((mxCheckBox *) event->widget)->isChecked());
break;
case IDC_MOVEMENT:
setShowMovement (((mxCheckBox *) event->widget)->isChecked());
break;
case IDC_BACKGROUND:
setShowBackground (((mxCheckBox *) event->widget)->isChecked());
break;
case IDC_HITBOXES:
g_viewerSettings.showHitBoxes = ((mxCheckBox *) event->widget)->isChecked();
break;
case IDC_PHYSICSMODEL:
g_viewerSettings.showPhysicsModel = ((mxCheckBox *) event->widget)->isChecked();
break;
case IDC_BONES:
g_viewerSettings.showBones = ((mxCheckBox *) event->widget)->isChecked();
break;
case IDC_ATTACHMENTS:
g_viewerSettings.showAttachments = ((mxCheckBox *) event->widget)->isChecked();
break;
case IDC_SEQUENCE:
{
int index = cSequence->getSelectedIndex();
if (index >= 0)
{
setSequence ( index );
}
}
break;
case IDC_SPEEDSCALE:
{
g_viewerSettings.speedScale = ((mxSlider *) event->widget)->getValue();
lSpeedScale->setLabel( va( "Speed scale %.2f", g_viewerSettings.speedScale ) );
}
break;
case IDC_PRIMARYBLEND:
{
setBlend( 0, ((mxSlider *) event->widget)->getValue() );
}
break;
case IDC_SECONDARYBLEND:
{
setBlend( 1, ((mxSlider *) event->widget)->getValue() );
}
break;
case IDC_BODYPART:
{
int index = cBodypart->getSelectedIndex();
if (index >= 0)
{
setBodypart (index);
}
}
break;
case IDC_SUBMODEL:
{
int index = cSubmodel->getSelectedIndex();
if (index >= 0)
{
setSubmodel (index);
}
}
break;
case IDC_CONTROLLER:
{
int index = cController->getSelectedIndex();
if (index >= 0)
setBoneController (index);
}
break;
case IDC_CONTROLLERVALUE:
{
int index = cController->getSelectedIndex();
if (index >= 0)
setBoneControllerValue (index, slController->getValue());
}
break;
case IDC_SKINS:
{
int index = cSkin->getSelectedIndex();
if (index >= 0)
{
models->GetActiveStudioModel()->SetSkin (index);
g_viewerSettings.skin = index;
g_pMatSysWindow->redraw();
}
}
break;
default:
iret = 0;
break;
}
}
}
return iret;
}
void LocalInitData::parseArguments( const int argc, char** argv )
{
std::string wsHelp = "Window System API ( one of: ";
#ifdef AGL
wsHelp += "AGL ";
#endif
#ifdef GLX
wsHelp += "GLX ";
#endif
#ifdef WGL
wsHelp += "WGL ";
#endif
#ifdef EQUALIZER_USE_QT5WIDGETS
wsHelp += "Qt ";
#endif
wsHelp += ")";
bool showHelp( false );
std::vector<std::string> userDefinedModelPath;
bool userDefinedBlackWhiteMode( false );
std::string userDefinedWindowSystem("");
std::string userDefinedRenderMode("");
bool userDefinedUseGLSL( false );
bool userDefinedInvertFaces( false );
bool userDefinedDisableLogo( false );
bool userDefinedDisableROI( false );
const std::string& desc = EqPly::getHelp();
po::options_description options( desc + " Version " +
eq::Version::getString(),
lunchbox::term::getSize().first );
options.add_options()
( "help,h", po::bool_switch(&showHelp)->default_value( false ),
"produce help message" )
( "model,m",
po::value<std::vector<std::string> >( &userDefinedModelPath ),
"ply model file names or directories" )
( "blackAndWhite,b",
po::bool_switch(&userDefinedBlackWhiteMode)->default_value( false ),
"Don't use colors from ply file" )
( "resident,r", po::bool_switch(&_isResident)->default_value( false ),
"Keep client resident (see resident mode documentation on website)" )
( "numFrames,n",
po::value<uint32_t>(&_maxFrames)->default_value(0xffffffffu),
"Maximum number of rendered frames")
( "windowSystem,w", po::value<std::string>( &userDefinedWindowSystem ),
wsHelp.c_str() )
( "renderMode,c", po::value<std::string>( &userDefinedRenderMode ),
"Rendering Mode (immediate|displayList|VBO)" )
( "glsl,g",
po::bool_switch(&userDefinedUseGLSL)->default_value( false ),
"Enable GLSL shaders" )
( "invertFaces,i"
, po::bool_switch(&userDefinedInvertFaces)->default_value( false ),
"Invert faces (valid during binary file creation)" )
( "cameraPath,a", po::value<std::string>(&_pathFilename),
"File containing camera path animation" )
( "noOverlay,o",
po::bool_switch(&userDefinedDisableLogo)->default_value( false ),
"Disable overlay logo" )
( "disableROI,d",
po::bool_switch(&userDefinedDisableROI)->default_value( false ),
"Disable region of interest (ROI)" );
po::variables_map variableMap;
try
{
// parse program options, ignore all non related options
po::store( po::command_line_parser( argc, argv ).options(
options ).allow_unregistered().run(),
variableMap );
po::notify( variableMap );
}
catch( std::exception& exception )
{
LBERROR << "Error parsing command line: " << exception.what()
<< std::endl;
eq::exit(); // cppcheck-suppress unreachableCode
::exit( EXIT_FAILURE );
}
// Evaluate parsed command line options
if( showHelp )
{
std::cout << options << std::endl
<< eq::getHelp() << eq::Client::getHelp() << std::endl;
eq::exit(); // cppcheck-suppress unreachableCode
::exit( EXIT_SUCCESS );
}
if( variableMap.count("model") > 0 )
{
_filenames.clear();
_filenames = userDefinedModelPath;
}
_color = !userDefinedBlackWhiteMode;
if( variableMap.count("windowSystem") > 0 )
setWindowSystem( userDefinedWindowSystem );
if( variableMap.count("renderMode") > 0 )
{
std::transform( userDefinedRenderMode.begin(),
userDefinedRenderMode.end(),
userDefinedRenderMode.begin(),
(int(*)(int))std::tolower );
if( userDefinedRenderMode == "immediate" )
setRenderMode( triply::RENDER_MODE_IMMEDIATE );
else if( userDefinedRenderMode == "displaylist" )
setRenderMode( triply::RENDER_MODE_DISPLAY_LIST );
else if( userDefinedRenderMode == "vbo" )
setRenderMode( triply::RENDER_MODE_BUFFER_OBJECT );
}
if( userDefinedUseGLSL )
enableGLSL();
if( userDefinedInvertFaces)
enableInvertedFaces();
if( userDefinedDisableLogo )
disableLogo();
if( userDefinedDisableROI )
disableROI();
}