Changeset 2964


Ignore:
Timestamp:
Apr 11, 2012, 1:26:09 PM (8 years ago)
Author:
ldelgass
Message:

Convert arrow glyph shaders to new NvShader? API. Fix velocity arrow glpyh and
line implementation, add arrow head to line arrows. Alpha channel of arrow
texture atlas still needs cleanup -- should probably just create a utility to
generate the texture to allow changes in lighting, FOV, etc. Note that volumes
and flows are currently not scaled properly -- the aspect ratios of the number
of samples is used rather than the physical lengths of the volumes/flows. This will be fixed for volumes, flows and the grid in a future commit. Also, client doesn't currently enable arrows, this will also be enabled in another commit.

Location:
trunk/packages/vizservers/nanovis
Files:
1 deleted
9 edited

Legend:

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

    r2953 r2964  
    146146
    147147void
    148 FlowParticles::Render()
     148FlowParticles::render()
    149149{
    150150    TRACE("rendering particles %s\n", _name);
     
    161161
    162162void
    163 FlowParticles::Configure()
     163FlowParticles::configure()
    164164{
    165165    _rendererPtr->setPos(FlowCmd::GetRelativePosition(&_sv.position));
     
    343343{
    344344    FlowParticlesIterator iter;
    345     FlowParticles *particlesPtr;
    346     for (particlesPtr = FirstParticles(&iter); particlesPtr != NULL;
     345    for (FlowParticles *particlesPtr = FirstParticles(&iter);
     346        particlesPtr != NULL;
    347347         particlesPtr = NextParticles(&iter)) {
    348         particlesPtr->Reset();
     348        particlesPtr->reset();
    349349    }
    350350}
     
    353353FlowCmd::Advect()
    354354{
    355     NvVectorField *fieldPtr;
    356     fieldPtr = VectorField();
     355    NvVectorField *fieldPtr = VectorField();
    357356    fieldPtr->active(true);
    358357    FlowParticlesIterator iter;
    359     FlowParticles *particlesPtr;
    360     for (particlesPtr = FirstParticles(&iter); particlesPtr != NULL;
     358    for (FlowParticles *particlesPtr = FirstParticles(&iter);
     359        particlesPtr != NULL;
    361360         particlesPtr = NextParticles(&iter)) {
    362361        if (particlesPtr->visible()) {
    363             particlesPtr->Advect();
     362            particlesPtr->advect();
    364363        }
    365364    }
     
    372371    _fieldPtr->render();
    373372    FlowParticlesIterator iter;
    374     FlowParticles *particlesPtr;
    375     for (particlesPtr = FirstParticles(&iter); particlesPtr != NULL;
     373    for (FlowParticles *particlesPtr = FirstParticles(&iter);
     374        particlesPtr != NULL;
    376375         particlesPtr = NextParticles(&iter)) {
    377376        if (particlesPtr->visible()) {
    378             particlesPtr->Render();
     377            particlesPtr->render();
    379378        }
    380379    }
     
    517516FlowCmd::InitializeParticles()
    518517{
    519     FlowParticles *particlesPtr;
    520518    FlowParticlesIterator iter;
    521     for (particlesPtr = FirstParticles(&iter); particlesPtr != NULL;
     519    for (FlowParticles *particlesPtr = FirstParticles(&iter);
     520         particlesPtr != NULL;
    522521         particlesPtr = NextParticles(&iter)) {
    523         particlesPtr->Initialize();
     522        particlesPtr->initialize();
    524523    }
    525524}
     
    582581    if (NanoVis::velocityArrowsSlice != NULL) {
    583582        NanoVis::velocityArrowsSlice->
    584             vectorField(_volPtr->id,
    585                         //*(volPtr->get_location()),
    586                         1.0f,
    587                         _volPtr->aspectRatioHeight / _volPtr->aspectRatioWidth,
    588                         _volPtr->aspectRatioDepth / _volPtr->aspectRatioWidth
    589                         //,volPtr->wAxis.max()
    590                         );
    591         TRACE("Arrows enabled set to %d\n", _sv.showArrows);
     583            setVectorField(_volPtr->id, loc,
     584                           _volPtr->aspectRatioWidth,
     585                           _volPtr->aspectRatioHeight,
     586                           _volPtr->aspectRatioDepth,
     587                           _volPtr->wAxis.max());
    592588        NanoVis::velocityArrowsSlice->axis(_sv.slicePos.axis);
    593589        NanoVis::velocityArrowsSlice->slicePos(_sv.slicePos.value);
    594590        NanoVis::velocityArrowsSlice->enabled(_sv.showArrows);
    595591    }
    596     FlowParticles *particlesPtr;
     592
    597593    FlowParticlesIterator partIter;
    598     for (particlesPtr = FirstParticles(&partIter); particlesPtr != NULL;
     594    for (FlowParticles *particlesPtr = FirstParticles(&partIter);
     595         particlesPtr != NULL;
    599596         particlesPtr = NextParticles(&partIter)) {
    600         particlesPtr->SetVectorField(_volPtr);
     597        particlesPtr->setVectorField(_volPtr, loc,
     598                                     _volPtr->aspectRatioWidth,
     599                                     _volPtr->aspectRatioHeight,
     600                                     _volPtr->aspectRatioDepth,
     601                                     _volPtr->wAxis.max());
    601602    }
    602603    return true;
     
    13571358        return TCL_ERROR;
    13581359    }
    1359     if (particlesPtr->ParseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
     1360    if (particlesPtr->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
    13601361        delete particlesPtr;
    13611362        return TCL_ERROR;
    13621363    }
    1363     particlesPtr->Configure();
     1364    particlesPtr->configure();
    13641365    NanoVis::eventuallyRedraw();
    13651366    Tcl_SetObjResult(interp, objv[3]);
     
    13771378        return TCL_ERROR;
    13781379    }
    1379     if (particlesPtr->ParseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
    1380         return TCL_ERROR;
    1381     }
    1382     particlesPtr->Configure();
     1380    if (particlesPtr->parseSwitches(interp, objc - 4, objv + 4) != TCL_OK) {
     1381        return TCL_ERROR;
     1382    }
     1383    particlesPtr->configure();
    13831384    NanoVis::eventuallyRedraw(NanoVis::MAP_FLOWS);
    13841385    return TCL_OK;
  • trunk/packages/vizservers/nanovis/FlowCmd.h

    r2920 r2964  
    8383    }
    8484
    85     int ParseSwitches(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     85    int parseSwitches(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
    8686    {
    8787        if (Rappture::ParseSwitches(interp, _switches, objc, objv, &_sv,
     
    9292    }
    9393
    94     void Advect()
     94    void advect()
    9595    {
    9696        assert(_rendererPtr->active());
     
    9898    }
    9999
    100     void Render();
    101 
    102     void Reset()
     100    void render();
     101
     102    void reset()
    103103    {
    104104        _rendererPtr->reset();
    105105    }
    106106
    107     void Initialize()
     107    void initialize()
    108108    {
    109109        _rendererPtr->initialize();
    110110    }
    111111
    112     void SetVectorField(Volume *volPtr)
     112    void setVectorField(Volume *volPtr, const Vector3& location,
     113                        float scaleX, float scaleY, float scaleZ,
     114                        float max)
    113115    {
    114116        _rendererPtr->
    115             setVectorField(volPtr->id, 
    116                            volPtr->location(),
    117                            1.0f,
    118                            volPtr->height / (float)volPtr->width,
    119                            volPtr->depth  / (float)volPtr->width,
    120                            volPtr->wAxis.max());
    121     }
    122 
    123     void Configure();
     117            setVectorField(volPtr->id,
     118                           location,
     119                           scaleX,
     120                           scaleY,
     121                           scaleZ,
     122                           max);
     123    }
     124
     125    void configure();
    124126
    125127private:
  • trunk/packages/vizservers/nanovis/Makefile.in

    r2951 r2964  
    157157                $(srcdir)/resources/Font.bmp \
    158158                $(srcdir)/resources/arrows.bmp \
    159                 $(srcdir)/resources/arrows_red_bg.bmp \
    160159                $(srcdir)/resources/particle2.bmp \
    161160                $(srcdir)/resources/verdana.fnt \
  • trunk/packages/vizservers/nanovis/ParticleSystem.cpp

    r2884 r2964  
    284284    }
    285285
    286 #ifdef USE_RGBA_ARROW
    287     std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
    288 #else
    289286    std::string path = vrFilePath::getInstance()->getPath("arrows.bmp");
    290 #endif
     287
    291288    if (!path.empty()) {
    292289        ImageLoader *loader = ImageLoaderFactory::getInstance()->createLoader("bmp");
     
    301298                if (bytes != NULL) {
    302299#ifdef USE_RGBA_ARROW
    303                     for (unsigned int y = 0; y < image->getHeight(); ++y) {
    304                         for (unsigned int x = 0; x < image->getWidth(); ++x, bytes += 4) {
    305                             bytes[3] = (bytes[0] > 127 &&
    306                                         bytes[1] < 127 &&
    307                                         bytes[2] < 127) ? 0 : 255;
    308                         }
    309                     }
    310300                    _arrows = new Texture2D(image->getWidth(), image->getHeight(),
    311301                                            GL_UNSIGNED_BYTE, GL_LINEAR, 4, NULL);
  • trunk/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

    r2884 r2964  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
    22#include "nvconf.h"
     3
     4#include <math.h>
    35
    46#include <GL/glew.h>
     
    1416#include "NvShader.h"
    1517
    16 VelocityArrowsSlice::VelocityArrowsSlice()
    17 {
    18     _enabled = false;
    19     _context = NvShader::getCgContext();
    20     _vectorFieldGraphicsID = 0;
    21     _vfXscale = _vfYscale = _vfZscale = 0;
    22     _slicePos = 0.5f;
    23     _vertexBufferGraphicsID = 0;
     18static inline float deg2rad(float deg)
     19{
     20    return ((deg * M_PI) / 180.);
     21}
     22
     23static inline float rad2deg(float rad)
     24{
     25    return ((rad * 180.) / M_PI);
     26}
     27
     28VelocityArrowsSlice::VelocityArrowsSlice() :
     29    _vectorFieldGraphicsID(0),
     30    _vfXscale(0),
     31    _vfYscale(0),
     32    _vfZscale(0),
     33    _slicePos(0.5f),
     34    _axis(2),
     35    _fbo(0),
     36    _tex(0),
     37    _maxPointSize(1.0f),
     38    _renderTargetWidth(128),
     39    _renderTargetHeight(128),
     40    _velocities(NULL),
     41    _projectionVector(1, 1, 0),
     42    _tickCountForMinSizeAxis(10),
     43    _tickCountX(0),
     44    _tickCountY(0),
     45    _tickCountZ(0),
     46    _pointCount(0),
     47    _maxVelocityScale(1, 1, 1),
     48    _arrowColor(1, 1, 0),
     49    _enabled(false),
     50    _dirty(true),
     51    _vertexBufferGraphicsID(0),
     52    _arrowsTex(NULL),
     53    _renderMode(LINES)
     54{
    2455    axis(2);
    25     //_renderMode = GLYPHS;
    26     _renderMode = LINES;
    27 
    28     _tickCountForMinSizeAxis = 10;
    29 
    30     _queryVelocityFP =
    31         LoadCgSourceProgram(_context, "queryvelocity.cg", CG_PROFILE_FP40, "main");
    32 
    33     _qvVectorFieldParam = cgGetNamedParameter(_queryVelocityFP, "vfield");
    34 
    35     _dirty = true;
    36     _dirtySamplingPosition = true;
    37     _dirtyRenderTarget = true;
    38     _maxVelocityScale.x = _maxVelocityScale.y = _maxVelocityScale.z = 1.0f;
    39 
    40     _renderTargetWidth = 128;
    41     _renderTargetHeight = 128;
    42     _velocities = new Vector3[_renderTargetWidth * _renderTargetHeight];
    43 
    44     ::glGenBuffers(1, &_vertexBufferGraphicsID);
    45     glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
    46     glBufferDataARB(GL_ARRAY_BUFFER, _renderTargetWidth * _renderTargetHeight * 3 * sizeof(float),
    47                     0, GL_DYNAMIC_DRAW_ARB);
    48     glBindBufferARB(GL_ARRAY_BUFFER, 0);
     56
     57    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg", "main");
     58
     59    _particleShader.loadVertexProgram("velocityslicevp.cg", "vpmain");
     60    _particleShader.loadFragmentProgram("velocityslicefp.cg", "fpmain");
     61
    4962    createRenderTarget();
    50     _pointCount = 0;
    51 
    52     _particleVP =
    53         LoadCgSourceProgram(_context, "velocityslicevp.cg", CG_PROFILE_VP40, "vpmain");
    54 
    55     _mvpParticleParam = cgGetNamedParameter(_particleVP, "mvp");
    56     _mvParticleParam = cgGetNamedParameter(_particleVP, "modelview");
    57     _mvTanHalfFOVParam = cgGetNamedParameter(_particleVP, "tanHalfFOV");
    58 
    59     // TBD..
    60     _particleFP =
    61         LoadCgSourceProgram(_context, "velocityslicefp.cg", CG_PROFILE_FP40, "fpmain");
    62 
    63     _vectorParticleParam = cgGetNamedParameter(_particleVP, "vfield");
    6463
    6564    const char *path = R2FilePath::getInstance()->getPath("arrows.bmp");
     
    7271                unsigned char *bytes = (unsigned char *)image->getImageBuffer();
    7372                if (bytes != NULL) {
    74                     for (unsigned int y = 0; y < image->getHeight(); ++y) {
    75                         for (unsigned int x = 0; x < image->getWidth(); ++x, bytes += 4) {
    76                             bytes[3] = (bytes[0] == 0 &&
    77                                         bytes[1] == 0 &&
    78                                         bytes[2] == 0) ? 0 : 255;
    79                         }
    80                     }
    81 
    8273                    _arrowsTex = new Texture2D(image->getWidth(), image->getHeight(),
    8374                                               GL_UNSIGNED_BYTE, GL_LINEAR, 4, NULL);
     
    9990    }
    10091
    101     _arrowColor.set(1, 1, 0);
    102 
    10392    GLfloat minMax[2];
    10493    glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, minMax);
     
    115104VelocityArrowsSlice::~VelocityArrowsSlice()
    116105{
    117     cgDestroyProgram(_queryVelocityFP);
    118     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
    119     glDeleteTextures(1, &_tex);
    120     glDeleteFramebuffersEXT(1, &_fbo);
    121 
    122     delete _arrowsTex;
    123 
    124     cgDestroyProgram(_particleFP);
    125     cgDestroyProgram(_particleVP);
    126 
    127     glDeleteBuffers(1, &_vertexBufferGraphicsID);
    128     delete [] _velocities;
     106    if (_tex != 0) {
     107        glDeleteTextures(1, &_tex);
     108    }
     109    if (_fbo != 0) {
     110        glDeleteFramebuffersEXT(1, &_fbo);
     111    }
     112    if (_arrowsTex != NULL) {
     113        delete _arrowsTex;
     114    }
     115    if (_vertexBufferGraphicsID != 0) {
     116        glDeleteBuffers(1, &_vertexBufferGraphicsID);
     117    }
     118    if (_velocities != NULL) {
     119        delete [] _velocities;
     120    }
    129121}
    130122
    131123void VelocityArrowsSlice::createRenderTarget()
    132124{
     125    if (_velocities != NULL) {
     126        delete [] _velocities;
     127    }
     128    _velocities = new Vector3[_renderTargetWidth * _renderTargetHeight];
     129
     130    if (_vertexBufferGraphicsID != 0) {
     131        glDeleteBuffers(1, &_vertexBufferGraphicsID);
     132    }
     133
     134    glGenBuffers(1, &_vertexBufferGraphicsID);
     135    glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
     136    glBufferDataARB(GL_ARRAY_BUFFER_ARB, _renderTargetWidth * _renderTargetHeight * 3 * sizeof(float),
     137                    0, GL_DYNAMIC_DRAW_ARB);
     138    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
     139
     140    if (_tex != 0) {
     141        glDeleteTextures(1, &_tex);
     142    }
     143    if (_fbo != 0) {
     144        glDeleteFramebuffersEXT(1, &_fbo);
     145    }
     146
    133147    glGenFramebuffersEXT(1, &_fbo);
    134148    glGenTextures(1, &_tex);
    135 
     149    int fboOrig;
     150    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
    136151    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
    137 
    138     glViewport(0, 0, _renderTargetWidth, _renderTargetHeight);
    139     glMatrixMode(GL_PROJECTION);
    140     glLoadIdentity();
    141     glOrtho(0, _renderTargetWidth, 0, _renderTargetHeight, -10.0f, 10.0f);
    142     glMatrixMode(GL_MODELVIEW);
    143     glLoadIdentity();
    144152
    145153    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, _tex);
     
    156164                              GL_TEXTURE_RECTANGLE_ARB, _tex, 0);
    157165
    158     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     166    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
    159167}
    160168
     
    179187        break;
    180188    }
    181     _dirtySamplingPosition = true;
    182     _dirtyRenderTarget = true;
    183     //_dirty = true;
     189    _dirty = true;
    184190}
    185191
     
    188194    if (!_enabled) return;
    189195
     196    glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
     197    int fboOrig;
     198    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
     199
    190200    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
     201
     202    _queryVelocityFP.bind();
     203    _queryVelocityFP.setFPTextureParameter("vfield", _vectorFieldGraphicsID);
     204
    191205    glDisable(GL_DEPTH_TEST);
    192     cgGLBindProgram(_queryVelocityFP);
    193     cgGLEnableProfile(CG_PROFILE_FP40);
    194     cgGLSetTextureParameter(_qvVectorFieldParam, _vectorFieldGraphicsID);
    195     cgGLEnableTextureParameter(_qvVectorFieldParam);
    196 
    197     glPushAttrib(GL_VIEWPORT_BIT);
    198206    glViewport(0, 0, _renderTargetWidth, _renderTargetHeight);
    199207    glMatrixMode(GL_PROJECTION);
     
    205213    glLoadIdentity();
    206214
    207     glBegin(GL_POINTS);
    208 
    209     for (unsigned int index = 0; index < _samplingPositions.size(); ++index) {
    210         glMultiTexCoord3f(0,
    211                           _samplingPositions[index].x,
    212                           _samplingPositions[index].y,
    213                           _samplingPositions[index].z);
    214         glVertex2f(index % _renderTargetWidth,
    215                    index / _renderTargetHeight);
    216     }
    217 
     215    glBegin(GL_QUADS);
     216    switch (_axis) {
     217    case 0:
     218        glTexCoord3f(_slicePos, 0, 0); glVertex2i(0,                  0);
     219        glTexCoord3f(_slicePos, 1, 0); glVertex2i(_renderTargetWidth, 0);
     220        glTexCoord3f(_slicePos, 1, 1); glVertex2i(_renderTargetWidth, _renderTargetHeight);
     221        glTexCoord3f(_slicePos, 0, 1); glVertex2i(0,                  _renderTargetHeight);
     222        break;
     223    case 1:
     224        glTexCoord3f(0, _slicePos, 0); glVertex2i(0,                  0);
     225        glTexCoord3f(1, _slicePos, 0); glVertex2i(_renderTargetWidth, 0);
     226        glTexCoord3f(1, _slicePos, 1); glVertex2i(_renderTargetWidth, _renderTargetHeight);
     227        glTexCoord3f(0, _slicePos, 1); glVertex2i(0,                  _renderTargetHeight);
     228        break;
     229    case 2:
     230    default:
     231        glTexCoord3f(0, 0, _slicePos); glVertex2i(0,                  0);
     232        glTexCoord3f(1, 0, _slicePos); glVertex2i(_renderTargetWidth, 0);
     233        glTexCoord3f(1, 1, _slicePos); glVertex2i(_renderTargetWidth, _renderTargetHeight);
     234        glTexCoord3f(0, 1, _slicePos); glVertex2i(0,                  _renderTargetHeight);
     235        break;
     236    }
    218237    glEnd();
    219238
    220     glDisable(GL_TEXTURE_RECTANGLE_ARB);
    221     cgGLDisableTextureParameter(_qvVectorFieldParam);
    222     cgGLDisableProfile(CG_PROFILE_FP40);
     239    _queryVelocityFP.disableFPTextureParameter("vfield");
     240    _queryVelocityFP.unbind();
    223241
    224242    glReadPixels(0, 0, _renderTargetWidth, _renderTargetHeight, GL_RGB, GL_FLOAT, _velocities);
     
    228246    glMatrixMode(GL_MODELVIEW);
    229247    glPopMatrix();
     248
     249    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
     250
    230251    glPopAttrib();
    231 
    232     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     252}
     253
     254static void drawLineArrow(int axis)
     255{
     256    glBegin(GL_LINES);
     257    switch (axis) {
     258    case 0: // ZY plane
     259        glVertex3f(0.0, 0.0, 0.0);
     260        glVertex3f(0.0, 0.0, 1.0);
     261
     262        glVertex3f(0.0, 0.0, 1.0);
     263        glVertex3f(0.0, 0.25, 0.75);
     264
     265        glVertex3f(0.0, 0.0, 1.0);
     266        glVertex3f(0.0, -0.25, 0.75);
     267        break;
     268    case 1: // XZ plane
     269        glVertex3f(0.0, 0.0, 0.0);
     270        glVertex3f(1.0, 0.0, 0.0);
     271
     272        glVertex3f(1.0, 0.0, 0.0);
     273        glVertex3f(0.75, 0.0, 0.25);
     274
     275        glVertex3f(1.0, 0.0, 0.0);
     276        glVertex3f(0.75, 0.0, -0.25);
     277        break;
     278    case 2: // XY plane
     279    default:
     280        glVertex3f(0.0, 0.0, 0.0);
     281        glVertex3f(1.0, 0.0, 0.0);
     282
     283        glVertex3f(1.0, 0.0, 0.0);
     284        glVertex3f(0.75, 0.25, 0.0);
     285
     286        glVertex3f(1.0, 0.0, 0.0);
     287        glVertex3f(0.75, -0.25, 0.0);
     288        break;
     289    }
     290    glEnd();
    233291}
    234292
     
    244302    }
    245303
     304    TRACE("_vf: %g %g %g\n", _vfXscale,_vfYscale, _vfZscale);
     305    TRACE("_maxVelocityScale: %g %g %g\n",
     306          _maxVelocityScale.x, _maxVelocityScale.y, _maxVelocityScale.z);
     307
     308    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     309
     310    glMatrixMode(GL_MODELVIEW);
    246311    glPushMatrix();
    247312
    248313    glScalef(_vfXscale,_vfYscale, _vfZscale);
    249314    glTranslatef(-0.5f, -0.5f, -0.5f);
     315
    250316    if (_renderMode == LINES) {
    251         glPushAttrib(GL_ENABLE_BIT);
    252317        glDisable(GL_TEXTURE_2D);
    253318        glDisable(GL_LIGHTING);
    254319        glLineWidth(2.0);
    255320        glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
    256         glBegin(GL_LINES);
     321 
    257322        Vector3 pos;
    258         Vector3 pos2;
    259         Vector3 vel(1, 0, 0);
    260         Vector3 v, v2;
    261         if (_axis == 2) {
    262             int index = 0;
    263             for (int y = 1; y <= _tickCountY; ++y) {
    264                 for (int x = 1; x <= _tickCountX; ++x, ++index) {
    265                     pos = _samplingPositions[index];
    266                     pos2 = _velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
    267                     glVertex3f(pos.x, pos.y, pos.z);
    268                     glVertex3f(pos2.x, pos2.y, pos2.z);
     323        Vector3 vel;
     324        Vector3 refVec;
     325        Vector3 blue(0, 0, 1);
     326        Vector3 red(1, 0, 0);
     327
     328        int index = 0, icount, jcount;
     329        switch (_axis) {
     330        case 0:
     331            icount = _tickCountZ;
     332            jcount = _tickCountY;
     333            refVec.set(0, 0, 1);
     334            break;
     335        case 1:
     336            icount = _tickCountZ;
     337            jcount = _tickCountX;
     338            refVec.set(1, 0, 0);
     339            break;
     340        case 2:
     341        default:
     342            icount = _tickCountY;
     343            jcount = _tickCountX;
     344            refVec.set(1, 0, 0);
     345            break;
     346        }
     347
     348        for (int i = 0; i < icount; ++i) {
     349            for (int j = 0; j < jcount; ++j, ++index) {
     350                pos = _samplingPositions[index];
     351                // Normalized velocity: [-1,1] components
     352                // Project 3D vector onto sample plane
     353                vel = _velocities[index].scale(_projectionVector);
     354                // Length: [0,1]
     355                double length = vel.length();
     356                if (length < 0.0 || length > 1.0) {
     357                    TRACE("***vec: (%g, %g, %g) length: %g***\n", vel.x, vel.y, vel.z, length);
     358                    continue;
     359                }
     360                if (length > 1.0e-6) {
     361                    Vector3 vnorm = vel.normalize();
     362                    Vector3 rotationAxis = refVec.cross(vnorm);
     363                    double angle = rad2deg(acos(refVec.dot(vnorm)));
     364                    Vector3 color = blue * (1.0 - length) + red * length;
     365                    float scale = length;
     366                    if (scale < 0.10) scale = 0.10;
     367                    glMatrixMode(GL_MODELVIEW);
     368                    glPushMatrix();
     369                    glColor3f(color.x, color.y, color.z);
     370                    glTranslatef(pos.x, pos.y, pos.z);
     371                    glScalef(2.0 * _maxVelocityScale.x,
     372                             2.0 * _maxVelocityScale.y,
     373                             2.0 * _maxVelocityScale.z);
     374                    glScalef(scale, scale, scale);
     375                    if (angle > 1.0e-6 || angle < -1.0e-6)
     376                        glRotated(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
     377                    drawLineArrow(_axis);
     378                    glPopMatrix();
    269379                }
    270380            }
    271         } else if (_axis == 1) {
    272             int index = 0;
    273             for (int z = 1; z <= _tickCountZ; ++z) {
    274                 for (int x = 1; x <= _tickCountX; ++x, ++index) {
    275                     pos = _samplingPositions[index];
    276                     pos2 = _velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
    277 
    278                     glVertex3f(pos.x, pos.y, pos.z);
    279                     glVertex3f(pos2.x, pos2.y, pos2.z);
    280                 }
    281             }
    282         } else if (_axis == 0) {
    283             int index = 0;
    284             for (int z = 1; z <= _tickCountZ; ++z) {
    285                 for (int y = 1; y <= _tickCountY; ++y, ++index) {
    286                     pos = _samplingPositions[index];
    287                     pos2 = _velocities[index].scale(_projectionVector).scale(_maxVelocityScale) + pos;
    288 
    289                     glVertex3f(pos.x, pos.y, pos.z);
    290                     glVertex3f(pos2.x, pos2.y, pos2.z);
    291                 }
    292             }
    293         }
    294 
    295         glEnd();
     381        }
     382
    296383        glLineWidth(1.0);
    297         glPopAttrib();
    298384    } else {
    299         glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
     385        glColor4f(_arrowColor.x, _arrowColor.y, _arrowColor.z, 1.0f);
     386        glEnable(GL_DEPTH_TEST);
     387        glDisable(GL_LIGHTING);
     388#if 0
     389        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    300390        glEnable(GL_BLEND);
    301         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
     391        glDepthMask(GL_FALSE);
     392#else
     393        glDisable(GL_BLEND);
     394#endif
     395        glAlphaFunc(GL_GREATER, 0.6);
     396        glEnable(GL_ALPHA_TEST);
    302397        glEnable(GL_POINT_SPRITE_ARB);
    303398        glPointSize(20);
     
    306401        _arrowsTex->activate();
    307402        glEnable(GL_TEXTURE_2D);
    308 
     403        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     404
     405        GLfloat atten[] = {1, 0, 0};
     406        glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, atten);
    309407        glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f);
    310408        glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
     
    312410        glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    313411
    314         cgGLBindProgram(_particleVP);
    315         cgGLBindProgram(_particleFP);
    316         cgGLEnableProfile(CG_PROFILE_VP40);
    317         cgGLEnableProfile(CG_PROFILE_FP40);
    318 
    319         cgGLSetTextureParameter(_vectorParticleParam, _vectorFieldGraphicsID);
    320         cgGLEnableTextureParameter(_vectorParticleParam);
    321 
    322         //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * 0.5) * _screenHeight * 0.5);
    323         cgSetParameter1f(_mvTanHalfFOVParam, tan(30. * 0.5) * NanoVis::winHeight * 0.5);
    324 
    325         cgGLSetStateMatrixParameter(_mvpParticleParam,
    326                                     CG_GL_MODELVIEW_PROJECTION_MATRIX,
    327                                     CG_GL_MATRIX_IDENTITY);
    328         cgGLSetStateMatrixParameter(_mvParticleParam,
    329                                     CG_GL_MODELVIEW_MATRIX,
    330                                     CG_GL_MATRIX_IDENTITY);
     412        _particleShader.bind();
     413        _particleShader.setVPTextureParameter("vfield", _vectorFieldGraphicsID);
     414        _particleShader.setFPTextureParameter("arrows", _arrowsTex->id());
     415        _particleShader.setVPParameter1f("tanHalfFOV",
     416                                         tan(30. * 0.5) * NanoVis::winHeight * 0.5);
     417        _particleShader.setGLStateMatrixVPParameter("modelview",
     418                                                    NvShader::MODELVIEW_MATRIX,
     419                                                    NvShader::MATRIX_IDENTITY);
     420        _particleShader.setGLStateMatrixVPParameter("mvp",
     421                                                    NvShader::MODELVIEW_PROJECTION_MATRIX,
     422                                                    NvShader::MATRIX_IDENTITY);
    331423
    332424        glEnableClientState(GL_VERTEX_ARRAY);
     
    340432
    341433        glDisableClientState(GL_VERTEX_ARRAY);
    342 
    343         cgGLDisableProfile(CG_PROFILE_VP40);
    344         cgGLDisableProfile(CG_PROFILE_FP40);
    345 
    346         glDepthMask(GL_TRUE);
    347 
     434        glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
    348435        glDisable(GL_POINT_SPRITE_ARB);
    349         glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
    350 
    351         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    352         glDisable(GL_BLEND);
     436
     437        _particleShader.disableVPTextureParameter("vfield");
     438        _particleShader.disableFPTextureParameter("arrows");
     439        _particleShader.unbind();
     440
     441        glActiveTexture(GL_TEXTURE0);
     442        glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
    353443        _arrowsTex->deactivate();
    354444    }
     445
    355446    glPopMatrix();
     447    glPopAttrib();
    356448}
    357449
    358450void
    359 VelocityArrowsSlice::vectorField(unsigned int vfGraphicsID,
    360                                  float xScale, float yScale, float zScale)
     451VelocityArrowsSlice::setVectorField(unsigned int vfGraphicsID, const Vector3& origin,
     452                                    float xScale, float yScale, float zScale, float max)
    361453{
    362454    _vectorFieldGraphicsID = vfGraphicsID;
     
    365457    _vfZscale = zScale;
    366458
    367     //_dirty = true;
     459    _dirty = true;
    368460}
    369461
     
    371463{
    372464    if (_vfXscale < _vfYscale) {
    373         if (_vfXscale < _vfZscale) {
     465        if (_vfXscale < _vfZscale || _vfZscale == 0.0) {
    374466            // vfXscale
    375467            _tickCountX = _tickCountForMinSizeAxis;
     
    379471            _tickCountY = (int)(_vfYscale/step);
    380472            _tickCountZ = (int)(_vfZscale/step);
    381             //vscalex = 1;
    382             //vscaley = _vfXscale / _vfXscale;
    383             //vscalez = _vfZscale / _vfXscale;
    384473        } else {
    385474            // vfZscale
     
    389478            _tickCountX = (int)(_vfXscale/step);
    390479            _tickCountY = (int)(_vfYscale/step);
    391             //vscalex = _vfXscale / _vfZscale;
    392             //vscaley = _vfYscale / _vfZscale;
    393             //vscalez = 1;
    394480        }
    395481    } else {
    396         if (_vfYscale < _vfZscale) {
     482        if (_vfYscale < _vfZscale || _vfZscale == 0.0) {
    397483            // _vfYscale
    398484            _tickCountY = _tickCountForMinSizeAxis;
     
    401487            _tickCountX = (int)(_vfXscale/step);
    402488            _tickCountZ = (int)(_vfZscale/step);
    403 
    404             //vscalex = _vfXscale / _vfYscale;
    405             //vscaley = 1;
    406             //vscalez = _vfZscale / _vfYscale;
    407489        } else {
    408490            // vfZscale
     
    412494            _tickCountX = (int)(_vfXscale/step);
    413495            _tickCountY = (int)(_vfYscale/step);
    414 
    415             //vscalex = _vfXscale / _vfZscale;
    416             //vscaley = _vfYscale / _vfZscale;
    417             //vscalez = 1;
    418         }
     496        }
     497    }
     498
     499    switch (_axis) {
     500    case 0:
     501        _tickCountX = 1;
     502        _renderTargetWidth = _tickCountY;
     503        _renderTargetHeight = _tickCountZ;
     504        break;
     505    case 1:
     506        _tickCountY = 1;
     507        _renderTargetWidth = _tickCountX;
     508        _renderTargetHeight = _tickCountZ;
     509        break;
     510    default:
     511    case 2:
     512        _tickCountZ = 1;
     513        _renderTargetWidth = _tickCountX;
     514        _renderTargetHeight = _tickCountY;
     515        break;
    419516    }
    420517
     
    422519    _maxVelocityScale.y = (1.0f / _tickCountY) * 0.8f;
    423520    _maxVelocityScale.z = (1.0f / _tickCountZ) * 0.8f;
     521
     522    TRACE("Tick counts: %d %d %d\n", _tickCountX, _tickCountY, _tickCountZ);
    424523
    425524    int pointCount = _tickCountX * _tickCountY * _tickCountZ;
     
    430529    }
    431530
    432     if (_renderMode == LINES) {
    433         Vector3 pos;
    434         if (_axis == 2) {
    435             for (int y = 1; y <= _tickCountY; ++y) {
    436                 for (int x = 1; x <= _tickCountX; ++x) {
    437                     pos.x = (1.0f / (_tickCountX + 1)) * x;
    438                     pos.y = (1.0f / (_tickCountY + 1)) * y;
    439                     pos.z = _slicePos;
     531    createRenderTarget();
     532
     533    Vector3 pos;
     534    Vector3 *pinfo = NULL;
     535    if (_renderMode == GLYPHS) {
     536        glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
     537        pinfo = (Vector3 *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
     538    }
     539
     540    if (_axis == 2) {
     541        for (int y = 1; y <= _tickCountY; ++y) {
     542            for (int x = 1; x <= _tickCountX; ++x) {
     543                pos.x = (1.0f / (_tickCountX + 1)) * x;
     544                pos.y = (1.0f / (_tickCountY + 1)) * y;
     545                pos.z = _slicePos;
     546                if (_renderMode == LINES) {
    440547                    _samplingPositions.push_back(pos);
    441                 }
    442             }
    443         } else if (_axis == 1) {
    444             for (int z = 1; z <= _tickCountZ; ++z) {
    445                 for (int x = 1; x <= _tickCountX; ++x) {
    446                     pos.x = (1.0f / (_tickCountX + 1)) * x;
    447                     pos.y = _slicePos;
    448                     pos.z = (1.0f / (_tickCountZ + 1)) * z;
    449                     _samplingPositions.push_back(pos);
    450                 }
    451             }
    452         } else if (_axis == 0) {
    453             for (int z = 1; z <= _tickCountZ; ++z) {
    454                 for (int y = 1; y <= _tickCountY; ++y) {
    455                     pos.x = _slicePos;
    456                     pos.y = (1.0f / (_tickCountY + 1)) * y;
    457                     pos.z = (1.0f / (_tickCountZ + 1)) * z;
    458                     _samplingPositions.push_back(pos);
    459                 }
    460             }
    461         }
    462     } else {
    463         glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
    464         Vector3 *pinfo = (Vector3 *)glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
    465 
    466         Vector3 pos;
    467         if (_axis == 2) {
    468             for (int y = 1; y <= _tickCountY; ++y) {
    469                 for (int x = 1; x <= _tickCountX; ++x) {
    470                     pos.x = (1.0f / (_tickCountX + 1)) * x;
    471                     pos.y = (1.0f / (_tickCountY + 1)) * y;
    472                     pos.z = _slicePos;
    473 
     548                } else {
    474549                    *pinfo = pos;
    475550                    ++pinfo;
    476551                }
    477552            }
    478         } else if (_axis == 1) {
    479             for (int z = 1; z <= _tickCountZ; ++z) {
    480                 for (int x = 1; x <= _tickCountX; ++x) {
    481                     pos.x = (1.0f / (_tickCountX + 1)) * x;
    482                     pos.y = _slicePos;
    483                     pos.z = (1.0f / (_tickCountZ + 1)) * z;
    484 
     553        }
     554    } else if (_axis == 1) {
     555        for (int z = 1; z <= _tickCountZ; ++z) {
     556            for (int x = 1; x <= _tickCountX; ++x) {
     557                pos.x = (1.0f / (_tickCountX + 1)) * x;
     558                pos.y = _slicePos;
     559                pos.z = (1.0f / (_tickCountZ + 1)) * z;
     560                if (_renderMode == LINES) {
     561                    _samplingPositions.push_back(pos);
     562                } else {
    485563                    *pinfo = pos;
    486564                    ++pinfo;
    487565                }
    488566            }
    489         } else if (_axis == 0) {
    490             for (int z = 1; z <= _tickCountZ; ++z) {
    491                 for (int y = 1; y <= _tickCountY; ++y) {
    492                     pos.x = _slicePos;
    493                     pos.y = (1.0f / (_tickCountY + 1)) * y;
    494                     pos.z = (1.0f / (_tickCountZ + 1)) * z;
    495 
     567        }
     568    } else if (_axis == 0) {
     569        for (int z = 1; z <= _tickCountZ; ++z) {
     570            for (int y = 1; y <= _tickCountY; ++y) {
     571                pos.x = _slicePos;
     572                pos.y = (1.0f / (_tickCountY + 1)) * y;
     573                pos.z = (1.0f / (_tickCountZ + 1)) * z;
     574                if (_renderMode == LINES) {
     575                    _samplingPositions.push_back(pos);
     576                } else {
    496577                    *pinfo = pos;
    497578                    ++pinfo;
     
    499580            }
    500581        }
    501 
     582    }
     583
     584    if (_renderMode == GLYPHS) {
    502585        glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
    503586    }
  • trunk/packages/vizservers/nanovis/VelocityArrowsSlice.h

    r2953 r2964  
    55#include <vector>
    66
    7 #include <Cg/cg.h>
    8 #include <Cg/cgGL.h>
    9 
    107#include "Texture2D.h"
    118#include "Vector3.h"
     9#include "NvShader.h"
    1210
    1311class VelocityArrowsSlice
     
    2321    ~VelocityArrowsSlice();
    2422
    25     void vectorField(unsigned int vfGraphicsID, float xScale, float yScale, float zScale);
     23    void setVectorField(unsigned int vfGraphicsID, const Vector3& origin,
     24                        float xScale, float yScale, float zScale, float max);
    2625
    2726    void axis(int axis);
     
    9998    float _maxPointSize;
    10099
    101     CGcontext _context;
    102     CGprogram _queryVelocityFP;
    103     CGparameter _qvVectorFieldParam;
     100    NvShader _queryVelocityFP;
     101
     102    NvShader _particleShader;
    104103
    105104    int _renderTargetWidth;
     
    126125    unsigned int _vertexBufferGraphicsID;
    127126
    128     CGprogram _particleVP;
    129     CGparameter _mvpParticleParam;
    130     CGparameter _mvParticleParam;
    131     CGparameter _mvTanHalfFOVParam;
    132     CGparameter _mvCurrentTimeParam;
    133 
    134     CGprogram _particleFP;
    135     CGparameter _vectorParticleParam;
    136 
    137127    Texture2D *_arrowsTex;
    138128
  • trunk/packages/vizservers/nanovis/shaders/velocityslicefp.cg

    r2857 r2964  
    44
    55float4 fpmain(float2 texCoord : TEXCOORD0,
    6               float3 color : COLOR,
     6              float4 color : COLOR0,
    77              float2 center : TEXCOORD2,
    88              float4 rotation : TEXCOORD3,
    9               uniform sampler2D arrows : register(s0)) : COLOR
     9              uniform sampler2D arrows : TEXUNIT0) : COLOR
    1010{
    1111    float2 newTexCoord = float2((texCoord.x - 0.5) / NUM_SUBIMAGE_X, (texCoord.y - 0.5) / NUM_SUBIMAGE_Y);
     
    1717    rotTexCoord = rotTexCoord + center;
    1818
    19     return float4(tex2D(arrows, rotTexCoord.xy).xyz * color, 1.0);
     19    return tex2D(arrows, rotTexCoord.xy) * color;
    2020}
  • trunk/packages/vizservers/nanovis/shaders/velocityslicevp.cg

    r2924 r2964  
    1010            out float4 rotation : TEXCOORD3,
    1111            out float4 pointSize : PSIZE,
    12             uniform sampler3D vfield,
     12            uniform sampler3D vfield : TEXUNIT1,
    1313            uniform float tanHalfFOV,
    1414            uniform float4x4 modelview,
Note: See TracChangeset for help on using the changeset viewer.