Qgs3DMapScene::Qgs3DMapScene( const Qgs3DMapSettings &map, QgsAbstract3DEngine *engine )
: mMap( map )
, mEngine( engine )
{
connect( &map, &Qgs3DMapSettings::backgroundColorChanged, this, &Qgs3DMapScene::onBackgroundColorChanged );
onBackgroundColorChanged();
// TODO: strange - setting OnDemand render policy still keeps QGIS busy (Qt 5.9.0)
// actually it is more busy than with the default "Always" policy although there are no changes in the scene.
//mRenderer->renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::OnDemand );
#if QT_VERSION >= 0x050900
// we want precise picking of terrain (also bounding volume picking does not seem to work - not sure why)
mEngine->renderSettings()->pickingSettings()->setPickMethod( Qt3DRender::QPickingSettings::TrianglePicking );
#endif
QRect viewportRect( QPoint( 0, 0 ), mEngine->size() );
// Camera
float aspectRatio = ( float )viewportRect.width() / viewportRect.height();
mEngine->camera()->lens()->setPerspectiveProjection( mMap.fieldOfView(), aspectRatio, 10.f, 10000.0f );
mFrameAction = new Qt3DLogic::QFrameAction();
connect( mFrameAction, &Qt3DLogic::QFrameAction::triggered,
this, &Qgs3DMapScene::onFrameTriggered );
addComponent( mFrameAction ); // takes ownership
// Camera controlling
mCameraController = new QgsCameraController( this ); // attaches to the scene
mCameraController->setViewport( viewportRect );
mCameraController->setCamera( mEngine->camera() );
mCameraController->resetView( 1000 );
addCameraViewCenterEntity( mEngine->camera() );
// create terrain entity
createTerrainDeferred();
connect( &map, &Qgs3DMapSettings::terrainGeneratorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::terrainVerticalScaleChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::mapTileResolutionChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::maxTerrainScreenErrorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::maxTerrainGroundErrorChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::terrainShadingChanged, this, &Qgs3DMapScene::createTerrain );
connect( &map, &Qgs3DMapSettings::pointLightsChanged, this, &Qgs3DMapScene::updateLights );
connect( &map, &Qgs3DMapSettings::fieldOfViewChanged, this, &Qgs3DMapScene::updateCameraLens );
// create entities of renderers
Q_FOREACH ( const QgsAbstract3DRenderer *renderer, map.renderers() )
{
Qt3DCore::QEntity *newEntity = renderer->createEntity( map );
newEntity->setParent( this );
}
// listen to changes of layers in order to add/remove 3D renderer entities
connect( &map, &Qgs3DMapSettings::layersChanged, this, &Qgs3DMapScene::onLayersChanged );
updateLights();
#if 0
ChunkedEntity *testChunkEntity = new ChunkedEntity( AABB( -500, 0, -500, 500, 100, 500 ), 2.f, 3.f, 7, new TestChunkLoaderFactory );
testChunkEntity->setEnabled( false );
testChunkEntity->setParent( this );
chunkEntities << testChunkEntity;
#endif
connect( mCameraController, &QgsCameraController::cameraChanged, this, &Qgs3DMapScene::onCameraChanged );
connect( mCameraController, &QgsCameraController::viewportChanged, this, &Qgs3DMapScene::onCameraChanged );
#if 0
// experiments with loading of existing 3D models.
// scene loader only gets loaded only when added to a scene...
// it loads everything: geometries, materials, transforms, lights, cameras (if any)
Qt3DCore::QEntity *loaderEntity = new Qt3DCore::QEntity;
Qt3DRender::QSceneLoader *loader = new Qt3DRender::QSceneLoader;
loader->setSource( QUrl( "file:///home/martin/Downloads/LowPolyModels/tree.dae" ) );
loaderEntity->addComponent( loader );
loaderEntity->setParent( this );
// mesh loads just geometry as one geometry...
// so if there are different materials (e.g. colors) used in the model, this information is lost
Qt3DCore::QEntity *meshEntity = new Qt3DCore::QEntity;
Qt3DRender::QMesh *mesh = new Qt3DRender::QMesh;
mesh->setSource( QUrl( "file:///home/martin/Downloads/LowPolyModels/tree.obj" ) );
meshEntity->addComponent( mesh );
Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial;
material->setAmbient( Qt::red );
meshEntity->addComponent( material );
Qt3DCore::QTransform *meshTransform = new Qt3DCore::QTransform;
meshTransform->setScale( 1 );
meshEntity->addComponent( meshTransform );
meshEntity->setParent( this );
#endif
if ( map.hasSkyboxEnabled() )
{
Qt3DExtras::QSkyboxEntity *skybox = new Qt3DExtras::QSkyboxEntity;
skybox->setBaseName( map.skyboxFileBase() );
skybox->setExtension( map.skyboxFileExtension() );
skybox->setParent( this );
// docs say frustum culling must be disabled for skybox.
// it _somehow_ works even when frustum culling is enabled with some camera positions,
// but then when zoomed in more it would disappear - so let's keep frustum culling disabled
mEngine->setFrustumCullingEnabled( false );
}
// force initial update of chunked entities
onCameraChanged();
}
// **************************************************************
void MainScene::display()
{
setDefaults();
updateDrawing();
// update scene camera
CGFscene::activeCamera->applyView();
updateLights();
long double time_0 = GetTickCount();
sceneData->getSceneGraph()->Display();
long double time_1 = GetTickCount();
//cout << "Time between: " << time_1 - time_0 << endl;
axis.draw();
glNormal3f(0, 1, 0);
// We have been drawing in a memory area that is not visible - the back buffer,
// while the graphics card is showing the contents of another buffer - the front buffer
// glutSwapBuffers() will swap pointers so that the back buffer becomes the front buffer and vice-versa
glutSwapBuffers();
}
virtual void render()
{
if (!prepared)
return;
draw();
if (!paused)
updateLights();
}
void LeftHandMenu::renderUI() {
auto scrollValue = mScrollArea->verticalScrollBar()->value();
if ((mIsIn || mAlwaysOpen) && (scrollValue == mLastScrollValue)) {
updateLights();
} else {
mLastScrollValue = scrollValue;
}
}
void DlgPass::updateLists(Pass *p)
{
updateCameraList(p);
updateViewportList(p);
updateRenderTargetList(p);
updateLights(p);
updateScenes(p);
updateMaterialList();
}
void LeftHandMenu::pushIn() {
updateLights();
this->raise();
cor::moveWidget(this,
this->size(),
this->pos(),
QPoint(0u, 0u));
mRenderThread->start(333);
mIsIn = true;
}
/**
Render the scene
*/
void ShadowableScene::render()
{
// update light positions and properties
updateLights();
// iterate through the normal list and display the geomerty
renderModelList(normalList);
// iterate through the receiver list and display the geometry
renderModelList(shadowReceiverList);
// iterate through the caster list and display the geometry
renderModelList(shadowCasterList);
// Draw the shadows
if (drawShadowsFlag) drawShadows();
}
void LeftHandMenu::groupSelected(const QString& key, bool shouldSelect) {
bool isValid = false;
std::list<cor::Light> lights;
// loop through all groups and subgroups, adding or removing lists only if a group is found
for (const auto& widget : mRoomWidgets) {
// check if group is the room itself
if (widget->key() == key) {
isValid = true;
lights = widget->reachableDevices();
}
// check if group is a subgroup of a room
for (const auto& groupID : widget->group().subgroups) {
const auto& group = mGroups->groups().item(QString::number(groupID).toStdString());
if (group.second) {
if (group.first.name() == key) {
isValid = true;
lights = mComm->lightListFromGroup(group.first);
}
}
}
}
// if the group selected is found, either select or deselect it
if (isValid) {
if (shouldSelect) {
mSelectedLights->addDeviceList(lights);
} else {
mSelectedLights->removeDeviceList(lights);
}
updateLights();
for (const auto& widget : mRoomWidgets) {
widget->setCheckedDevices(mSelectedLights->devices());
widget->updateTopWidget();
}
emit changedDeviceCount();
}
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers()
{
// Objact vertex shader uniform buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&uniformBuffers.object,
sizeof(uboMatrices)));
// Shared parameter uniform buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&uniformBuffers.params,
sizeof(uboParams)));
// Map persistent
VK_CHECK_RESULT(uniformBuffers.object.map());
VK_CHECK_RESULT(uniformBuffers.params.map());
updateUniformBuffers();
updateLights();
}
void ShowScene2(int mode, int view_mode, int quad, GLint s_left, GLint s_down){
if(rotation_type==EYE_CENTERED&&nskyboxinfo>0)draw_skybox();
if(UpdateLIGHTS==1)updateLights(light_position0,light_position1);
if(mode==DRAWSCENE){
glPointSize((float)1.0);
/* ++++++++++++++++++++++++ draw trees +++++++++++++++++++++++++ */
if(ntreeinfo>0){
CLIP_GEOMETRY;
drawtrees();
SNIFF_ERRORS("after drawtrees");
}
/* ++++++++++++++++++++++++ draw particles +++++++++++++++++++++++++ */
if(showsmoke==1){
CLIP_VALS;
drawpart_frame();
}
/* ++++++++++++++++++++++++ draw evacuation +++++++++++++++++++++++++ */
if(showevac==1){
CLIP_VALS;
drawevac_frame();
}
/* ++++++++++++++++++++++++ draw targets +++++++++++++++++++++++++ */
if(showtarget==1){
CLIP_VALS;
drawTargets();
}
#ifdef pp_GEOMTEST
if(show_geomtest==1){
CLIP_GEOMETRY;
draw_geomtestclip();
draw_geomtestoutline();
}
if(show_cutcells==1)draw_geom_cutcells();
#endif
/* ++++++++++++++++++++++++ draw circular vents +++++++++++++++++++++++++ */
if(ncvents>0&&visCircularVents!=VENT_HIDE){
CLIP_GEOMETRY;
DrawCircVents(visCircularVents);
}
/* ++++++++++++++++++++++++ draw sensors/sprinklers/heat detectors +++++++++++++++++++++++++ */
CLIP_GEOMETRY;
draw_devices();
#ifdef pp_PILOT
draw_pilot();
#endif
SNIFF_ERRORS("after draw_devices");
if(visaxislabels==1){
UNCLIP;
outputAxisLabels();
SNIFF_ERRORS("after outputAxisLables");
}
/* ++++++++++++++++++++++++ draw user ticks +++++++++++++++++++++++++ */
if(visUSERticks==1){
antialias(ON);
UNCLIP;
draw_user_ticks();
antialias(OFF);
SNIFF_ERRORS("after drawticks");
}
/* ++++++++++++++++++++++++ draw ticks +++++++++++++++++++++++++ */
if(visFDSticks==1&&ntickinfo>0){
UNCLIP;
drawticks();
SNIFF_ERRORS("after drawticks");
}
/* ++++++++++++++++++++++++ draw ticks +++++++++++++++++++++++++ */
if(showgravity==1){
UNCLIP;
drawaxis();
SNIFF_ERRORS("after drawaxis");
}
/* draw the box framing the simulation (corners at (0,0,0) (xbar,ybar,zbar) */
/* ++++++++++++++++++++++++ draw simulation frame (corners at (0,0,0) and (xbar,ybar,zbar) +++++++++++++++++++++++++ */
if(isZoneFireModel==0&&visFrame==1&&highlight_flag==2){
CLIP_GEOMETRY;
drawoutlines();
SNIFF_ERRORS("after drawoutlines");
}
if(show_rotation_center==1){
unsigned char pcolor[4];
CLIP_GEOMETRY;
glPushMatrix();
glTranslatef(camera_current->xcen,camera_current->ycen,camera_current->zcen);
pcolor[0]=255*foregroundcolor[0];
pcolor[1]=255*foregroundcolor[1];
pcolor[2]=255*foregroundcolor[2];
drawsphere(0.03,pcolor);
glPopMatrix();
}
/* ++++++++++++++++++++++++ draw mesh +++++++++++++++++++++++++ */
if(setPDIM==1){
if(visGrid!=noGridnoProbe){
int igrid;
mesh *meshi;
UNCLIP;
for(igrid=0;igrid<nmeshes;igrid++){
meshi=meshinfo+igrid;
drawgrid(meshi);
SNIFF_ERRORS("drawgrid");
}
}
}
} /* end of if(mode==DRAWSCENE) code segment */
/* ++++++++++++++++++++++++ draw selected devices +++++++++++++++++++++++++ */
if(mode==SELECTOBJECT){
if(select_device==1){
CLIP_GEOMETRY;
draw_devices();
SNIFF_ERRORS("after drawselect_devices");
return;
}
}
/* ++++++++++++++++++++++++ draw selected avatars +++++++++++++++++++++++++ */
if(mode==SELECTOBJECT){
if(select_avatar==1){
CLIP_GEOMETRY;
drawselect_avatars();
SNIFF_ERRORS("after drawselect_avatars");
return;
}
}
/* ++++++++++++++++++++++++ draw selected tours +++++++++++++++++++++++++ */
if(mode==SELECTOBJECT){
if(edittour==1&&ntours>0){
CLIP_GEOMETRY;
drawselect_tours();
SNIFF_ERRORS("after drawselect_tours");
return;
}
}
/* ++++++++++++++++++++++++ draw tours +++++++++++++++++++++++++ */
if(showtours==1){
CLIP_GEOMETRY;
drawtours();
SNIFF_ERRORS("after drawtours");
}
/* ++++++++++++++++++++++++ draw stereo parallax indicator +++++++++++++++++++++++++ */
if(show_parallax==1){
UNCLIP;
antialias(ON);
glLineWidth(linewidth);
glBegin(GL_LINES);
glColor3fv(foregroundcolor);
glVertex3f(0.75,0.0,0.25);
glVertex3f(0.75,1.0,0.25);
glEnd();
antialias(OFF);
}
/* ++++++++++++++++++++++++ draw blockages +++++++++++++++++++++++++ */
CLIP_GEOMETRY;
drawBlockages(mode,DRAW_OPAQUE);
SNIFF_ERRORS("drawBlockages");
/* ++++++++++++++++++++++++ draw triangles +++++++++++++++++++++++++ */
if(ngeominfoptrs>0){
CLIP_GEOMETRY;
draw_geom(DRAW_OPAQUE,GEOM_STATIC);
draw_geom(DRAW_OPAQUE,GEOM_DYNAMIC);
}
/* ++++++++++++++++++++++++ draw shooter points +++++++++++++++++++++++++ */
if(showshooter!=0&&shooter_active==1){
CLIP_VALS;
draw_shooter();
}
/* ++++++++++++++++++++++++ draw terrain +++++++++++++++++++++++++ */
if(visTerrainType!=TERRAIN_HIDDEN&&nterraininfo>0){
int i;
//shaded 17 0
//stepped 18 1
//line 19 2
//texture 20 3
//hidden 20 4
CLIP_GEOMETRY;
for(i=0;i<nterraininfo;i++){
terraindata *terri;
int only_geom;
terri = terraininfo + i;
if(terri->loaded==1){
only_geom=0;
}
else{
only_geom=1;
}
switch(visTerrainType){
case TERRAIN_3D:
drawterrain(terri,only_geom);
break;
case TERRAIN_2D_STEPPED:
if(cullfaces==1)glDisable(GL_CULL_FACE);
glPushMatrix();
glScalef(SCALE2SMV(1.0),SCALE2SMV(1.0),SCALE2SMV(1.0));
glTranslatef(-xbar0,-ybar0,-zbar0);
DrawContours(&meshinfo[i].terrain_contour);
glPopMatrix();
if(cullfaces==1)glEnable(GL_CULL_FACE);
break;
case TERRAIN_2D_LINE:
glPushMatrix();
glScalef(SCALE2SMV(1.0),SCALE2SMV(1.0),SCALE2SMV(1.0));
glTranslatef(-xbar0,-ybar0,-zbar0);
DrawLineContours(&meshinfo[i].terrain_contour,1.0);
glPopMatrix();
break;
case TERRAIN_3D_MAP:
if(terrain_texture!=NULL&&terrain_texture->loaded==1){
drawterrain_texture(terri,only_geom);
}
else{
drawterrain(terri,only_geom);
}
break;
default:
ASSERT(FFALSE);
break;
}
}
}
/* ++++++++++++++++++++++++ draw slice files +++++++++++++++++++++++++ */
if(show_gslice_triangles==1||show_gslice_normal==1||show_gslice_normal_keyboard==1||show_gslice_triangulation==1){
CLIP_VALS;
drawgslice_outline();
}
if((show_slices_and_vectors==1&&showvslice==1)||(showslice==1&&use_transparency_data==0)){
CLIP_VALS;
drawslice_frame();
}
/* ++++++++++++++++++++++++ draw boundary files +++++++++++++++++++++++++ */
if(showpatch==1){
CLIP_VALS;
drawpatch_frame();
}
/* ++++++++++++++++++++++++ draw labels +++++++++++++++++++++++++ */
if(visLabels==1){
CLIP_GEOMETRY;
drawLabels();
}
/* ++++++++++++++++++++++++ draw animated isosurfaces +++++++++++++++++++++++++ */
//if(isoinfo!=NULL)drawspherepoints(sphereinfo);
if(showiso==1){
CLIP_VALS;
drawiso(DRAW_OPAQUE);
}
/* ++++++++++++++++++++++++ draw zone fire modeling info +++++++++++++++++++++++++ */
if(nrooms>0){
CLIP_GEOMETRY;
drawroomgeom();
SNIFF_ERRORS("after drawroomgeom");
}
if(nrooms>0){
if(showzone==1){
CLIP_VALS;
drawfiredata();
SNIFF_ERRORS("after drawroomdata");
if(ReadZoneFile==1&&nzvents>0){
drawventdata();
SNIFF_ERRORS("after drawventdata");
}
}
}
//**********************************************************************************
//**********************************************************************************
//**********************************************************************************
// nothing transparent should be drawn before this portion of the code
// (ie draw all opaque objects first then draw transparent objects
//**********************************************************************************
//**********************************************************************************
//**********************************************************************************
/* ++++++++++++++++++++++++ draw triangles +++++++++++++++++++++++++ */
if(ngeominfoptrs>0){
CLIP_GEOMETRY;
draw_geom(DRAW_TRANSPARENT,GEOM_STATIC);
draw_geom(DRAW_TRANSPARENT,GEOM_DYNAMIC);
}
if(showiso==1){
CLIP_VALS;
drawiso(DRAW_TRANSPARENT);
}
/* ++++++++++++++++++++++++ draw transparent faces +++++++++++++++++++++++++ */
CLIP_GEOMETRY;
draw_transparent_faces();
/* ++++++++++++++++++++++++ draw 3D smoke +++++++++++++++++++++++++ */
if(show3dsmoke==1||showvolrender==1){
CLIP_VALS;
drawsmoke_frame();
}
if(active_smokesensors==1&&show_smokesensors!=0){
CLIP_VALS;
getsmokesensors();
draw_devices_val();
}
/* ++++++++++++++++++++++++ draw zone fire modeling info +++++++++++++++++++++++++ */
if(nrooms>0&&showzone==1){
CLIP_VALS;
drawroomdata();
SNIFF_ERRORS("after drawroomdata");
}
/* ++++++++++++++++++++++++ draw slice files +++++++++++++++++++++++++ */
if((show_slices_and_vectors==1&&showvslice==1)||(showslice==1&&use_transparency_data==1)){
CLIP_VALS;
drawslice_frame();
SNIFF_ERRORS("after drawslice_frame");
}
/* ++++++++++++++++++++++++ draw transparent blockages +++++++++++++++++++++++++ */
// draw_demo(20,20);
// draw_demo2(1);
CLIP_GEOMETRY;
drawBlockages(mode,DRAW_TRANSPARENT);
SNIFF_ERRORS("after drawBlokcages");
/* ++++++++++++++++++++++++ draw vector slice files +++++++++++++++++++++++++ */
if(showvslice==1){
CLIP_VALS;
drawvslice_frame();
}
SNIFF_ERRORS("after drawvslice");
/* ++++++++++++++++++++++++ draw plot3d files +++++++++++++++++++++++++ */
if(showplot3d==1){
CLIP_VALS;
drawplot3d_frame();
}
SNIFF_ERRORS("after drawplot3d");
}
void myInterface::processGUI(GLUI_Control *ctrl)
{
updateLights();
//updateCameras();
}
void EnemyAspect::update( float _dt)
{
int currentunitindex,
othersunitindex;
float distance,
alignment_count,
separation_count,
randx,
randy = 0,
randz;
float multiplier = 1.f / RAND_MAX;
glm::vec3 alignment, separation, t;
float dt = _dt / 1000.f;
// horde behaviour
for(uint j = 0; j < ec->pos.size(); j++)
{
// every horde is 20 or 10 units
for(uint i = 0; i < HORDESIZE; i++)
{
currentunitindex = j * HORDESIZE + i;
// Alignment
alignment = glm::vec3(0.f, 0.f, 0.f);
alignment_count = 0;
// Separation
separation = glm::vec3(0.f, 0.f, 0.f);
separation_count = 0;
for(uint l = 0; l < HORDESIZE; l++)
{
if(i == l)
continue;
othersunitindex = j*HORDESIZE + l;
distance = glm::distance(ec->hordeunits[currentunitindex].pos, ec->hordeunits[othersunitindex].pos);
// Alignment
if(distance < 60.f)
{
alignment += ec->hordeunitdir1[othersunitindex];
alignment_count++;
}
if(distance < 5.f)
{
separation += ec->hordeunits[othersunitindex].pos - ec->hordeunits[currentunitindex].pos;
separation_count++;
}
}
// Alignment
if(alignment_count)
ec->hordeunitdir1[currentunitindex] += glm::normalize(alignment / alignment_count) * 0.005f;
// Cohesion
t = ec->hordeunits[j*HORDESIZE].pos;
t = t - ec->hordeunits[currentunitindex].pos;
if(L(t) > 0.001f)
{
t = glm::normalize(t);
ec->hordeunitdir1[currentunitindex] += t * 0.005f;
}
// Separation
if(separation_count)
{
t = separation * -1.f / separation_count;
if(L(t) > 0.001f)
{
t = glm::normalize(t);
ec->hordeunitdir1[currentunitindex] += t * 0.05f;
}
}
randx = 3 - (float)std::rand() * multiplier * 6.f;
randz = 3 - (float)std::rand() * multiplier * 6.f;
ec->hordeunitdir1[currentunitindex].y = 0;
ec->hordeunitdir1[currentunitindex] = glm::normalize(ec->hordeunitdir1[currentunitindex] + glm::vec3(randx, randy, randz) * 0.01f) * 9.f * dt;
ec->hordeunits[currentunitindex].pos += ec->hordeunitdir1[currentunitindex];
ec->hordeunitwavevar1[currentunitindex] += dt;
if(ec->hordeunitwavevar1[currentunitindex] > (float)TWOPI)
ec->hordeunitwavevar1[currentunitindex] -= (float)TWOPI;
}
for(uint i = 0; i < HORDESIZE; i++)
{
ec->hordeunits[j*HORDESIZE + i].pos -= ec->hordeunits[HORDESIZE*j].pos;
}
}
followTerrain(_dt);
updateLights();
}
void Tp2Application::updateWorld()
{
updateLights();
}
void InitOpenGL(void){
int type;
int err;
PRINTF("%s",_("Initializing OpenGL\n"));
type = GLUT_RGB|GLUT_DEPTH;
if(buffertype==GLUT_DOUBLE){
type |= GLUT_DOUBLE;
}
else{
type |= GLUT_SINGLE;
}
// glutInitDisplayMode(GLUT_STEREO);
if(stereoactive==1){
if(glutGet(GLUT_DISPLAY_MODE_POSSIBLE)==1){
videoSTEREO=1;
type |= GLUT_STEREO;
}
else{
videoSTEREO=0;
fprintf(stderr,"*** Error: video hardware does not support stereo\n");
}
}
#ifdef _DEBUG
PRINTF("%s",_(" Initializing Glut display mode - "));
#endif
glutInitDisplayMode(type);
#ifdef _DEBUG
PRINTF("%s\n",_("initialized"));
#endif
CheckMemory;
#ifdef _DEBUG
PRINTF("%s\n",_(" creating window"));
#endif
mainwindow_id=glutCreateWindow("");
#ifdef _DEBUG
PRINTF("%s\n",_(" window created"));
#endif
#ifdef _DEBUG
PRINTF("%s",_(" Initializing callbacks - "));
#endif
glutSpecialUpFunc(specialkeyboard_up_CB);
glutKeyboardUpFunc(keyboard_up_CB);
glutKeyboardFunc(keyboard_CB);
glutMouseFunc(mouse_CB);
glutSpecialFunc(specialkeyboard_CB);
glutMotionFunc(motion_CB);
glutReshapeFunc(Reshape_CB);
glutDisplayFunc(Display_CB);
glutVisibilityFunc(NULL);
glutMenuStatusFunc(MenuStatus_CB);
#ifdef _DEBUG
PRINTF("%s\n",_("initialized"));
#endif
opengl_version = get_opengl_version(opengl_version_label);
err=0;
#ifdef pp_GPU
err=glewInit();
if(err==GLEW_OK){
err=0;
}
else{
PRINTF(" GLEW initialization failed\n");
err=1;
}
if(err==0){
if(disable_gpu==1){
err=1;
}
else{
err=init_shaders();
}
#ifdef _DEBUG
if(err==0){
PRINTF("%s\n",_(" GPU shader initialization succeeded"));
}
#endif
if(err!=0){
PRINTF("%s\n",_(" GPU shader initialization failed"));
}
}
#endif
#ifdef pp_CULL
if(err==0){
err=init_cull_exts();
#ifdef _DEBUG
if(err==0){
PRINTF("%s\n",_(" Culling extension initialization succeeded"));
}
#endif
if(err!=0){
PRINTF("%s\n",_(" Culling extension initialization failed"));
}
}
#endif
light_position0[0]=1.0f;
light_position0[1]=1.0f;
light_position0[2]=4.0f;
light_position0[3]=0.f;
light_position1[0]=-1.0f;
light_position1[1]=1.0f;
light_position1[2]=4.0f;
light_position1[3]=0.f;
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
updateLights(light_position0,light_position1);
{
glGetIntegerv(GL_RED_BITS,&nredbits);
glGetIntegerv(GL_GREEN_BITS,&ngreenbits);
glGetIntegerv(GL_BLUE_BITS,&nbluebits);
nredshift = 8 - nredbits;
if(nredshift<0)nredshift=0;
ngreenshift = 8 - ngreenbits;
if(ngreenshift<0)ngreenshift=0;
nblueshift=8-nbluebits;
if(nblueshift<0)nblueshift=0;
}
opengldefined=1;
PRINTF("%s",_("OpenGL initialization completed\n\n"));
}
int setup_case(int argc, char **argv){
int return_code;
char *input_file;
/*
warning: the following line was commented out!! (perhaps it broke something)
this line is necessary in order to define smv_filename and trainer_filename
*/
// parse_commandlines(argc, argv);
return_code=-1;
if(strcmp(input_filename_ext,".svd")==0||demo_option==1){
trainer_mode=1;
trainer_active=1;
if(strcmp(input_filename_ext,".svd")==0){
input_file=trainer_filename;
}
else if(strcmp(input_filename_ext,".smt")==0){
input_file=test_filename;
}
else{
input_file=smv_filename;
}
return_code=readsmv(input_file,iso_filename);
if(return_code==0){
show_glui_trainer();
show_glui_alert();
}
}
else{
input_file=smv_filename;
return_code=readsmv(input_file,iso_filename);
}
switch(return_code){
case 1:
fprintf(stderr,"*** Error: Smokeview file, %s, not found\n",input_file);
return 1;
case 2:
fprintf(stderr,"*** Error: problem reading Smokeview file, %s\n",input_file);
return 2;
case 0:
readsmv_dynamic(input_file);
break;
default:
ASSERT(FFALSE);
}
/* initialize units */
InitUnits();
init_unit_defs();
set_unit_vis();
CheckMemory;
readini(NULL);
readboundini();
if(use_graphics==0)return 0;
#ifdef pp_LANG
init_lang();
#endif
if(sb_atstart==1)smooth_blockages();
if(ntours==0)setup_tour();
glui_colorbar_setup(mainwindow_id);
glui_motion_setup(mainwindow_id);
glui_bounds_setup(mainwindow_id);
glui_shooter_setup(mainwindow_id);
glui_geometry_setup(mainwindow_id);
glui_clip_setup(mainwindow_id);
glui_wui_setup(mainwindow_id);
glui_labels_setup(mainwindow_id);
glui_device_setup(mainwindow_id);
glui_tour_setup(mainwindow_id);
glui_alert_setup(mainwindow_id);
glui_stereo_setup(mainwindow_id);
glui_3dsmoke_setup(mainwindow_id);
if(UpdateLIGHTS==1)updateLights(NULL,NULL);
glutReshapeWindow(screenWidth,screenHeight);
glutSetWindow(mainwindow_id);
glutShowWindow();
glutSetWindowTitle(fdsprefix);
Init();
glui_trainer_setup(mainwindow_id);
glutDetachMenu(GLUT_RIGHT_BUTTON);
InitMenus(LOAD);
glutAttachMenu(GLUT_RIGHT_BUTTON);
if(trainer_mode==1){
show_glui_trainer();
show_glui_alert();
}
return 0;
}
