Ignore:
Timestamp:
Apr 16, 2013 12:52:20 AM (9 years ago)
Author:
ldelgass
Message:

Nanovis refactoring to fix problems with scaling and multiple results.
Do rendering in world space to properly place and scale multiple data sets.
Also fix flows to reduce resets of animations. More work toward removing
Cg dependency. Fix panning to convert viewport coords to world coords.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r3612 r3630  
    2424
    2525#include <graphics/RenderContext.h>
     26#include <vrmath/BBox.h>
    2627#include <vrmath/Vector3f.h>
    2728
     
    6465Tcl_Interp *NanoVis::interp = NULL;
    6566
    66 unsigned int NanoVis::flags = 0;
     67bool NanoVis::redrawPending = false;
    6768bool NanoVis::debugFlag = false;
    6869
     
    7374Texture2D *NanoVis::legendTexture = NULL;
    7475Fonts *NanoVis::fonts;
    75 int NanoVis::updir = Y_POS;
    76 Camera *NanoVis::cam = NULL;
     76Camera *NanoVis::_camera = NULL;
    7777RenderContext *NanoVis::renderContext = NULL;
    7878
     
    8282NanoVis::HeightMapHashmap NanoVis::heightMapTable;
    8383
    84 double NanoVis::magMin = DBL_MAX;
    85 double NanoVis::magMax = -DBL_MAX;
    86 float NanoVis::xMin = FLT_MAX;
    87 float NanoVis::xMax = -FLT_MAX;
    88 float NanoVis::yMin = FLT_MAX;
    89 float NanoVis::yMax = -FLT_MAX;
    90 float NanoVis::zMin = FLT_MAX;
    91 float NanoVis::zMax = -FLT_MAX;
    92 float NanoVis::wMin = FLT_MAX;
    93 float NanoVis::wMax = -FLT_MAX;
    94 Vector3f NanoVis::sceneMin, NanoVis::sceneMax;
     84BBox NanoVis::sceneBounds;
    9585
    9686VolumeRenderer *NanoVis::volRenderer = NULL;
     
    10191Grid *NanoVis::grid = NULL;
    10292
    103 // Image based flow visualization slice location
    104 // FLOW
    105 float NanoVis::_licSlice = 0.5f;
    106 int NanoVis::_licAxis = 2; // z axis
    107 
    10893//frame buffer for final rendering
    10994GLuint NanoVis::_finalFbo = 0;
     
    11196GLuint NanoVis::_finalDepthRb = 0;
    11297
    113 // Default camera location.
    114 float def_eye_x = 0.0f;
    115 float def_eye_y = 0.0f;
    116 float def_eye_z = 2.5f;
    117 
    11898void
    11999NanoVis::removeAllData()
    120100{
    121101    TRACE("Enter");
     102
    122103    if (grid != NULL) {
    123104        TRACE("Deleting grid");
    124105        delete grid;
    125106    }
    126     if (cam != NULL) {
    127         TRACE("Deleting cam");
    128         delete cam;
     107    if (_camera != NULL) {
     108        TRACE("Deleting camera");
     109        delete _camera;
    129110    }
    130111    if (volRenderer != NULL) {
     
    167148
    168149void
    169 NanoVis::eventuallyRedraw(unsigned int flag)
    170 {
    171     if (flag) {
    172         flags |= flag;
    173     }
    174     if ((flags & REDRAW_PENDING) == 0) {
     150NanoVis::eventuallyRedraw()
     151{
     152    if (!redrawPending) {
    175153        glutPostRedisplay();
    176         flags |= REDRAW_PENDING;
    177     }
    178 }
    179 
    180 void
    181 NanoVis::pan(float dx, float dy)
    182 {
    183     /* Move the camera and its target by equal amounts along the x and y
    184      * axes. */
    185     TRACE("pan: x=%f, y=%f", dx, dy);
    186 
    187     cam->x(def_eye_x - dx);
    188     cam->y(def_eye_y + dy);
    189     TRACE("set eye to %f %f", cam->x(), cam->y());
    190 }
    191 
    192 void
    193 NanoVis::zoom(float z)
    194 {
    195     /* Move the camera and its target by equal amounts along the x and y
    196      * axes. */
    197     TRACE("zoom: z=%f", z);
    198 
    199     cam->z(def_eye_z / z);
     154        redrawPending = true;
     155    }
     156}
     157
     158void
     159NanoVis::panCamera(float dx, float dy)
     160{
     161    _camera->pan(dx, dy);
    200162
    201163    collectBounds();
    202     cam->resetClippingRange(sceneMin, sceneMax);
    203 
    204     TRACE("set cam z to %f", cam->z());
     164    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
     165}
     166
     167void
     168NanoVis::zoomCamera(float z)
     169{
     170    _camera->zoom(z);
     171
     172    collectBounds();
     173    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
     174}
     175
     176void
     177NanoVis::orientCamera(double *quat)
     178{
     179    _camera->orient(quat);
     180
     181    collectBounds();
     182    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
     183}
     184
     185void
     186NanoVis::setCameraPosition(Vector3f pos)
     187{
     188    _camera->setPosition(pos);
     189
     190    collectBounds();
     191    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
     192}
     193
     194void
     195NanoVis::setCameraUpdir(Camera::AxisDirection dir)
     196{
     197    _camera->setUpdir(dir);
     198
     199    collectBounds();
     200    _camera->resetClippingRange(sceneBounds.min, sceneBounds.max);
    205201}
    206202
     
    211207
    212208    collectBounds();
    213     cam->reset(sceneMin, sceneMax, resetOrientation);
    214 
    215     def_eye_x = cam->x();
    216     def_eye_y = cam->y();
    217     def_eye_z = cam->z();
     209    _camera->reset(sceneBounds.min, sceneBounds.max, resetOrientation);
    218210}
    219211
     
    244236    }
    245237
    246     Volume *volume = new Volume(0.f, 0.f, 0.f,
    247                                 width, height, depth,
     238    Volume *volume = new Volume(width, height, depth,
    248239                                numComponents,
    249240                                data, vmin, vmax, nonZeroMin);
     
    451442    TRACE("change camera");
    452443    //change the camera setting
    453     cam->setScreenSize(0, 0, winWidth, winHeight);
     444    _camera->setViewport(0, 0, winWidth, winHeight);
    454445    planeRenderer->setScreenSize(winWidth, winHeight);
    455446
    456447    TRACE("Leave (%d, %d)", w, h);
    457448    return true;
    458 }
    459 
    460 static
    461 void cgErrorCallback(void)
    462 {
    463     if (!Shader::printErrorInfo()) {
    464         TRACE("Cg error, exiting...");
    465         exit(1);
    466     }
    467449}
    468450
     
    536518    ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
    537519
    538     Shader::initCg();
    539     Shader::setErrorCallback(cgErrorCallback);
    540 
    541     fonts = new Fonts();
    542     fonts->addFont("verdana", "verdana.fnt");
    543     fonts->setFont("verdana");
    544 
    545     velocityArrowsSlice = new VelocityArrowsSlice;
    546     licRenderer = new LIC(NMESH, NPIX, NPIX, _licAxis, _licSlice);
    547 
    548     grid = new Grid();
    549     grid->setFont(fonts);
    550520    return true;
    551521}
     
    564534
    565535    //create the camera with default setting
    566     cam = new Camera(0, 0, winWidth, winHeight,
    567                      def_eye_x, def_eye_y, def_eye_z);
     536    _camera = new Camera(0, 0, winWidth, winHeight);
    568537
    569538    glEnable(GL_TEXTURE_2D);
     
    577546    GLfloat mat_shininess[] = {30.0};
    578547    GLfloat white_light[] = {1.0, 1.0, 1.0, 1.0};
    579     GLfloat green_light[] = {0.1, 0.5, 0.1, 1.0};
    580548
    581549    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
     
    583551    glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);
    584552    glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);
    585     glLightfv(GL_LIGHT1, GL_DIFFUSE, green_light);
     553    glLightfv(GL_LIGHT1, GL_DIFFUSE, white_light);
    586554    glLightfv(GL_LIGHT1, GL_SPECULAR, white_light);
    587555
     
    591559    }
    592560
     561    fonts = new Fonts();
     562    fonts->addFont("verdana", "verdana.fnt");
     563    fonts->setFont("verdana");
     564
     565    renderContext = new RenderContext();
     566
    593567    volRenderer = new VolumeRenderer();
    594568
    595     renderContext = new RenderContext();
    596 
    597569    planeRenderer = new PlaneRenderer(winWidth, winHeight);
    598570
     571    velocityArrowsSlice = new VelocityArrowsSlice();
     572
     573    licRenderer = new LIC();
     574
    599575    orientationIndicator = new OrientationIndicator();
     576
     577    grid = new Grid();
     578    grid->setFont(fonts);
    600579
    601580    //assert(glGetError()==0);
     
    635614NanoVis::setVolumeRanges()
    636615{
    637     double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    638 
    639616    TRACE("Enter");
    640     xMin = yMin = zMin = wMin = DBL_MAX;
    641     xMax = yMax = zMax = wMax = -DBL_MAX;
     617
     618    double valueMin = DBL_MAX, valueMax = -DBL_MAX;
    642619    VolumeHashmap::iterator itr;
    643620    for (itr = volumeTable.begin();
    644621         itr != volumeTable.end(); ++itr) {
    645622        Volume *volume = itr->second;
    646         if (xMin > volume->xAxis.min()) {
    647             xMin = volume->xAxis.min();
    648         }
    649         if (xMax < volume->xAxis.max()) {
    650             xMax = volume->xAxis.max();
    651         }
    652         if (yMin > volume->yAxis.min()) {
    653             yMin = volume->yAxis.min();
    654         }
    655         if (yMax < volume->yAxis.max()) {
    656             yMax = volume->yAxis.max();
    657         }
    658         if (zMin > volume->zAxis.min()) {
    659             zMin = volume->zAxis.min();
    660         }
    661         if (zMax < volume->zAxis.max()) {
    662             zMax = volume->zAxis.max();
    663         }
    664         if (wMin > volume->wAxis.min()) {
    665             wMin = volume->wAxis.min();
    666         }
    667         if (wMax < volume->wAxis.max()) {
    668             wMax = volume->wAxis.max();
    669         }
    670     }
    671     if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
    672         grid->xAxis.setScale(xMin, xMax);
    673     }
    674     if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
    675         grid->yAxis.setScale(yMin, yMax);
    676     }
    677     if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
    678         grid->zAxis.setScale(zMin, zMax);
    679     }
    680     if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
    681         Volume::valueMin = wMin;
    682         Volume::valueMax = wMax;
     623        if (valueMin > volume->wAxis.min()) {
     624            valueMin = volume->wAxis.min();
     625        }
     626        if (valueMax < volume->wAxis.max()) {
     627            valueMax = volume->wAxis.max();
     628        }
     629    }
     630    if ((valueMin < DBL_MAX) && (valueMax > -DBL_MAX)) {
     631        Volume::valueMin = valueMin;
     632        Volume::valueMax = valueMax;
    683633    }
    684634    Volume::updatePending = false;
     
    689639NanoVis::setHeightmapRanges()
    690640{
    691     double xMin, xMax, yMin, yMax, zMin, zMax, wMin, wMax;
    692 
    693641    TRACE("Enter");
    694     xMin = yMin = zMin = wMin = DBL_MAX;
    695     xMax = yMax = zMax = wMax = -DBL_MAX;
     642
     643    double valueMin = DBL_MAX, valueMax = -DBL_MAX;
    696644    HeightMapHashmap::iterator itr;
    697645    for (itr = heightMapTable.begin();
    698646         itr != heightMapTable.end(); ++itr) {
    699647        HeightMap *heightMap = itr->second;
    700         if (xMin > heightMap->xAxis.min()) {
    701             xMin = heightMap->xAxis.min();
    702         }
    703         if (xMax < heightMap->xAxis.max()) {
    704             xMax = heightMap->xAxis.max();
    705         }
    706         if (yMin > heightMap->yAxis.min()) {
    707             yMin = heightMap->yAxis.min();
    708         }
    709         if (yMax < heightMap->yAxis.max()) {
    710             yMax = heightMap->yAxis.max();
    711         }
    712         if (zMin > heightMap->zAxis.min()) {
    713             zMin = heightMap->zAxis.min();
    714         }
    715         if (zMax < heightMap->zAxis.max()) {
    716             zMax = heightMap->zAxis.max();
    717         }
    718         if (wMin > heightMap->wAxis.min()) {
    719             wMin = heightMap->wAxis.min();
    720         }
    721         if (wMax < heightMap->wAxis.max()) {
    722             wMax = heightMap->wAxis.max();
    723         }
    724     }
    725     if ((xMin < DBL_MAX) && (xMax > -DBL_MAX)) {
    726         grid->xAxis.setScale(xMin, xMax);
    727     }
    728     if ((yMin < DBL_MAX) && (yMax > -DBL_MAX)) {
    729         grid->yAxis.setScale(yMin, yMax);
    730     }
    731     if ((zMin < DBL_MAX) && (zMax > -DBL_MAX)) {
    732         grid->zAxis.setScale(zMin, zMax);
    733     }
    734     if ((wMin < DBL_MAX) && (wMax > -DBL_MAX)) {
    735         HeightMap::valueMin = grid->yAxis.min();
    736         HeightMap::valueMax = grid->yAxis.max();
     648        if (valueMin > heightMap->wAxis.min()) {
     649            valueMin = heightMap->wAxis.min();
     650        }
     651        if (valueMax < heightMap->wAxis.max()) {
     652            valueMax = heightMap->wAxis.max();
     653        }
     654    }
     655    if ((valueMin < DBL_MAX) && (valueMax > -DBL_MAX)) {
     656        HeightMap::valueMin = valueMin;
     657        HeightMap::valueMax = valueMax;
    737658    }
    738659    for (HeightMapHashmap::iterator itr = heightMapTable.begin();
     
    747668NanoVis::collectBounds(bool onlyVisible)
    748669{
    749     if (flags & MAP_FLOWS) {
     670    if (Flow::updatePending) {
    750671        mapFlows();
    751         grid->xAxis.setScale(xMin, xMax);
    752         grid->yAxis.setScale(yMin, yMax);
    753         grid->zAxis.setScale(zMin, zMax);
    754     }
    755 
    756     sceneMin.set(FLT_MAX, FLT_MAX, FLT_MAX);
    757     sceneMax.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
     672    }
     673
     674    sceneBounds.makeEmpty();
    758675
    759676    for (VolumeHashmap::iterator itr = volumeTable.begin();
     
    764681            continue;
    765682
    766         Vector3f bmin, bmax;
    767         volume->getWorldSpaceBounds(bmin, bmax);
    768         if (bmin.x > bmax.x)
    769             continue;
    770 
    771         if (sceneMin.x > bmin.x) {
    772             sceneMin.x = bmin.x;
    773         }
    774         if (sceneMax.x < bmax.x) {
    775             sceneMax.x = bmax.x;
    776         }
    777         if (sceneMin.y > bmin.y) {
    778             sceneMin.y = bmin.y;
    779         }
    780         if (sceneMax.y < bmax.y) {
    781             sceneMax.y = bmax.y;
    782         }
    783         if (sceneMin.z > bmin.z) {
    784             sceneMin.z = bmin.z;
    785         }
    786         if (sceneMax.z < bmax.z) {
    787             sceneMax.z = bmax.z;
    788         }
     683        BBox bbox;
     684        volume->getBounds(bbox.min, bbox.max);
     685        sceneBounds.extend(bbox);
    789686    }
    790687
     
    796693            continue;
    797694
    798         Vector3f bmin, bmax;
    799         heightMap->getWorldSpaceBounds(bmin, bmax);
    800         if (bmin.x > bmax.x)
    801             continue;
    802 
    803         if (sceneMin.x > bmin.x) {
    804             sceneMin.x = bmin.x;
    805         }
    806         if (sceneMax.x < bmax.x) {
    807             sceneMax.x = bmax.x;
    808         }
    809         if (sceneMin.y > bmin.y) {
    810             sceneMin.y = bmin.y;
    811         }
    812         if (sceneMax.y < bmax.y) {
    813             sceneMax.y = bmax.y;
    814         }
    815         if (sceneMin.z > bmin.z) {
    816             sceneMin.z = bmin.z;
    817         }
    818         if (sceneMax.z < bmax.z) {
    819             sceneMax.z = bmax.z;
    820         }
    821     }
    822 
    823     Vector3f flowMin, flowMax;
    824     getFlowBounds(flowMin, flowMax, onlyVisible);
    825     if (flowMin.x < flowMax.x) {
    826         if (sceneMin.x > flowMin.x) {
    827             sceneMin.x = flowMin.x;
    828         }
    829         if (sceneMax.x < flowMax.x) {
    830             sceneMax.x = flowMax.x;
    831         }
    832         if (sceneMin.y > flowMin.y) {
    833             sceneMin.y = flowMin.y;
    834         }
    835         if (sceneMax.y < flowMax.y) {
    836             sceneMax.y = flowMax.y;
    837         }
    838         if (sceneMin.z > flowMin.z) {
    839             sceneMin.z = flowMin.z;
    840         }
    841         if (sceneMax.z < flowMax.z) {
    842             sceneMax.z = flowMax.z;
    843         }
    844     }
    845 
    846     // TODO: Get Grid bounds
    847 
    848     if (sceneMin.x > sceneMax.x) {
    849         sceneMin.set(-0.5, -0.5, -0.5);
    850         sceneMax.set( 0.5,  0.5,  0.5);
     695        BBox bbox;
     696        heightMap->getBounds(bbox.min, bbox.max);
     697        sceneBounds.extend(bbox);
     698    }
     699
     700    {
     701        BBox bbox;
     702        getFlowBounds(bbox.min, bbox.max, onlyVisible);
     703        sceneBounds.extend(bbox);
     704    }
     705
     706    if (!sceneBounds.isEmptyX()) {
     707        grid->xAxis.setScale(sceneBounds.min.x, sceneBounds.max.x);
     708    }
     709    if (!sceneBounds.isEmptyY()) {
     710        grid->yAxis.setScale(sceneBounds.min.y, sceneBounds.max.y);
     711    }
     712    if (!sceneBounds.isEmptyZ()) {
     713        grid->zAxis.setScale(sceneBounds.min.z, sceneBounds.max.z);
     714    }
     715
     716    if (!onlyVisible || grid->isVisible()) {
     717        BBox bbox;
     718        grid->getBounds(bbox.min, bbox.max);
     719        sceneBounds.extend(bbox);
     720    }
     721
     722    if (sceneBounds.isEmpty()) {
     723        sceneBounds.min.set(-0.5, -0.5, -0.5);
     724        sceneBounds.max.set( 0.5,  0.5,  0.5);
    851725    }
    852726
    853727    TRACE("Scene bounds: (%g,%g,%g) - (%g,%g,%g)",
    854           sceneMin.x, sceneMin.y, sceneMin.z,
    855           sceneMax.x, sceneMax.y, sceneMax.z);
     728          sceneBounds.min.x, sceneBounds.min.y, sceneBounds.min.z,
     729          sceneBounds.max.x, sceneBounds.max.y, sceneBounds.max.z);
    856730}
    857731
     
    933807    TRACE("Enter");
    934808
    935     flags &= ~MAP_FLOWS;
    936 
    937809    /*
    938810     * Step 1. Get the overall min and max magnitudes of all the
    939811     *         flow vectors.
    940812     */
    941     magMin = DBL_MAX, magMax = -DBL_MAX;
     813    Flow::magMin = DBL_MAX;
     814    Flow::magMax = -DBL_MAX;
    942815
    943816    for (FlowHashmap::iterator itr = flowTable.begin();
     
    951824        min = data->magMin();
    952825        max = data->magMax();
    953         if (min < magMin) {
    954             magMin = min;
     826        if (min < Flow::magMin) {
     827            Flow::magMin = min;
    955828        }
    956         if (max > magMax) {
    957             magMax = max;
    958         }
    959         if (data->xMin() < xMin) {
    960             xMin = data->xMin();
    961         }
    962         if (data->yMin() < yMin) {
    963             yMin = data->yMin();
    964         }
    965         if (data->zMin() < zMin) {
    966             zMin = data->zMin();
    967         }
    968         if (data->xMax() > xMax) {
    969             xMax = data->xMax();
    970         }
    971         if (data->yMax() > yMax) {
    972             yMax = data->yMax();
    973         }
    974         if (data->zMax() > zMax) {
    975             zMax = data->zMax();
    976         }
    977     }
    978 
    979     TRACE("magMin=%g magMax=%g", NanoVis::magMin, NanoVis::magMax);
     829        if (max > Flow::magMax) {
     830            Flow::magMax = max;
     831        }
     832    }
     833
     834    TRACE("magMin=%g magMax=%g", Flow::magMin, Flow::magMax);
    980835
    981836    /*
     
    994849            return false;
    995850        }
    996         // FIXME: This doesn't work when there is more than one flow.
    997         licRenderer->setOffset(flow->getRelativePosition());
    998         velocityArrowsSlice->slicePos(flow->getRelativePosition());
    999     }
    1000     advectFlows();
     851    }
     852
     853    Flow::updatePending = false;
    1001854    return true;
    1002855}
     
    1009862    TRACE("Enter");
    1010863
    1011     min.set(FLT_MAX, FLT_MAX, FLT_MAX);
    1012     max.set(-FLT_MAX, -FLT_MAX, -FLT_MAX);
    1013 
     864    BBox allBounds;
    1014865    for (FlowHashmap::iterator itr = flowTable.begin();
    1015866         itr != flowTable.end(); ++itr) {
    1016         itr->second->getBounds(min, max, onlyVisible);
    1017     }
     867        BBox bbox;
     868        itr->second->getBounds(bbox.min, bbox.max, onlyVisible);
     869        allBounds.extend(bbox);
     870    }
     871
     872    min = allBounds.min;
     873    max = allBounds.max;
    1018874}
    1019875
     
    1028884        }
    1029885    }
    1030     flags &= ~REDRAW_PENDING;
    1031886}
    1032887
     
    1034889NanoVis::resetFlows()
    1035890{
    1036     if (licRenderer->active()) {
    1037         NanoVis::licRenderer->reset();
    1038     }
     891    NanoVis::licRenderer->reset();
    1039892    for (FlowHashmap::iterator itr = flowTable.begin();
    1040893         itr != flowTable.end(); ++itr) {
    1041894        Flow *flow = itr->second;
    1042         if (flow->isDataLoaded() && flow->visible()) {
     895        if (flow->isDataLoaded()) {
    1043896            flow->resetParticles();
    1044897        }
     
    1049902NanoVis::advectFlows()
    1050903{
     904    TRACE("Enter");
    1051905    for (FlowHashmap::iterator itr = flowTable.begin();
    1052906         itr != flowTable.end(); ++itr) {
    1053907        Flow *flow = itr->second;
    1054         if (flow->isDataLoaded() && flow->visible()) {
     908        if (flow->isDataLoaded()) {
    1055909            flow->advect();
    1056910        }
     
    1063917    TRACE("Enter");
    1064918
    1065     if (flags & MAP_FLOWS) {
    1066 #ifdef notdef
    1067         xMin = yMin = zMin = wMin = FLT_MAX, magMin = DBL_MAX;
    1068         xMax = yMax = zMax = wMax = -FLT_MAX, magMax = -DBL_MAX;
    1069 #endif
     919    if (Flow::updatePending) {
    1070920        mapFlows();
    1071         grid->xAxis.setScale(xMin, xMax);
    1072         grid->yAxis.setScale(yMin, yMax);
    1073         grid->zAxis.setScale(zMin, zMax);
    1074     }
    1075     //assert(glGetError()==0);
     921    }
    1076922    if (HeightMap::updatePending) {
    1077923        setHeightmapRanges();
     
    1081927    }
    1082928
    1083     //start final rendering
     929    collectBounds();
     930
     931    // Start final rendering
    1084932
    1085933    // Need to reset fbo since it may have been changed to default (0)
     
    1092940    glEnable(GL_COLOR_MATERIAL);
    1093941
    1094     //camera setting activated
    1095     cam->initialize();
    1096 
    1097     //set up the orientation of items in the scene.
    1098     glPushMatrix();
    1099 
    1100     switch (updir) {
    1101     case X_POS:
    1102         glRotatef(90, 0, 0, 1);
    1103         glRotatef(90, 1, 0, 0);
    1104         break;
    1105     case Y_POS:
    1106         // this is the default
    1107         break;
    1108     case Z_POS:
    1109         glRotatef(-90, 1, 0, 0);
    1110         glRotatef(-90, 0, 0, 1);
    1111         break;
    1112     case X_NEG:
    1113         glRotatef(-90, 0, 0, 1);
    1114         break;
    1115     case Y_NEG:
    1116         glRotatef(180, 0, 0, 1);
    1117         glRotatef(-90, 0, 1, 0);
    1118         break;
    1119     case Z_NEG:
    1120         glRotatef(90, 1, 0, 0);
    1121         break;
    1122     }
    1123 
    1124     //now render things in the scene
    1125 
     942    // Emit modelview and projection matrices
     943    _camera->initialize();
     944
     945    // Now render things in the scene
     946
     947    orientationIndicator->setPosition(sceneBounds.getCenter());
     948    orientationIndicator->setScale(sceneBounds.getSize());
    1126949    orientationIndicator->render();
     950
    1127951    grid->render();
    1128     if ((licRenderer != NULL) && (licRenderer->active())) {
    1129         licRenderer->render();
    1130     }
    1131     if ((velocityArrowsSlice != NULL) && (velocityArrowsSlice->enabled())) {
    1132         velocityArrowsSlice->render();
    1133     }
     952
     953    licRenderer->render();
     954
     955    velocityArrowsSlice->render();
     956
    1134957    renderFlows();
     958
    1135959    volRenderer->renderAll();
    1136960
    1137     HeightMapHashmap::iterator itr;
    1138     for (itr = heightMapTable.begin();
     961    for (HeightMapHashmap::iterator itr = heightMapTable.begin();
    1139962         itr != heightMapTable.end(); ++itr) {
    1140         HeightMap *heightMap = itr->second;
    1141         if (heightMap->isVisible()) {
    1142             heightMap->render(renderContext);
    1143         }
    1144     }
    1145     glPopMatrix();
     963        itr->second->render(renderContext);
     964     }
    1146965
    1147966    CHECK_FRAMEBUFFER_STATUS();
    1148967    TRACE("Leave");
    1149 }
     968    redrawPending = false;
     969}
Note: See TracChangeset for help on using the changeset viewer.