Ignore:
Timestamp:
Mar 9, 2012 5:11:37 PM (12 years ago)
Author:
ldelgass
Message:

More misc. cleanups

Location:
trunk/packages/vizservers/nanovis
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/nanovis/Makefile.in

    r2835 r2837  
    143143                RpAVTranslate.o \
    144144                ScreenSnapper.o \
    145                 Sphere.o \
    146145                Switch.o \
    147146                Texture1D.o \
    … …  
    163162OBJS +=         ParticleEmitter.o \
    164163                ParticleSystem.o \
    165                 ParticleSystemFactory.o
     164                ParticleSystemFactory.o \
     165                Sphere.o
    166166endif
    167167

  • trunk/packages/vizservers/nanovis/NvLIC.cpp

    r2831 r2837  
    2525
    2626NvLIC::NvLIC(int _size, int _width, int _height, int _axis,
    27              const Vector3& _offset, CGcontext _context) : 
    28     Renderable(Vector3(0.0f,0.0f,0.0f)),
     27             const Vector3& _offset, CGcontext _context) :
     28    Renderable(Vector3(0.0f, 0.0f, 0.0f)),
    2929    disListID(0),
    3030    width(_width),
    … …  
    3939    dmax(SCALE/NPIX),
    4040    max(1.0f),
    41     m_g_context(_context),
     41    _g_context(_context),
    4242    _vectorFieldId(0),
    4343    _activate(false)
    … …  
    110110    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    111111
    112     m_render_vel_fprog = LoadCgSourceProgram(m_g_context, "render_vel.cg",
     112    _render_vel_fprog = LoadCgSourceProgram(_g_context, "render_vel.cg",
    113113        CG_PROFILE_FP30, "main");
    114     m_vel_tex_param_render_vel = cgGetNamedParameter(m_render_vel_fprog,
     114    _vel_tex_param_render_vel = cgGetNamedParameter(_render_vel_fprog,
    115115        "vel_tex");
    116     m_plane_normal_param_render_vel = cgGetNamedParameter(m_render_vel_fprog,
     116    _plane_normal_param_render_vel = cgGetNamedParameter(_render_vel_fprog,
    117117        "plane_normal");
    118     m_max_param = cgGetNamedParameter(m_render_vel_fprog, "vmax");
     118    _max_param = cgGetNamedParameter(_render_vel_fprog, "vmax");
    119119
    120120
    … …  
    140140/*
    141141    TBD..
    142     cgDestroyParameter(m_vel_tex_param_render_vel);
    143     cgDestroyParameter(m_plane_normal_param_render_vel);
    144     cgDestroyParameter(m_max_param);
     142    cgDestroyParameter(_vel_tex_param_render_vel);
     143    cgDestroyParameter(_plane_normal_param_render_vel);
     144    cgDestroyParameter(_max_param);
    145145*/
    146     cgDestroyProgram(m_render_vel_fprog);
     146    cgDestroyProgram(_render_vel_fprog);
    147147
    148148    delete [] slice_vector;
    … …  
    194194    TRACE("finish make_patterns\n");
    195195}
    196 
    197196
    198197void NvLIC::make_magnitudes()
    … …  
    248247    glEnable(GL_TEXTURE_3D);
    249248    glBindTexture(GL_TEXTURE_3D, _vectorFieldId);
    250     cgGLBindProgram(m_render_vel_fprog);
    251 
    252     cgGLSetTextureParameter(m_vel_tex_param_render_vel, _vectorFieldId);
    253     cgGLEnableTextureParameter(m_vel_tex_param_render_vel);
    254     cgGLSetParameter4f(m_plane_normal_param_render_vel, 1., 1., 0., 0);
    255     cgGLSetParameter1f(m_max_param, max);
     249    cgGLBindProgram(_render_vel_fprog);
     250
     251    cgGLSetTextureParameter(_vel_tex_param_render_vel, _vectorFieldId);
     252    cgGLEnableTextureParameter(_vel_tex_param_render_vel);
     253    cgGLSetParameter4f(_plane_normal_param_render_vel, 1., 1., 0., 0);
     254    cgGLSetParameter1f(_max_param, max);
    256255
    257256    cgGLEnableProfile(CG_PROFILE_FP30);
    … …  
    286285    cgGLDisableProfile(CG_PROFILE_FP30);
    287286   
    288     cgGLDisableTextureParameter(m_vel_tex_param_render_vel);
     287    cgGLDisableTextureParameter(_vel_tex_param_render_vel);
    289288
    290289    glBindTexture(GL_TEXTURE_3D, 0);
    … …  
    412411}
    413412
    414 void NvLIC::render(){ display(); }
    415 
     413void NvLIC::render()
     414{
     415    display();
     416}
    416417
    417418void

  • trunk/packages/vizservers/nanovis/NvLIC.h

    r2798 r2837  
    1414 * ======================================================================
    1515 */
     16#ifndef NV_LIC_H
     17#define NV_LIC_H
    1618
    17 
    18 #ifndef _NV_LIC_H_
    19 #define _NV_LIC_H_
    20 
    21 #include "GL/glew.h"
    22 #include "Cg/cgGL.h"
     19#include <GL/glew.h>
     20#include <Cg/cgGL.h>
    2321
    2422#include "define.h"
    … …  
    3634#define SCALE 3.0 //scale for background pattern. small value -> fine texture
    3735
    38 class NvLIC : public Renderable {
     36class NvLIC : public Renderable
     37{
     38public:
     39    NvLIC(int _size, int _width, int _height, int axis,
     40          const Vector3& _offset, CGcontext _context);
     41    ~NvLIC();
     42
     43    /// project 3D vectors to a 2D slice for line integral convolution
     44    void convolve();
     45
     46    /// Display the convolution result
     47    void display();
     48
     49    void render();
     50
     51    void make_patterns();
     52
     53    void make_magnitudes();
     54
     55    void get_velocity(float x, float y, float *px, float *py);
     56
     57    void get_slice();
     58
     59    void set_offset(float v);
     60
     61    /**
     62     * @brief Specify the perdicular axis
     63     *
     64     * 0 : x axis<br>
     65     * 1 : y axis<br>
     66     * 2 : z axis<br>
     67     */
     68    void set_axis(int axis);
     69
     70    void setVectorField(unsigned int texID, const Vector3& ori,
     71                        float scaleX, float scaleY, float scaleZ, float max);
     72
     73    void reset();
     74
     75    void visible(bool state)
     76    {
     77        _isHidden = !state;
     78    }
     79
     80    bool visible() const
     81    {
     82        return (!_isHidden);
     83    }
     84
     85    void active(bool state)
     86    {
     87        _activate = state;
     88    }
     89
     90    bool active() const
     91    {
     92        return _activate;
     93    }
    3994
    4095private:
     96    /**
     97     * @brief the normal vector of the NvLIC plane,
     98     * the inherited Vector3 location is its center
     99     */
     100    Vector3 normal;
     101
    41102    GLuint disListID;
    42103
    … …  
    44105    int size;                           // The lic is a square of size, it can
    45106                                        // be stretched
    46     float* slice_vector;                // Storage for the per slice vectors
     107    float *slice_vector;                // Storage for the per slice vectors
    47108                                        // driving the follow.
    48109    Vector3 scale;                      // Scaling factor stretching the lic
    … …  
    61122    float dmax;
    62123    float max;
    63    
     124
    64125    //CG shader parameters
    65     CGcontext m_g_context;
    66     CGparameter m_vel_tex_param;
    67     CGparameter m_vel_tex_param_render_vel, m_plane_normal_param_render_vel;
    68     CGprogram m_render_vel_fprog;
    69     CGparameter m_max_param;
    70    
     126    CGcontext _g_context;
     127    CGparameter _vel_tex_param;
     128    CGparameter _vel_tex_param_render_vel;
     129    CGparameter _plane_normal_param_render_vel;
     130    CGprogram _render_vel_fprog;
     131    CGparameter _max_param;
     132 
    71133    GLuint color_tex, pattern_tex, mag_tex;
    72134    GLuint fbo, vel_fbo, slice_vector_tex;  // For projecting 3d vector to 2d
    … …  
    74136    GLuint _vectorFieldId;
    75137
    76     Volume* _vectorField;
     138    Volume *_vectorField;
    77139    /**
    78140     * flag for rendering
    … …  
    80142    bool _activate;
    81143    bool _isHidden;                     // Indicates if LIC plane is displayed.
    82 public:
    83     Vector3 normal; //the normal vector of the NvLIC plane,
    84     //the inherited Vector3 location is its center
    85     NvLIC(int _size, int _width, int _height, int axis,
    86           const Vector3& _offset, CGcontext _context);
    87     ~NvLIC();
    88 
    89     /**
    90      * @brief project 3D vectors to a 2D slice for line integral convolution
    91      */
    92     void convolve();
    93 
    94     void display(void);                 // Display the convolution result
    95     void render(void);
    96     void make_patterns();
    97     void make_magnitudes();
    98     void get_velocity(float x, float y, float* px, float* py);
    99     void get_slice();
    100     void set_offset(float v);
    101     /**
    102      * @brief Specify the perdicular axis
    103      * @brief 0 : x axis
    104      * @brief 1 : y axis
    105      * @brief 2 : z axis
    106      */
    107     void set_axis(int axis);
    108 
    109     void setVectorField(unsigned int texID, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max);
    110 
    111     void reset(void);
    112     void visible(bool state) {
    113         _isHidden = !state;
    114     }
    115     bool visible(void) {
    116         return (!_isHidden);
    117     }
    118     void active(bool state) {
    119         _activate = state;
    120     }
    121     bool active(void) {
    122         return _activate;
    123     }
    124144};
    125145
    126 
    127146#endif

  • trunk/packages/vizservers/nanovis/NvParticleAdvectionShader.cpp

    r2831 r2837  
    2323{
    2424    _cgFP = LoadCgSourceProgram(g_context, "update_pos.cg", CG_PROFILE_FP30,
    25         "main");
     25                                "main");
    2626    _posTimestepParam  = cgGetNamedParameter(_cgFP, "timestep");
    2727    _maxParam          = cgGetNamedParameter(_cgFP, "max");
    2828    _velTexParam       = cgGetNamedParameter(_cgFP, "vel_tex");
    2929    _posTexParam       = cgGetNamedParameter(_cgFP, "pos_tex");
    30     //_tfTexParam      = cgGetNamedParameter(_cgFP, "tf_tex");
    3130    _initPosTexParam   = cgGetNamedParameter(_cgFP, "init_pos_tex");
    3231    _scaleParam        = cgGetNamedParameter(_cgFP, "scale");
    3332    _modeParam         = cgGetNamedParameter(_cgFP, "mode");
    3433}
    35 
    36 //void NvParticleAdvectionShader::bind(unsigned int texID, unsigned int tfTexID, unsigned int initPosTexID)
    3734
    3835void
    … …  
    4744    cgGLEnableTextureParameter(_velTexParam);
    4845
    49     //cgGLSetTextureParameter(_tfTexParam, tfTexID);
    50     //cgGLEnableTextureParameter(_tfTexParam);
    51 
    5246    cgGLSetTextureParameter(_posTexParam, texID);
    5347    cgGLEnableTextureParameter(_posTexParam);
    … …  
    5852    cgGLEnableProfile(CG_PROFILE_FP30);
    5953}
     54
     55void
     56NvParticleAdvectionShader::unbind()
     57{
     58     cgGLDisableProfile(CG_PROFILE_FP30);
     59   
     60     cgGLDisableTextureParameter(_velTexParam);
     61     cgGLDisableTextureParameter(_posTexParam);
     62     cgGLDisableTextureParameter(_initPosTexParam);
     63}

  • trunk/packages/vizservers/nanovis/NvParticleAdvectionShader.h

    r2798 r2837  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
    2 #ifndef __NV_PARTICLE_ADV_SHADER_H__
    3 #define __NV_PARTICLE_ADV_SHADER_H__
     2#ifndef NV_PARTICLE_ADV_SHADER_H
     3#define NV_PARTICLE_ADV_SHADER_H
    44
    55#include "Vector3.h"
    66#include "NvShader.h"
    77
    8 class NvParticleAdvectionShader : public NvShader {
     8class NvParticleAdvectionShader : public NvShader
     9{
     10public :
     11    NvParticleAdvectionShader();
     12
     13    virtual ~NvParticleAdvectionShader();
     14
     15    void bind(unsigned int texID, unsigned int initPosTexID);
     16
     17    void unbind();
     18
     19    void setScale(const Vector3& scale)
     20    {
     21        _scale = scale;
     22    }
     23
     24    void setVelocityVolume(unsigned int texID, float max)
     25    {
     26        _velocityVolumeID = texID;
     27        _max = max;
     28    }
     29
     30    void setTimeStep(float timeStep)
     31    {
     32        _timeStep = timeStep;
     33    }
     34
     35    void setRenderMode(int mode)
     36    {
     37        _mode = mode;
     38    }
     39
     40private :
     41    void init();
    942
    1043    CGparameter _posTimestepParam;
    1144    CGparameter _velTexParam;
    12     //CGparameter _tfTexParam;
    1345    CGparameter _posTexParam;
    1446    CGparameter _initPosTexParam;
    … …  
    2052    float _max;
    2153    float _timeStep;
    22 
    2354    int _mode;
    24 
    25 public :
    26     NvParticleAdvectionShader();
    27     ~NvParticleAdvectionShader();
    28 
    29 private :
    30     void init();
    31 public :
    32     //void bind(unsigned int texID, unsigned int tfTexID, unsigned int initPosTexID);
    33     void bind(unsigned int texID, unsigned int initPosTexID);
    34     void unbind();
    35     void setScale(const Vector3& scale);
    36     void setVelocityVolume(unsigned int texID, float max);
    37     void setTimeStep(float timeStep);
    38     void setRenderMode(int mode);
    3955};
    4056
    41 inline void NvParticleAdvectionShader::setTimeStep(float timeStep)
    42 {
    43     _timeStep = timeStep;
    44 }
    45 
    46 inline void NvParticleAdvectionShader::unbind()
    47 {
    48      cgGLDisableProfile(CG_PROFILE_FP30);
    49    
    50      cgGLDisableTextureParameter(_velTexParam);
    51      cgGLDisableTextureParameter(_posTexParam);
    52      //cgGLDisableTextureParameter(_tfTexParam);
    53      cgGLDisableTextureParameter(_initPosTexParam);
    54 }
    55 
    56 inline void NvParticleAdvectionShader::setScale(const Vector3& scale)
    57 {
    58     _scale = scale;
    59 }
    60 
    61 inline void NvParticleAdvectionShader::setVelocityVolume(unsigned int texID, float max)
    62 {
    63     _velocityVolumeID = texID;
    64     _max = max;
    65 }
    66 
    67 inline void NvParticleAdvectionShader::setRenderMode(int mode)
    68 {
    69     _mode = mode;
    70 }
    71 
    72 #endif //__NV_PARTICLE_ADV_SHADER_H__
     57#endif

  • trunk/packages/vizservers/nanovis/NvParticleRenderer.cpp

    r2835 r2837  
    2828#define NV_32
    2929
    30 NvParticleAdvectionShader* NvParticleRenderer::_advectionShader = NULL;
    31 
    32 class NvParticleAdvectionShaderInstance {
     30NvParticleAdvectionShader *NvParticleRenderer::_advectionShader = NULL;
     31
     32class NvParticleAdvectionShaderInstance
     33{
    3334public :
    34     NvParticleAdvectionShaderInstance() {
    35     }
    36     ~NvParticleAdvectionShaderInstance() {
     35    NvParticleAdvectionShaderInstance()
     36    {}
     37
     38    ~NvParticleAdvectionShaderInstance()
     39    {
    3740        if (NvParticleRenderer::_advectionShader) {
    3841            delete NvParticleRenderer::_advectionShader;
    … …  
    4043    }
    4144};
     45
    4246NvParticleAdvectionShaderInstance shaderInstance;
    4347
    … …  
    6468    memset(data, 0, sizeof(Particle) * w * h);
    6569
    66     m_vertex_array = new RenderVertexArray(psys_width*psys_height, 3, GL_FLOAT);
     70    _vertex_array = new RenderVertexArray(psys_width*psys_height, 3, GL_FLOAT);
    6771
    6872    assert(CheckGL(AT));
    … …  
    119123    CHECK_FRAMEBUFFER_STATUS();
    120124
    121     //load related shaders
    122     /*
    123       m_g_context = context;
    124 
    125       m_pos_fprog = LoadCgSourceProgram(m_g_context, "update_pos.cg",
    126         CG_PROFILE_FP30, NULL);
    127       m_pos_timestep_param  = cgGetNamedParameter(m_pos_fprog, "timestep");
    128       m_vel_tex_param = cgGetNamedParameter(m_pos_fprog, "vel_tex");
    129       m_pos_tex_param = cgGetNamedParameter(m_pos_fprog, "pos_tex");
    130       m_scale_param = cgGetNamedParameter(m_pos_fprog, "scale");
    131       cgGLSetTextureParameter(m_vel_tex_param, volume);
    132       cgGLSetParameter3f(m_scale_param, scale_x, scale_y, scale_z);
    133     */
    134125    if (_advectionShader == NULL) {
    135126        _advectionShader = new NvParticleAdvectionShader();
    … …  
    149140    glDeleteFramebuffersEXT(2, psys_fbo);
    150141
    151     delete m_vertex_array;
     142    delete _vertex_array;
    152143    delete [] data;
    153144}
    … …  
    280271        _advectionShader->bind(psys_tex[0], initPosTex);
    281272       
    282         //cgGLBindProgram(m_pos_fprog);
    283         //cgGLSetParameter1f(m_pos_timestep_param, 0.05);
    284         //cgGLEnableTextureParameter(m_vel_tex_param);
    285         //cgGLSetTextureParameter(m_pos_tex_param, psys_tex[0]);
    286         //cgGLEnableTextureParameter(m_pos_tex_param);
    287         //cgGLEnableProfile(CG_PROFILE_FP30);
    288        
    289273        draw_quad(psys_width, psys_height, psys_width, psys_height);
    290        
    291         //cgGLDisableProfile(CG_PROFILE_FP30);
    292         //cgGLDisableTextureParameter(m_vel_tex_param);
    293         //cgGLDisableTextureParameter(m_pos_tex_param);
     274
    294275        glDisable(GL_TEXTURE_RECTANGLE_NV);
    295276    } else {
    … …  
    310291        _advectionShader->bind(psys_tex[1], initPosTex);
    311292       
    312         //cgGLBindProgram(m_pos_fprog);
    313         //cgGLSetParameter1f(m_pos_timestep_param, 0.05);
    314         //cgGLEnableTextureParameter(m_vel_tex_param);
    315         //cgGLSetTextureParameter(m_pos_tex_param, psys_tex[1]);
    316         //cgGLEnableTextureParameter(m_pos_tex_param);
    317         //cgGLEnableProfile(CG_PROFILE_FP30);
    318        
    319293        draw_quad(psys_width, psys_height, psys_width, psys_height);
    320         //draw_quad(psys_width, psys_height, 1.0f, 1.0f);
    321        
    322         //cgGLDisableProfile(CG_PROFILE_FP30);
    323         //cgGLDisableTextureParameter(m_vel_tex_param);
    324         //cgGLDisableTextureParameter(m_pos_tex_param);
    325     }
    326    
     294    }
     295
    327296    _advectionShader->unbind();
    328    
    329     //soft_read_verts();
    330    
     297
    331298    update_vertex_buffer();
    332    
     299
    333300    flip = (!flip);
    334    
     301
    335302    psys_frame++;
    336     if (psys_frame==max_life) {
     303    if (psys_frame == max_life) {
    337304        psys_frame=0;
    338305//      reborn = true;
    … …  
    344311NvParticleRenderer::update_vertex_buffer()
    345312{
    346     m_vertex_array->Read(psys_width, psys_height);
    347 
    348     //m_vertex_array->LoadData(vert);     //does not work??
     313    _vertex_array->Read(psys_width, psys_height);
     314
     315    //_vertex_array->LoadData(vert);     //does not work??
    349316    //assert(glGetError()==0);
    350317}
    … …  
    448415    glColor4f(_color.x, _color.y, _color.z, _color.w);
    449416    glEnableClientState(GL_VERTEX_ARRAY);
    450     m_vertex_array->SetPointer(0);
     417    _vertex_array->SetPointer(0);
    451418    glDrawArrays(GL_POINTS, 0, psys_width*psys_height);
    452419    glDisableClientState(GL_VERTEX_ARRAY);

  • trunk/packages/vizservers/nanovis/NvParticleRenderer.h

    r2798 r2837  
    1414 * ======================================================================
    1515 */
     16#ifndef NV_PARTICLE_SYSTEM_H
     17#define NV_PARTICLE_SYSTEM_H
    1618
     19#include <vector>
    1720
    18 #ifndef _NV_PARTICLE_SYSTEM_H_
    19 #define _NV_PARTICLE_SYSTEM_H_
    20 
    21 #include "GL/glew.h"
    22 #include "Cg/cgGL.h"
     21#include <GL/glew.h>
     22#include <Cg/cgGL.h>
    2323
    2424#include "define.h"
    … …  
    2929#include "RenderVertexArray.h"
    3030#include "Vector3.h"
    31 
    32 #include <vector>
    33 
    3431#include "NvParticleAdvectionShader.h"
    3532
    … …  
    4037    float aux;
    4138
    42     Particle(){};
     39    Particle()
     40    {}
     41
    4342    Particle(float _x, float _y, float _z, float _life) :
    44         x(_x), y(_y), z(_z), aux(_life){}
     43        x(_x), y(_y), z(_z), aux(_life)
     44    {}
    4545};
    4646
    47 class NvParticleRenderer : public Renderable {
    48 public :
    49     /**
    50      * @brief frame buffer objects: two are defined, flip them as input output every step
    51      */
     47class NvParticleRenderer : public Renderable
     48{
     49public:
     50    NvParticleRenderer(int w, int h, CGcontext context);
     51
     52    ~NvParticleRenderer();
     53
     54    void setVectorField(unsigned int texID, const Vector3& ori,
     55                        float scaleX, float scaleY, float scaleZ, float max);
     56
     57    void initialize();
     58
     59    void advect();
     60
     61    void update_vertex_buffer();
     62
     63    void display_vertices();
     64
     65    void reset();
     66
     67    void render();
     68
     69    bool active() const
     70    {
     71        return _activate;
     72    }
     73
     74    void active(bool state)
     75    {
     76        _activate = state;
     77    }
     78
     79    void setColor(const Vector4& color)
     80    {
     81        _color = color;
     82    }
     83
     84    void setAxis(int axis);
     85
     86    void setPos(float pos);
     87
     88    void draw_bounding_box(float x0, float y0, float z0,
     89                           float x1, float y1, float z1,
     90                           float r, float g, float b, float line_width);
     91
     92    void initializeDataArray();
     93
     94    void particleSize(float size)
     95    {
     96        _particleSize = size;
     97    }
     98
     99    float particleSize() const
     100    {
     101        return _particleSize;
     102    }
     103
     104   static NvParticleAdvectionShader *_advectionShader;
     105
     106private:
     107    /// frame buffer objects: two are defined, flip them as input output every step
    52108    GLuint psys_fbo[2];         
    53109
    54     /**
    55      * @brief color textures attached to frame buffer objects
    56      */
     110    /// color textures attached to frame buffer objects
    57111    GLuint psys_tex[2];
    58112    GLuint initPosTex; 
    59     Particle* data;
    60    
    61     /**
    62      *@brief Count the frame number of particle system iteration
    63      */
     113    Particle *data;
     114
     115    /// Count the frame number of particle system iteration
    64116    int psys_frame;         
    65    
    66     /**
    67      * @brief Reinitiate particles     
    68      */
     117
     118    /// Reinitiate particles
    69119    bool reborn;                       
    70120
    71     /**
    72      * @brief flip the source and destination render targets
    73      */
     121    /// flip the source and destination render targets
    74122    bool flip;                 
    75123
    76124    float max_life;
    77125
    78     float _particleSize;                // Size of the particle: default is 1.2
     126    /// Size of the particle: default is 1.2
     127    float _particleSize;
    79128
    80     /**
    81      * @brief vertex array for display particles
    82      */
    83     RenderVertexArray* m_vertex_array; 
     129    /// vertex array for display particles
     130    RenderVertexArray *_vertex_array;   
    84131
    85     //Nvidia CG shaders and their parameters
    86     /*
    87       CGcontext m_g_context;
    88       CGprogram m_pos_fprog;
    89       CGparameter m_vel_tex_param, m_pos_tex_param, m_scale_param;
    90       CGparameter m_pos_timestep_param, m_pos_spherePos_param;
    91     */
    92     static NvParticleAdvectionShader* _advectionShader;
    93 
    94     /**
    95      * @brief scale of flow data
    96      */
     132    /// scale of flow data
    97133    Vector3 scale;
    98134
    … …  
    103139    float _slice_pos;
    104140    int _slice_axis;
     141
    105142    Vector4 _color;
    106143
    107 public:
    108     int psys_width;     //the storage of particles is implemented as a 2D array.
     144    //the storage of particles is implemented as a 2D array.
     145    int psys_width;
    109146    int psys_height;
    110 
    111     NvParticleRenderer(int w, int h, CGcontext context);
    112     ~NvParticleRenderer();
    113     void setVectorField(unsigned int texID, const Vector3& ori, float scaleX, float scaleY, float scaleZ, float max);
    114     void initialize();
    115     void advect();
    116     void update_vertex_buffer();
    117     void display_vertices();
    118     void reset();
    119     void render();
    120 
    121     bool active(void) {
    122         return _activate;
    123     }
    124     void active(bool state) {
    125         _activate = state;
    126     }
    127     void setColor(const Vector4& color) {
    128         _color = color;
    129     }
    130     void setAxis(int axis);
    131     void setPos(float pos);
    132     void draw_bounding_box(float x0, float y0, float z0,
    133                            float x1, float y1, float z1,
    134                            float r, float g, float b, float line_width);
    135     void initializeDataArray();
    136     void particleSize(float size) {
    137         _particleSize = size;
    138     }
    139     float particleSize(void) {
    140         return _particleSize;
    141     }
    142147};
    143148

  • trunk/packages/vizservers/nanovis/NvRegularVolumeShader.cpp

    r2831 r2837  
    1515{
    1616    _cgFP = LoadCgSourceProgram(g_context, "one_volume.cg", CG_PROFILE_FP30,
    17         "main");
    18     m_mvi_one_volume_param = cgGetNamedParameter(_cgFP, "modelViewInv");
    19     m_mv_one_volume_param = cgGetNamedParameter(_cgFP, "modelView");
     17                                "main");
     18    _mvi_one_volume_param = cgGetNamedParameter(_cgFP, "modelViewInv");
     19    _mv_one_volume_param = cgGetNamedParameter(_cgFP, "modelView");
    2020
    21     m_vol_one_volume_param = cgGetNamedParameter(_cgFP, "volume");
    22     m_tf_one_volume_param = cgGetNamedParameter(_cgFP, "tf");
    23     m_render_param_one_volume_param = cgGetNamedParameter(_cgFP, "renderParameters");
    24     m_option_one_volume_param = cgGetNamedParameter(_cgFP, "options");
     21    _vol_one_volume_param = cgGetNamedParameter(_cgFP, "volume");
     22    _tf_one_volume_param = cgGetNamedParameter(_cgFP, "tf");
     23    _render_param_one_volume_param = cgGetNamedParameter(_cgFP, "renderParameters");
     24    _option_one_volume_param = cgGetNamedParameter(_cgFP, "options");
    2525}
    2626

  • trunk/packages/vizservers/nanovis/NvRegularVolumeShader.h

    r2798 r2837  
    66#include "NvVolumeShader.h"
    77
    8 class NvRegularVolumeShader : public NvVolumeShader {
    9     CGparameter m_vol_one_volume_param;
    10     CGparameter m_tf_one_volume_param;
    11     CGparameter m_mvi_one_volume_param;
    12     CGparameter m_mv_one_volume_param;
    13     CGparameter m_render_param_one_volume_param;
    14     CGparameter m_option_one_volume_param;
    15 
    16 public :
     8class NvRegularVolumeShader : public NvVolumeShader
     9{
     10public:
    1711    NvRegularVolumeShader();
    1812    ~NvRegularVolumeShader();
    19 private :
    20     void init();
    2113
    22 public :
    2314    void bind(unsigned int tfID, Volume* volume, int sliceMode);
    2415    void unbind();
    2516
     17private:
     18    void init();
     19
     20    CGparameter _vol_one_volume_param;
     21    CGparameter _tf_one_volume_param;
     22    CGparameter _mvi_one_volume_param;
     23    CGparameter _mv_one_volume_param;
     24    CGparameter _render_param_one_volume_param;
     25    CGparameter _option_one_volume_param;
    2626};
    2727
    … …  
    3030{
    3131    //regular cubic volume
    32     cgGLSetStateMatrixParameter(m_mvi_one_volume_param, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE);
    33     cgGLSetStateMatrixParameter(m_mv_one_volume_param, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
     32    cgGLSetStateMatrixParameter(_mvi_one_volume_param, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE);
     33    cgGLSetStateMatrixParameter(_mv_one_volume_param, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
    3434
    35     cgGLSetTextureParameter(m_vol_one_volume_param, volume->id);
    36     cgGLSetTextureParameter(m_tf_one_volume_param, tfID);
    37     cgGLEnableTextureParameter(m_vol_one_volume_param);
    38     cgGLEnableTextureParameter(m_tf_one_volume_param);
     35    cgGLSetTextureParameter(_vol_one_volume_param, volume->id);
     36    cgGLSetTextureParameter(_tf_one_volume_param, tfID);
     37    cgGLEnableTextureParameter(_vol_one_volume_param);
     38    cgGLEnableTextureParameter(_tf_one_volume_param);
    3939
    4040    if(!sliceMode)
    41         cgGLSetParameter4f(m_render_param_one_volume_param,
     41        cgGLSetParameter4f(_render_param_one_volume_param,
    4242            volume->n_slices(),
    4343            volume->opacity_scale(),
    … …  
    4545            volume->specular());
    4646    else
    47         cgGLSetParameter4f(m_render_param_one_volume_param,
     47        cgGLSetParameter4f(_render_param_one_volume_param,
    4848            0.,
    4949            volume->opacity_scale(),
    … …  
    5151            volume->specular());
    5252
    53     cgGLSetParameter4f(m_option_one_volume_param,
     53    cgGLSetParameter4f(_option_one_volume_param,
    5454        0.0f,
    5555        volume->isosurface(),
    … …  
    6363inline void NvRegularVolumeShader::unbind()
    6464{
    65     cgGLDisableTextureParameter(m_vol_one_volume_param);
    66     cgGLDisableTextureParameter(m_tf_one_volume_param);
     65    cgGLDisableTextureParameter(_vol_one_volume_param);
     66    cgGLDisableTextureParameter(_tf_one_volume_param);
    6767
    6868    cgGLDisableProfile(CG_PROFILE_FP30);
    6969}
    7070
    71 
    72 #endif //
     71#endif

  • trunk/packages/vizservers/nanovis/NvShader.h

    r2833 r2837  
    3636            return cgGetNamedParameter(_cgFP, paramName);
    3737        }
    38 
    3938        return 0;
    4039    }
    … …  
    4544            return cgGetNamedParameter(_cgVP, paramName);
    4645        }
    47 
    4846        return 0;
    4947    }

  • trunk/packages/vizservers/nanovis/RenderVertexArray.cpp

    r2800 r2837  
    3535 * ======================================================================
    3636 */
     37#include <stdio.h>
     38
     39#include <GL/glew.h>
     40#include <GL/gl.h>
     41
    3742#include "RenderVertexArray.h"
    3843#include "Trace.h"
    39 #include <GL/gl.h>
    40 #include <stdio.h>
    4144
    4245RenderVertexArray::RenderVertexArray(int nverts, GLint size, GLenum type) :
    43     m_usage(GL_STREAM_COPY),
    44     m_nverts(nverts),
    45     m_size(size),
    46     m_type(type)
     46    _usage(GL_STREAM_COPY),
     47    _nverts(nverts),
     48    _size(size),
     49    _type(type)
    4750{
    48     switch(m_type) {
     51    switch (_type) {
    4952    case GL_HALF_FLOAT_NV:
    50         m_bytes_per_component = 2; break;
     53        _bytes_per_component = 2; break;
    5154    case GL_FLOAT:
    52         m_bytes_per_component = sizeof(float); break;
     55        _bytes_per_component = sizeof(float); break;
    5356    default:
    5457        ERROR("unsupported RenderVertexArray type\n");
    … …  
    5760
    5861    // create the buffer object
    59     glGenBuffersARB(1, &m_buffer);
    60     glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, m_buffer);
     62    glGenBuffersARB(1, &_buffer);
     63    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, _buffer);
    6164    glBufferDataARB(GL_PIXEL_PACK_BUFFER_EXT,
    62         m_nverts*m_size*m_bytes_per_component, 0, m_usage); // undefined data
     65        _nverts*_size*_bytes_per_component, 0, _usage); // undefined data
    6366    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
    6467
    6568    // set equivalent image format
    66     switch(m_size) {
     69    switch(_size) {
    6770    case 1:
    68         m_format = GL_LUMINANCE; break;
     71        _format = GL_LUMINANCE; break;
    6972    case 3:
    70         m_format = GL_RGB; break;
     73        _format = GL_RGB; break;
    7174    case 4:
    72         m_format = GL_RGBA; break;
     75        _format = GL_RGBA; break;
    7376    default:
    7477        ERROR("unsupported RenderVertexArray size\n");
    … …  
    7982RenderVertexArray::~RenderVertexArray()
    8083{
    81     glDeleteBuffersARB(1, &m_buffer);
     84    glDeleteBuffersARB(1, &_buffer);
    8285}
    8386
    … …  
    8689{
    8790    // load data to buffer object
    88     glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, m_buffer);
     91    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, _buffer);
    8992    glBufferDataARB(GL_PIXEL_PACK_BUFFER_EXT,
    90                     m_nverts*m_size*m_bytes_per_component, data, m_usage);
     93                    _nverts*_size*_bytes_per_component, data, _usage);
    9194    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
    9295}
    … …  
    9699{
    97100    // bind buffer object to pixel pack buffer
    98     glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, m_buffer);
     101    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, _buffer);
    99102    // read from frame buffer to buffer object
    100103    //glReadBuffer(buffer); //crash
    101     glReadPixels(0, 0, w, h, m_format, m_type, 0);
     104    glReadPixels(0, 0, w, h, _format, _type, 0);
    102105
    103106    glBindBufferARB(GL_PIXEL_PACK_BUFFER_EXT, 0);
    … …  
    108111{
    109112    // bind buffer object to vertex array
    110     glBindBufferARB(GL_ARRAY_BUFFER, m_buffer);
    111     //glVertexAttribPointerARB(index, m_size, m_type, GL_FALSE, 0, 0);          //doesn't work
    112     glVertexPointer(m_size, m_type, 0, 0);
     113    glBindBufferARB(GL_ARRAY_BUFFER, _buffer);
     114    //glVertexAttribPointerARB(index, _size, _type, GL_FALSE, 0, 0);          //doesn't work
     115    glVertexPointer(_size, _type, 0, 0);
    113116
    114117    glBindBufferARB(GL_ARRAY_BUFFER, 0);

  • trunk/packages/vizservers/nanovis/RenderVertexArray.h

    r2798 r2837  
    2020#include <GL/gl.h>
    2121
    22 class RenderVertexArray {
    23     GLenum m_usage;     // vbo usage flag
    24     GLuint m_buffer;
    25     GLuint m_index;
    26     GLuint m_nverts;
    27     GLint m_size;       // size of attribute       
    28     GLenum m_format;    // readpixels image format
    29     GLenum m_type;      // FLOAT or HALF_FLOAT
    30     int m_bytes_per_component;
    31 
     22class RenderVertexArray
     23{
    3224public:
    3325    RenderVertexArray(int nverts, GLint size, GLenum type = GL_FLOAT);
     26
    3427    ~RenderVertexArray();
    3528
    3629    void LoadData(void *data);  // load vertex data from memory
     30
    3731    void Read(/*GLenum buffer,*/ int w, int h);   // read vertex data from
    3832                                                  // frame buffer
    3933    void SetPointer(GLuint index);
     34
     35private:
     36    GLenum _usage;     // vbo usage flag
     37    GLuint _buffer;
     38    GLuint _index;
     39    GLuint _nverts;
     40    GLint _size;       // size of attribute       
     41    GLenum _format;    // readpixels image format
     42    GLenum _type;      // FLOAT or HALF_FLOAT
     43    int _bytes_per_component;
    4044};
    4145

  • trunk/packages/vizservers/nanovis/Renderable.cpp

    r2798 r2837  
    1414 * ======================================================================
    1515 */
    16 
    17 
    1816#include "Renderable.h"
    1917
    20 Renderable::Renderable(){}
    21 Renderable::Renderable(Vector3 loc):
     18Renderable::Renderable()
     19{
     20}
     21
     22Renderable::Renderable(const Vector3& loc) :
    2223    location(loc),
    2324    enabled(true)
    … …  
    2526}
    2627
    27 Renderable::~Renderable(){}
    28  
    29 void Renderable::move(Vector3 new_loc) { location = new_loc; }
     28Renderable::~Renderable()
     29{}
    3030
    31 void Renderable::enable() { enabled = true; }
    32 void Renderable::disable() { enabled = false; }
    33 bool Renderable::is_enabled() { return enabled; }
     31void Renderable::move(const Vector3& new_loc)
     32{
     33    location = new_loc;
     34}
    3435
     36void Renderable::enable()
     37{
     38    enabled = true;
     39}
     40
     41void Renderable::disable()
     42{
     43    enabled = false;
     44}
     45
     46bool Renderable::is_enabled() const
     47{
     48    return enabled;
     49}
     50

  • trunk/packages/vizservers/nanovis/Renderable.h

    r2798 r2837  
    1414 * ======================================================================
    1515 */
    16 
    17 
    18 #ifndef _RENDERABLE_H_
    19 #define _RENDERABLE_H_
    20 
     16#ifndef RENDERABLE_H
     17#define RENDERABLE_H
    2118
    2219#include "Vector3.h"
    2320
    24 struct BoundBox{
    25   Vector3 low; //lower coordinates
    26   Vector3 high; //higher coordinates
     21struct BoundBox {
     22    Vector3 low; //lower coordinates
     23    Vector3 high; //higher coordinates
    2724
    28   BoundBox(){}
    29   BoundBox(float low_x, float low_y, float low_z,
    30           float high_x, float high_y, float high_z):
    31           low(Vector3(low_x, low_y, low_z)),
    32           high(Vector3(high_x, high_y, high_z)){}
     25    BoundBox()
     26    {}
     27
     28    BoundBox(float low_x, float low_y, float low_z,
     29             float high_x, float high_y, float high_z) :
     30        low(low_x, low_y, low_z),
     31        high(high_x, high_y, high_z)
     32    {}
    3333};
    3434
    35 class Renderable{
     35class Renderable
     36{
     37public:
     38    Renderable(const Vector3& loc);
     39
     40    Renderable();
     41
     42    virtual ~Renderable();
     43
     44    void move(const Vector3& new_loc);
     45
     46    virtual void render() = 0;
     47
     48    void enable();
     49
     50    void disable();
     51
     52    bool is_enabled() const;
     53
    3654protected:
    37   Vector3 location;     //the location (x,y,z) of the object
    38   bool enabled;         //display is enabled
    39   BoundBox boundary;    //the bounding box
    40 
    41 public:
    42   explicit Renderable(Vector3 loc);
    43   Renderable();
    44   virtual ~Renderable();
    45 
    46   void move(Vector3 new_loc);
    47   virtual void render() = 0;
    48   void enable();
    49   void disable();
    50   bool is_enabled();
     55    Vector3 location;   //the location (x,y,z) of the object
     56    bool enabled;       //display is enabled
     57    BoundBox boundary;  //the bounding box
    5158};
    5259
    53 
    5460#endif

  • trunk/packages/vizservers/nanovis/Sphere.h

    r2822 r2837  
    2929{
    3030public:
    31     float radius;
    32     Color color;
    33     int stack;
    34     int slice;
    35 
    3631    Sphere(float x, float y, float z, float r, float g, float b, float _radius,
    3732           int _stack, int _slice);
    … …  
    4540    void draw(GLUquadric* q);
    4641    void render();
     42
     43    float radius;
     44    Color color;
     45    int stack;
     46    int slice;
    4747};
    4848
Note: See TracChangeset for help on using the changeset viewer.