source: nanovis/branches/1.1/VelocityArrowsSlice.cpp @ 4906

Last change on this file since 4906 was 4904, checked in by ldelgass, 5 years ago

Merge serveral changes from trunk. Does not include threading, world space
changes, etc.

  • Property svn:eol-style set to native
File size: 18.3 KB
RevLine 
[2798]1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
[3502]2/*
3 * Copyright (C) 2004-2013  HUBzero Foundation, LLC
4 *
5 */
[2818]6
[2964]7#include <math.h>
8
[1493]9#include <GL/glew.h>
10#include <GL/gl.h>
[1489]11
[3492]12#include <vrmath/Vector3f.h>
[3465]13#include <util/FilePath.h>
[2857]14#include <Image.h>
15#include <ImageLoaderFactory.h>
16#include <ImageLoader.h>
[2831]17
[2870]18#include "nanovis.h"
[2818]19#include "VelocityArrowsSlice.h"
[4889]20#include "Shader.h"
21#include "Camera.h"
[1489]22
[4889]23using namespace nv;
[3463]24using namespace nv::util;
[3492]25using namespace vrmath;
[3463]26
[2964]27static inline float deg2rad(float deg)
[1493]28{
[2964]29    return ((deg * M_PI) / 180.);
30}
[2831]31
[2964]32static inline float rad2deg(float rad)
33{
34    return ((rad * 180.) / M_PI);
35}
[1493]36
[2964]37VelocityArrowsSlice::VelocityArrowsSlice() :
38    _vectorFieldGraphicsID(0),
39    _slicePos(0.5f),
[4904]40    _axis(AXIS_Z),
[2964]41    _fbo(0),
42    _tex(0),
43    _maxPointSize(1.0f),
44    _renderTargetWidth(128),
45    _renderTargetHeight(128),
46    _velocities(NULL),
47    _projectionVector(1, 1, 0),
48    _tickCountForMinSizeAxis(10),
49    _tickCountX(0),
50    _tickCountY(0),
51    _tickCountZ(0),
52    _pointCount(0),
53    _maxVelocityScale(1, 1, 1),
54    _arrowColor(1, 1, 0),
[4904]55    _visible(false),
[2964]56    _dirty(true),
57    _vertexBufferGraphicsID(0),
58    _arrowsTex(NULL),
59    _renderMode(LINES)
60{
[4904]61    setSliceAxis(_axis);
[2831]62
[4904]63    _queryVelocityFP.loadFragmentProgram("queryvelocity.cg");
[1493]64
[4904]65    _particleShader.loadVertexProgram("velocityslicevp.cg");
66    _particleShader.loadFragmentProgram("velocityslicefp.cg");
[1493]67
[2818]68    createRenderTarget();
[1493]69
[3463]70    std::string path = FilePath::getInstance()->getPath("arrows.bmp");
[2972]71    if (!path.empty()) {
[2857]72        ImageLoader *loader = ImageLoaderFactory::getInstance()->createLoader("bmp");
73        if (loader != NULL) {
[2972]74            Image *image = loader->load(path.c_str(), Image::IMG_RGBA);
[2857]75            if (image != NULL) {
76                unsigned char *bytes = (unsigned char *)image->getImageBuffer();
77                if (bytes != NULL) {
78                    _arrowsTex = new Texture2D(image->getWidth(), image->getHeight(),
79                                               GL_UNSIGNED_BYTE, GL_LINEAR, 4, NULL);
80                    _arrowsTex->setWrapS(GL_MIRRORED_REPEAT);
81                    _arrowsTex->setWrapT(GL_MIRRORED_REPEAT);
82                    _arrowsTex->initialize(image->getImageBuffer());
83                }
84                delete image;
85            } else {
[3452]86                ERROR("Failed to load arrows image");
[2857]87            }
88            delete loader;
89        } else {
[3452]90            ERROR("Couldn't find loader for arrows image");
[2857]91        }
92    } else {
[3452]93        ERROR("Couldn't find arrows image");
[2857]94    }
95
[2870]96    GLfloat minMax[2];
97    glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, minMax);
[3452]98    TRACE("Aliased point size range: %g %g", minMax[0], minMax[1]);
[2870]99    _maxPointSize = minMax[1];
100    glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, minMax);
[3452]101    TRACE("Smooth point size range: %g %g", minMax[0], minMax[1]);
[2870]102    _maxPointSize = minMax[1] > _maxPointSize ? minMax[1] : _maxPointSize;
[3452]103    TRACE("Max point size: %g", _maxPointSize);
[2870]104
[3452]105    TRACE("Leaving VelocityArrowsSlice constructor");
[1493]106}
107
108VelocityArrowsSlice::~VelocityArrowsSlice()
109{
[2964]110    if (_tex != 0) {
111        glDeleteTextures(1, &_tex);
112    }
113    if (_fbo != 0) {
114        glDeleteFramebuffersEXT(1, &_fbo);
115    }
116    if (_arrowsTex != NULL) {
117        delete _arrowsTex;
118    }
119    if (_vertexBufferGraphicsID != 0) {
120        glDeleteBuffers(1, &_vertexBufferGraphicsID);
121    }
122    if (_velocities != NULL) {
123        delete [] _velocities;
124    }
125}
[1486]126
[2964]127void VelocityArrowsSlice::createRenderTarget()
128{
129    if (_velocities != NULL) {
130        delete [] _velocities;
131    }
[3492]132    _velocities = new Vector3f[_renderTargetWidth * _renderTargetHeight];
[2831]133
[2964]134    if (_vertexBufferGraphicsID != 0) {
135        glDeleteBuffers(1, &_vertexBufferGraphicsID);
136    }
[1493]137
[2964]138    glGenBuffers(1, &_vertexBufferGraphicsID);
139    glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
140    glBufferDataARB(GL_ARRAY_BUFFER_ARB, _renderTargetWidth * _renderTargetHeight * 3 * sizeof(float), 
141                    0, GL_DYNAMIC_DRAW_ARB);
142    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
[1493]143
[2964]144    if (_tex != 0) {
145        glDeleteTextures(1, &_tex);
146    }
147    if (_fbo != 0) {
148        glDeleteFramebuffersEXT(1, &_fbo);
149    }
150
[2818]151    glGenFramebuffersEXT(1, &_fbo);
[1493]152    glGenTextures(1, &_tex);
[2964]153    int fboOrig;
154    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
[1493]155    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
[2831]156
[2884]157    glBindTexture(GL_TEXTURE_RECTANGLE_ARB, _tex);
158    glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
159    glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
160    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
161    glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
[1493]162
[2884]163    glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA32F_ARB, 
[2818]164                 _renderTargetWidth, _renderTargetHeight, 0,
165                 GL_RGBA, GL_FLOAT, NULL);
[2831]166
[2818]167    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, 
[2884]168                              GL_TEXTURE_RECTANGLE_ARB, _tex, 0);
[1493]169
[2964]170    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
[1493]171}
172
[4904]173void VelocityArrowsSlice::setSliceAxis(FlowSliceAxis axis)
[1493]174{
[2818]175    _axis = axis;
176    switch (_axis) {
[4904]177    case AXIS_X:
[2818]178        _projectionVector.x = 0;
179        _projectionVector.y = 1;
180        _projectionVector.z = 1;
181        break;
[4904]182    case AXIS_Y:
[2818]183        _projectionVector.x = 1;
184        _projectionVector.y = 0;
185        _projectionVector.z = 1;
186        break;
[4904]187    case AXIS_Z:
[2818]188        _projectionVector.x = 1;
189        _projectionVector.y = 1;
190        _projectionVector.z = 0;
191        break;
192    }
[2964]193    _dirty = true;
[1493]194}
195
196void VelocityArrowsSlice::queryVelocity()
197{
[2964]198    glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT);
199    int fboOrig;
200    glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &fboOrig);
201
[2818]202    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _fbo);
[2964]203
204    _queryVelocityFP.bind();
205    _queryVelocityFP.setFPTextureParameter("vfield", _vectorFieldGraphicsID);
206
[2818]207    glDisable(GL_DEPTH_TEST);
208    glViewport(0, 0, _renderTargetWidth, _renderTargetHeight);
209    glMatrixMode(GL_PROJECTION);
210    glPushMatrix();
211    glLoadIdentity();
212    glOrtho(0, _renderTargetWidth, 0, _renderTargetHeight, -10.0f, 10.0f);
213    glMatrixMode(GL_MODELVIEW);
214    glPushMatrix();
215    glLoadIdentity();
[1493]216
[2964]217    glBegin(GL_QUADS);
218    switch (_axis) {
[4904]219    case AXIS_X:
[2964]220        glTexCoord3f(_slicePos, 0, 0); glVertex2i(0,                  0);
221        glTexCoord3f(_slicePos, 1, 0); glVertex2i(_renderTargetWidth, 0);
222        glTexCoord3f(_slicePos, 1, 1); glVertex2i(_renderTargetWidth, _renderTargetHeight);
223        glTexCoord3f(_slicePos, 0, 1); glVertex2i(0,                  _renderTargetHeight);
224        break;
[4904]225    case AXIS_Y:
[2964]226        glTexCoord3f(0, _slicePos, 0); glVertex2i(0,                  0);
227        glTexCoord3f(1, _slicePos, 0); glVertex2i(_renderTargetWidth, 0);
228        glTexCoord3f(1, _slicePos, 1); glVertex2i(_renderTargetWidth, _renderTargetHeight);
229        glTexCoord3f(0, _slicePos, 1); glVertex2i(0,                  _renderTargetHeight);
230        break;
[4904]231    case AXIS_Z:
[2964]232    default:
233        glTexCoord3f(0, 0, _slicePos); glVertex2i(0,                  0);
234        glTexCoord3f(1, 0, _slicePos); glVertex2i(_renderTargetWidth, 0);
235        glTexCoord3f(1, 1, _slicePos); glVertex2i(_renderTargetWidth, _renderTargetHeight);
236        glTexCoord3f(0, 1, _slicePos); glVertex2i(0,                  _renderTargetHeight);
237        break;
[2818]238    }
239    glEnd();
[1493]240
[2964]241    _queryVelocityFP.disableFPTextureParameter("vfield");
242    _queryVelocityFP.unbind();
[1493]243
[2818]244    glReadPixels(0, 0, _renderTargetWidth, _renderTargetHeight, GL_RGB, GL_FLOAT, _velocities);
[1493]245
[2818]246    glMatrixMode(GL_PROJECTION);
247    glPopMatrix();
248    glMatrixMode(GL_MODELVIEW);
249    glPopMatrix();
[2964]250
251    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboOrig);
252
[2818]253    glPopAttrib();
[2964]254}
[2818]255
[4904]256static void drawLineArrow(FlowSliceAxis axis)
[2964]257{
258    glBegin(GL_LINES);
259    switch (axis) {
[4904]260    case AXIS_X: // ZY plane
[2964]261        glVertex3f(0.0, 0.0, 0.0);
262        glVertex3f(0.0, 0.0, 1.0);
263
264        glVertex3f(0.0, 0.0, 1.0);
265        glVertex3f(0.0, 0.25, 0.75);
266
267        glVertex3f(0.0, 0.0, 1.0);
268        glVertex3f(0.0, -0.25, 0.75);
269        break;
[4904]270    case AXIS_Y: // XZ plane
[2964]271        glVertex3f(0.0, 0.0, 0.0);
272        glVertex3f(1.0, 0.0, 0.0);
273
274        glVertex3f(1.0, 0.0, 0.0);
275        glVertex3f(0.75, 0.0, 0.25);
276
277        glVertex3f(1.0, 0.0, 0.0);
278        glVertex3f(0.75, 0.0, -0.25);
279        break;
[4904]280    case AXIS_Z: // XY plane
[2964]281    default:
282        glVertex3f(0.0, 0.0, 0.0);
283        glVertex3f(1.0, 0.0, 0.0);
284
285        glVertex3f(1.0, 0.0, 0.0);
286        glVertex3f(0.75, 0.25, 0.0);
287
288        glVertex3f(1.0, 0.0, 0.0);
289        glVertex3f(0.75, -0.25, 0.0);
290        break;
291    }
292    glEnd();
[1493]293}
294
295void VelocityArrowsSlice::render()
296{
[4904]297    if (!_visible)
[2857]298        return;
[2818]299
[1493]300    if (_dirty) {
[2857]301        computeSamplingTicks();
302        queryVelocity();
303        _dirty = false;
[1493]304    }
[2818]305
[4904]306    TRACE("_scale: %g %g %g", _scale.x, _scale.y, _scale.z);
[3452]307    TRACE("_maxVelocityScale: %g %g %g",
[2964]308          _maxVelocityScale.x, _maxVelocityScale.y, _maxVelocityScale.z);
309
310    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
311
312    glMatrixMode(GL_MODELVIEW);
[1493]313    glPushMatrix();
[2831]314
[4904]315    glScalef(_scale.x, _scale.y, _scale.z);
[1493]316    glTranslatef(-0.5f, -0.5f, -0.5f);
[2964]317
[1493]318    if (_renderMode == LINES) {
[2857]319        glDisable(GL_TEXTURE_2D);
[2884]320        glDisable(GL_LIGHTING);
[2857]321        glLineWidth(2.0);
322        glColor3f(_arrowColor.x, _arrowColor.y, _arrowColor.z);
[2964]323 
[3492]324        Vector3f pos;
325        Vector3f vel;
326        Vector3f refVec;
327        Vector3f blue(0, 0, 1);
328        Vector3f red(1, 0, 0);
[2831]329
[2964]330        int index = 0, icount, jcount;
331        switch (_axis) {
[4904]332        case AXIS_X:
[2964]333            icount = _tickCountZ;
334            jcount = _tickCountY;
335            refVec.set(0, 0, 1);
336            break;
[4904]337        case AXIS_Y:
[2964]338            icount = _tickCountZ;
339            jcount = _tickCountX;
340            refVec.set(1, 0, 0);
341            break;
[4904]342        case AXIS_Z:
[2964]343        default:
344            icount = _tickCountY;
345            jcount = _tickCountX;
346            refVec.set(1, 0, 0);
347            break;
348        }
[2831]349
[2964]350        for (int i = 0; i < icount; ++i) {
351            for (int j = 0; j < jcount; ++j, ++index) {
352                pos = _samplingPositions[index];
353                // Normalized velocity: [-1,1] components
354                // Project 3D vector onto sample plane
355                vel = _velocities[index].scale(_projectionVector);
356                // Length: [0,1]
357                double length = vel.length();
358                if (length < 0.0 || length > 1.0) {
[3452]359                    TRACE("***vec: (%g, %g, %g) length: %g***", vel.x, vel.y, vel.z, length);
[2964]360                    continue;
[2857]361                }
[4904]362                if (length > 0.0) {
[3492]363                    Vector3f vnorm = vel.normalize();
364                    Vector3f rotationAxis = refVec.cross(vnorm);
[2964]365                    double angle = rad2deg(acos(refVec.dot(vnorm)));
[3492]366                    Vector3f color = blue * (1.0 - length) + red * length;
[2964]367                    float scale = length;
368                    if (scale < 0.10) scale = 0.10;
369                    glMatrixMode(GL_MODELVIEW);
370                    glPushMatrix();
371                    glColor3f(color.x, color.y, color.z);
372                    glTranslatef(pos.x, pos.y, pos.z);
373                    glScalef(2.0 * _maxVelocityScale.x,
374                             2.0 * _maxVelocityScale.y,
375                             2.0 * _maxVelocityScale.z);
376                    glScalef(scale, scale, scale);
377                    if (angle > 1.0e-6 || angle < -1.0e-6)
378                        glRotated(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
379                    drawLineArrow(_axis);
380                    glPopMatrix();
381                }
[2818]382            }
[2857]383        }
[2818]384
[2857]385        glLineWidth(1.0);
[1493]386    } else {
[2964]387        glColor4f(_arrowColor.x, _arrowColor.y, _arrowColor.z, 1.0f);
388        glEnable(GL_DEPTH_TEST);
389        glDisable(GL_LIGHTING);
390#if 0
391        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
[2857]392        glEnable(GL_BLEND);
[2964]393        glDepthMask(GL_FALSE);
394#else
395        glDisable(GL_BLEND);
396#endif
397        glAlphaFunc(GL_GREATER, 0.6);
398        glEnable(GL_ALPHA_TEST);
[2870]399        glEnable(GL_POINT_SPRITE_ARB);
[2857]400        glPointSize(20);
[2884]401        glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
[2831]402
[2857]403        _arrowsTex->activate();
404        glEnable(GL_TEXTURE_2D);
[4904]405        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
[2831]406
[2964]407        GLfloat atten[] = {1, 0, 0};
408        glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, atten);
[2857]409        glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f);
410        glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
[2870]411        glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, _maxPointSize);
[4904]412        glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
[2831]413
[2964]414        _particleShader.bind();
415        _particleShader.setVPTextureParameter("vfield", _vectorFieldGraphicsID);
416        _particleShader.setFPTextureParameter("arrows", _arrowsTex->id());
417        _particleShader.setVPParameter1f("tanHalfFOV",
[4904]418                                         tan(NanoVis::getCamera()->getFov() * 0.5) * NanoVis::winHeight * 0.5);
[2964]419        _particleShader.setGLStateMatrixVPParameter("modelview",
[4889]420                                                    Shader::MODELVIEW_MATRIX,
421                                                    Shader::MATRIX_IDENTITY);
[2964]422        _particleShader.setGLStateMatrixVPParameter("mvp",
[4889]423                                                    Shader::MODELVIEW_PROJECTION_MATRIX,
424                                                    Shader::MATRIX_IDENTITY);
[2831]425
[2857]426        glEnableClientState(GL_VERTEX_ARRAY);
427        glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
428        glVertexPointer(3, GL_FLOAT, 0, 0);
429        //glEnableClientState(GL_COLOR_ARRAY);
[2831]430
[2857]431        // TBD..
432        glDrawArrays(GL_POINTS, 0, _pointCount);
433        glPointSize(1);
[2831]434
[2857]435        glDisableClientState(GL_VERTEX_ARRAY);
[2964]436        glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
437        glDisable(GL_POINT_SPRITE_ARB);
[2831]438
[2964]439        _particleShader.disableVPTextureParameter("vfield");
440        _particleShader.disableFPTextureParameter("arrows");
441        _particleShader.unbind();
[2831]442
[2964]443        glActiveTexture(GL_TEXTURE0);
[4904]444        glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
[2857]445        _arrowsTex->deactivate();
[1493]446    }
[2964]447
[1493]448    glPopMatrix();
[2964]449    glPopAttrib();
[1493]450}
[1489]451
[1493]452void 
[3492]453VelocityArrowsSlice::setVectorField(unsigned int vfGraphicsID, const Vector3f& origin,
[2964]454                                    float xScale, float yScale, float zScale, float max)
[1493]455{
456    _vectorFieldGraphicsID = vfGraphicsID;
[4904]457    _scale.set(xScale, yScale, zScale);
[1493]458
[2964]459    _dirty = true;
[1493]460}
461
462void VelocityArrowsSlice::computeSamplingTicks()
463{
[4904]464    if (_scale.x < _scale.y) {
465        if (_scale.x < _scale.z || _scale.z == 0.0) {
466            // _scale.x
[2818]467            _tickCountX = _tickCountForMinSizeAxis;
[2857]468
[4904]469            float step = _scale.x / (_tickCountX + 1);
470            _tickCountY = (int)(_scale.y/step);
471            _tickCountZ = (int)(_scale.z/step);
[2818]472        } else {
[4904]473            // _scale.z
[2818]474            _tickCountZ = _tickCountForMinSizeAxis;
[1493]475
[4904]476            float step = _scale.z / (_tickCountZ + 1);
477            _tickCountX = (int)(_scale.x/step);
478            _tickCountY = (int)(_scale.y/step);
[2818]479        }
480    } else {
[4904]481        if (_scale.y < _scale.z || _scale.z == 0.0) {
482            // _scale.y
[2818]483            _tickCountY = _tickCountForMinSizeAxis;
[1484]484
[4904]485            float step = _scale.y / (_tickCountY + 1);
486            _tickCountX = (int)(_scale.x/step);
487            _tickCountZ = (int)(_scale.z/step);
[2818]488        } else {
[4904]489            // _scale.z
[2818]490            _tickCountZ = _tickCountForMinSizeAxis;
[2857]491
[4904]492            float step = _scale.z / (_tickCountZ + 1);
493            _tickCountX = (int)(_scale.x/step);
494            _tickCountY = (int)(_scale.y/step);
[2818]495        }
496    }
[1493]497
[2964]498    switch (_axis) {
[4904]499    case AXIS_X:
[2964]500        _tickCountX = 1;
501        _renderTargetWidth = _tickCountY;
502        _renderTargetHeight = _tickCountZ;
503        break;
[4904]504    case AXIS_Y:
[2964]505        _tickCountY = 1;
506        _renderTargetWidth = _tickCountX;
507        _renderTargetHeight = _tickCountZ;
508        break;
509    default:
[4904]510    case AXIS_Z:
[2964]511        _tickCountZ = 1;
512        _renderTargetWidth = _tickCountX;
513        _renderTargetHeight = _tickCountY;
514        break;
515    }
516
[2884]517    _maxVelocityScale.x = (1.0f / _tickCountX) * 0.8f;
518    _maxVelocityScale.y = (1.0f / _tickCountY) * 0.8f;
519    _maxVelocityScale.z = (1.0f / _tickCountZ) * 0.8f;
[1493]520
[3452]521    TRACE("Tick counts: %d %d %d", _tickCountX, _tickCountY, _tickCountZ);
[2964]522
[2818]523    int pointCount = _tickCountX * _tickCountY * _tickCountZ;
524    if (_pointCount != pointCount) {
525        _samplingPositions.clear();
526        _samplingPositions.reserve(pointCount);
527        _pointCount = pointCount;
528    }
[1493]529
[2964]530    createRenderTarget();
531
[3492]532    Vector3f pos;
533    Vector3f *pinfo = NULL;
[2964]534    if (_renderMode == GLYPHS) {
[2818]535        glBindBufferARB(GL_ARRAY_BUFFER_ARB, _vertexBufferGraphicsID);
[3492]536        pinfo = (Vector3f *)glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
[2964]537    }
[1493]538
[4904]539    if (_axis == AXIS_Z) {
[2964]540        for (int y = 1; y <= _tickCountY; ++y) {
541            for (int x = 1; x <= _tickCountX; ++x) {
542                pos.x = (1.0f / (_tickCountX + 1)) * x;
543                pos.y = (1.0f / (_tickCountY + 1)) * y;
544                pos.z = _slicePos;
545                if (_renderMode == LINES) {
546                    _samplingPositions.push_back(pos);
547                } else {
[2818]548                    *pinfo = pos;
549                    ++pinfo;
550                }
551            }
[2964]552        }
[4904]553    } else if (_axis == AXIS_Y) {
[2964]554        for (int z = 1; z <= _tickCountZ; ++z) {
555            for (int x = 1; x <= _tickCountX; ++x) {
556                pos.x = (1.0f / (_tickCountX + 1)) * x;
557                pos.y = _slicePos;
558                pos.z = (1.0f / (_tickCountZ + 1)) * z;
559                if (_renderMode == LINES) {
560                    _samplingPositions.push_back(pos);
561                } else {
[2818]562                    *pinfo = pos;
563                    ++pinfo;
564                }
565            }
[2964]566        }
[4904]567    } else if (_axis == AXIS_X) {
[2964]568        for (int z = 1; z <= _tickCountZ; ++z) {
569            for (int y = 1; y <= _tickCountY; ++y) {
570                pos.x = _slicePos;
571                pos.y = (1.0f / (_tickCountY + 1)) * y;
572                pos.z = (1.0f / (_tickCountZ + 1)) * z;
573                if (_renderMode == LINES) {
574                    _samplingPositions.push_back(pos);
575                } else {
[2818]576                    *pinfo = pos;
577                    ++pinfo;
578                }
579            }
580        }
[2964]581    }
[2818]582
[2964]583    if (_renderMode == GLYPHS) {
[2818]584        glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
585    }
[1484]586}
Note: See TracBrowser for help on using the repository browser.