Changeset 2870


Ignore:
Timestamp:
Mar 19, 2012 9:04:34 PM (12 years ago)
Author:
ldelgass
Message:

remove global.h header. Move global Cg context handle into NvShader? as a
static member. Move LoadCgSourceProgram? to NvShader?.cpp, but make shader
classes use the methods NvShader::loadVertex/FragmentProgram instead.
There are still some users of LoadCgSourceProgram? left that need the context
handle.

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

Legend:

Unmodified
Added
Removed

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

    r2844 r2870  
    1818
    1919#include "Color.h"
    20 #include "define.h"
    2120
    2221Color::Color() :

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

    r2823 r2870  
    174174    if (vertices.size() >= 3) {
    175175        for (unsigned int i = 0; i < vertices.size(); i++) {
    176             if(use_texture) {
     176            if (use_texture) {
    177177                glTexCoord4fv((float *)&(texcoords[i]));
    178178                //glTexCoord4fv((float *)&(vertices[i]));

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

    r2844 r2870  
    1414#endif
    1515
    16 #define GRADIENTS_EXT       ".grd"
    1716static int g_numOfSlices[3] = { 256, 256, 256 };
    1817static void *g_volData = 0;
    … …  
    2827#ifdef notused
    2928static char *
    30 getFloatGradientsFilename(void)
     29getFloatGradientsFilename()
    3130{
    3231    char floatExt[] = "_float";
    3332    char *filename;
    34 
    35     /*
    36     if (! (filename = (char *)malloc(strlen(g.basename) +
    37                                      strlen(floatExt) +
    38                                      strlen(GRADIENTS_EXT) + 1))) {
    39                                          */
     33    char extension[] = ".grd";
     34
    4035    if (! (filename = (char *)malloc(strlen("base") +
    4136                                     strlen(floatExt) +
    42                                      strlen(GRADIENTS_EXT) + 1))) {
     37                                     strlen(extension) + 1))) {
    4338        ERROR("not enough memory for filename\n");
    4439        exit(1);
    4540    }
    4641
    47     //strcpy(filename, g.basename);
    4842    strcpy(filename, "base");
    49 
    5043    strcat(filename, floatExt);
    51     strcat(filename, GRADIENTS_EXT);
     44    strcat(filename, extension);
    5245
    5346    return filename;
    … …  
    7265    fclose(fp);
    7366}
     67
     68static void
     69saveGradients(void *gradients, int *sizes, DataType dataType)
     70{
     71    char *filename;
     72    int size;
     73    FILE *fp;
     74
     75    filename = getGradientsFilename();
     76    if (! (fp = fopen(filename, "wb"))) {
     77        perror("cannot open gradients file for writing");
     78        exit(1);
     79    }
     80
     81    size = 3 * sizes[0] * sizes[1] * sizes[2]
     82           * getDataTypeSize(dataType);
     83
     84    if (fwrite(gradients, size, 1, fp) != 1) {
     85        ERROR("writing gradients failed\n");
     86        exit(1);
     87    }
     88
     89    fclose(fp);
     90}
    7491#endif
    7592
    … …  
    104121{
    105122    return ((float*)g_volData)[z * g_numOfSlices[0] * g_numOfSlices[1] +
    106                                        y * g_numOfSlices[0] +
    107                                        x];
     123                               y * g_numOfSlices[0] +
     124                               x];
    108125}
    109126
    … …  
    127144    return 0.0;
    128145}
    129 
    130146
    131147void computeGradients(float *gradients, void* volData, int *sizes, DataType dataType)
    … …  
    425441}
    426442
    427 
    428443void quantize8(float *grad, unsigned char *data)
    429444{
    … …  
    489504                       int *sizes, DataType dataType)
    490505{
    491 
    492506    int idx, idy, idz, di;
    493507
    … …  
    518532    }
    519533}
    520 /*
    521 
    522 void saveGradients(void *gradients, int *sizes, DataType dataType)
    523 {
    524     char *filename;
    525     int size;
    526     FILE *fp;
    527 
    528     filename = getGradientsFilename();
    529     if (! (fp = fopen(filename, "wb"))) {
    530         perror("cannot open gradients file for writing");
    531         exit(1);
    532     }
    533 
    534     size = 3 * sizes[0] * sizes[1] * sizes[2]
    535            * getDataTypeSize(dataType);
    536 
    537     if (fwrite(gradients, size, 1, fp) != 1) {
    538          ERROR("writing gradients failed\n");
    539         exit(1);
    540     }
    541 
    542     fclose(fp);
    543 }
    544 */

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

    r2844 r2870  
    99
    1010#include <GL/glew.h>
    11 #include <GL/gl.h>
     11#include <Cg/cgGL.h>
    1212
    1313#include "Grid.h"

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

    r2831 r2870  
    33#define HEIGHTMAP_H
    44
    5 #include <Cg/cgGL.h>
    65#include <Cg/cg.h>
    76

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

    r2863 r2870  
    2323RM              = rm -f
    2424
    25 AUXSRC          = config.h define.h global.h
     25AUXSRC          = config.h define.h
    2626
    2727CG_INC_SPEC     = @CG_INC_SPEC@
    … …  
    140140                RenderVertexArray.o \
    141141                RpAVTranslate.o \
    142                 ScreenSnapper.o \
    143142                Switch.o \
    144143                Texture1D.o \
    … …  
    162161                ParticleSystem.o \
    163162                ParticleSystemFactory.o \
     163                ScreenSnapper.o \
    164164                Sphere.o
    165165endif
    … …  
    175175resources       = \
    176176                $(srcdir)/resources/Font.bmp \
    177                 $(srcdir)/resources/arrows_flip2.png \
     177                $(srcdir)/resources/arrows.bmp \
    178178                $(srcdir)/resources/arrows_red_bg.bmp \
    179                 $(srcdir)/resources/arrows.bmp \
    180179                $(srcdir)/resources/particle2.bmp \
    181180                $(srcdir)/resources/verdana.fnt \
    … …  
    185184                $(srcdir)/shaders/common.cg \
    186185                $(srcdir)/shaders/copy_texcoord.cg \
     186                $(srcdir)/shaders/distance.cg \
     187                $(srcdir)/shaders/distancesort.cg \
    187188                $(srcdir)/shaders/heightcolor.cg \
     189                $(srcdir)/shaders/mergesort.cg \
     190                $(srcdir)/shaders/moveparticles.cg \
    188191                $(srcdir)/shaders/one_plane.cg \
    189192                $(srcdir)/shaders/one_volume.cg \
    190193                $(srcdir)/shaders/particle_common.cg \
     194                $(srcdir)/shaders/particlefp.cg \
     195                $(srcdir)/shaders/particlevp.cg \
     196                $(srcdir)/shaders/passthrough.cg \
    191197                $(srcdir)/shaders/passthru.cg \
    192198                $(srcdir)/shaders/pointsvp.cg \
    193199                $(srcdir)/shaders/queryvelocity.cg \
     200                $(srcdir)/shaders/renderparticle.cg \
    194201                $(srcdir)/shaders/render_vel.cg \
    195202                $(srcdir)/shaders/update_pos.cg \
    196203                $(srcdir)/shaders/update_pos_vel.cg \
    197204                $(srcdir)/shaders/update_vel.cg \
     205                $(srcdir)/shaders/velocity.cg \
     206                $(srcdir)/shaders/velocityslicefp.cg \
     207                $(srcdir)/shaders/velocityslicevp.cg \
    198208                $(srcdir)/shaders/vertex_std.cg \
    199209                $(srcdir)/shaders/volqd_volume.cg \
    200                 $(srcdir)/shaders/velocityslicevp.cg \
    201                 $(srcdir)/shaders/velocityslicefp.cg \
    202                 $(srcdir)/shaders/zincblende_volume.cg \
    203                 $(srcdir)/shaders/distance.cg \
    204                 $(srcdir)/shaders/distancesort.cg \
    205                 $(srcdir)/shaders/mergesort.cg \
    206                 $(srcdir)/shaders/moveparticles.cg \
    207                 $(srcdir)/shaders/particlefp.cg \
    208                 $(srcdir)/shaders/particlevp.cg \
    209                 $(srcdir)/shaders/passthrough.cg \
    210                 $(srcdir)/shaders/renderparticle.cg \
    211                 $(srcdir)/shaders/velocity.cg
     210                $(srcdir)/shaders/zincblende_volume.cg
     211
    212212
    213213.PHONY: all install install-resources install-shaders install-nanovis clean distclean newmat11 R2 imgloaders vrmath vrutil transfer-function
    … …  
    335335RenderVertexArray.o: RenderVertexArray.cpp RenderVertexArray.h
    336336RpAVTranslate.o: RpAVTranslate.cpp RpAVTranslate.h nvconf.h
    337 ScreenSnapper.o: ScreenSnapper.cpp ScreenSnapper.h define.h
     337ScreenSnapper.o: ScreenSnapper.cpp ScreenSnapper.h
    338338Sphere.o: Sphere.cpp Sphere.h
    339339Switch.o: Switch.cpp Switch.h
    … …  
    349349VolumeRenderer.o: VolumeRenderer.cpp VolumeRenderer.h
    350350ZincBlendeVolume.o: ZincBlendeVolume.cpp ZincBlendeVolume.h $(AUXSRC)
    351 dxReader.o: dxReader.cpp dxReaderCommon.h nanovis.h Unirect.h ZincBlendeVolume.h NvZincBlendeReconstructor.h
     351dxReader.o: dxReader.cpp dxReaderCommon.h config.h nanovis.h Unirect.h ZincBlendeVolume.h NvZincBlendeReconstructor.h
    352352dxReaderCommon.o: dxReaderCommon.cpp dxReaderCommon.h GradientFilter.h Vector3.h
    353353nanovis.o: nanovis.cpp nanovis.h $(AUXSRC) FlowCmd.h Grid.h HeightMap.h NvCamera.h NvColorTableRenderer.h NvEventLog.h NvFlowVisRenderer.h NvLIC.h NvZincBlendeReconstructor.h PerfQuery.h PlaneRenderer.h PointSetRenderer.h PointSet.h RenderContext.h Switch.h Trace.h Unirect.h VelocityArrowsSlice.h VolumeInterpolator.h VolumeRenderer.h ZincBlendeVolume.h

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

    r2859 r2870  
    22#include <R2/R2FilePath.h>
    33
     4#include <GL/glew.h>
     5#include <Cg/cgGL.h>
     6
    47#include "NvColorTableShader.h"
    58#include "Trace.h"
    6 #include "global.h"
    79
    810NvColorTableShader::NvColorTableShader()
    … …  
    1719void NvColorTableShader::init()
    1820{
    19     _cgFP = LoadCgSourceProgram(g_context, "one_plane.cg", CG_PROFILE_FP30,
    20                                 "main");
     21    loadFragmentProgram("one_plane.cg", "main");
    2122    _dataParam = cgGetNamedParameter(_cgFP, "data");
    2223    _tfParam = cgGetNamedParameter(_cgFP, "tf");

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

    r2859 r2870  
    55#include <Cg/cg.h>
    66
     7#include "NvShader.h"
    78#include "Texture2D.h"
    89#include "TransferFunction.h"
    9 #include "NvShader.h"
    1010
    1111class NvColorTableShader : public NvShader

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

    r2836 r2870  
    1010#include <Cg/cgGL.h>
    1111
    12 #include "define.h"
    1312#include "config.h"
    14 #include "global.h"
    1513
    1614#include "Renderable.h"

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

    r2847 r2870  
    2121
    2222#include "NvLIC.h"
     23#include "NvShader.h"
     24#include "define.h"
    2325#include "Trace.h"
    24 #include "global.h"
    2526
    2627#define NPN 256   //resolution of background pattern
    … …  
    4344    dmax(SCALE/NPIX),
    4445    max(1.0f),
    45     _g_context(_context),
     46    _cgContext(_context),
    4647    _vectorFieldId(0),
    4748    _activate(false)
    … …  
    113114
    114115    _render_vel_fprog =
    115         LoadCgSourceProgram(_g_context, "render_vel.cg",
     116        LoadCgSourceProgram(_cgContext, "render_vel.cg",
    116117                            CG_PROFILE_FP30, "main");
    117118

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

    r2847 r2870  
    2020#include <Cg/cgGL.h>
    2121
    22 #include "define.h"
    2322#include "config.h"
    24 #include "global.h"
    2523#include "nanovis.h"
    2624
    … …  
    119117
    120118    //CG shader parameters
    121     CGcontext _g_context;
     119    CGcontext _cgContext;
    122120    CGparameter _vel_tex_param;
    123121    CGparameter _vel_tex_param_render_vel;

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

    r2837 r2870  
    22#include <R2/R2FilePath.h>
    33
     4#include <GL/glew.h>
     5#include <Cg/cgGL.h>
     6
    47#include "NvParticleAdvectionShader.h"
    58#include "Trace.h"
    6 #include "global.h"
    79
    810NvParticleAdvectionShader::NvParticleAdvectionShader() :
    … …  
    2224void NvParticleAdvectionShader::init()
    2325{
    24     _cgFP = LoadCgSourceProgram(g_context, "update_pos.cg", CG_PROFILE_FP30,
    25                                 "main");
     26    loadFragmentProgram("update_pos.cg", "main");
    2627    _posTimestepParam  = cgGetNamedParameter(_cgFP, "timestep");
    2728    _maxParam          = cgGetNamedParameter(_cgFP, "max");

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

    r2863 r2870  
    2424
    2525#include "NvParticleRenderer.h"
     26#include "define.h"
    2627#include "Trace.h"
    2728

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

    r2863 r2870  
    2222#include <Cg/cgGL.h>
    2323
    24 #include "define.h"
    2524#include "config.h"
    26 #include "global.h"
    2725
    2826#include "Renderable.h"

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

    r2859 r2870  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
    22
    3 #include "global.h"
     3#include <GL/glew.h>
     4#include <Cg/cgGL.h>
     5
    46#include "NvRegularVolumeShader.h"
    57
    … …  
    1517void NvRegularVolumeShader::init()
    1618{
    17     _cgFP = LoadCgSourceProgram(g_context, "one_volume.cg", CG_PROFILE_FP30,
    18                                 "main");
     19    loadFragmentProgram("one_volume.cg", "main");
    1920    _mvi_one_volume_param = cgGetNamedParameter(_cgFP, "modelViewInv");
    2021    _mv_one_volume_param = cgGetNamedParameter(_cgFP, "modelView");

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

    r2833 r2870  
    22#include <stdio.h>
    33
    4 #include "global.h"
     4#include <GL/glew.h>
     5#include <Cg/cg.h>
     6#include <Cg/cgGL.h>
     7
     8#include <R2/R2FilePath.h>
     9
    510#include "NvShader.h"
     11#include "Trace.h"
    612
    7 CGcontext g_context = 0;
     13CGcontext NvShader::_cgContext = NULL;
    814
    9 void NvInitCG()
     15void NvShader::initCg()
    1016{
    11     g_context = cgCreateContext();
     17    _cgContext = cgCreateContext();
     18}
     19
     20void NvShader::exitCg()
     21{
     22    setErrorCallback(NULL);
     23    printErrorInfo();
     24    if (_cgContext != NULL) {
     25        cgDestroyContext(_cgContext);
     26        _cgContext = NULL;
     27    }
     28}
     29
     30bool NvShader::printErrorInfo()
     31{
     32    CGerror lastError = cgGetError();
     33
     34    if (lastError) {
     35        TRACE("Cg Error: %s\n", cgGetErrorString(lastError));
     36        if (getCgContext())
     37            TRACE("%s\n", cgGetLastListing(getCgContext()));
     38        return false;
     39    }
     40    return true;
     41}
     42
     43CGprogram
     44LoadCgSourceProgram(CGcontext context, const char *fileName, CGprofile profile,
     45                    const char *entryPoint)
     46{
     47    const char *path = R2FilePath::getInstance()->getPath(fileName);
     48    if (path == NULL) {
     49        ERROR("can't find program \"%s\"\n", fileName);
     50    }
     51    TRACE("cg program compiling: %s\n", path);
     52    CGprogram program;
     53    program = cgCreateProgramFromFile(context, CG_SOURCE, path, profile,
     54                                      entryPoint, NULL);
     55    cgGLLoadProgram(program);
     56    CGerror LastError = cgGetError();
     57    if (LastError) {
     58        ERROR("Error message: %s\n", cgGetLastListing(context));
     59    }
     60    TRACE("successfully compiled program: %s\n", path);
     61    delete [] path;
     62    return program;
    1263}
    1364
    1465NvShader::NvShader():
    15     _cgVP(0),
    16     _cgFP(0)
     66    _cgVP(NULL),
     67    _cgFP(NULL)
    1768{
    1869}
    … …  
    2778    resetPrograms();
    2879
    29     _cgVP = LoadCgSourceProgram(g_context, fileName, CG_PROFILE_VP30, entryPoint);
     80    _cgVP = LoadCgSourceProgram(_cgContext, fileName, CG_PROFILE_VP40, entryPoint);
    3081}
    3182
    3283void NvShader::loadFragmentProgram(const char *fileName, const char *entryPoint)
    3384{
    34     _cgFP = LoadCgSourceProgram(g_context, fileName, CG_PROFILE_FP30, entryPoint);
     85    _cgFP = LoadCgSourceProgram(_cgContext, fileName, CG_PROFILE_FP40, entryPoint);
    3586}
    3687
    3788void NvShader::resetPrograms()
    3889{
    39     if (_cgVP > 0) {
     90    if (_cgVP != NULL) {
    4091        cgDestroyProgram(_cgVP);
    4192    }
    4293
    43     if (_cgFP > 0) {
     94    if (_cgFP != NULL) {
    4495        cgDestroyProgram(_cgFP);
    4596    }
    … …  
    4899void NvShader::setErrorCallback(NvCgCallbackFunction callback)
    49100{
    50     TRACE("NvShader callback\n");
     101    TRACE("NvShader error callback: %p\n", callback);
    51102    cgSetErrorCallback(callback);
    52103}

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

    r2837 r2870  
    44
    55#include <Cg/cg.h>
    6 #include <Cg/cgGL.h>
    76
    8 typedef void NvCgCallbackFunction(void);
    9 
    10 extern CGcontext g_context;
     7extern CGprogram LoadCgSourceProgram(CGcontext context, const char *filename,
     8                                     CGprofile profile, const char *entryPoint);
    119
    1210class NvShader
    1311{
    1412public:
     13    typedef void NvCgCallbackFunction(void);
     14
    1515    NvShader();
    1616
    … …  
    5757    }
    5858
     59    static void initCg();
     60
     61    static void exitCg();
     62
     63    static bool printErrorInfo();
     64
    5965    static void setErrorCallback(NvCgCallbackFunction callback);
    6066
     67    static CGcontext getCgContext()
     68    {
     69        return _cgContext;
     70    }
     71
    6172protected:
     73    void resetPrograms();
     74
    6275    CGprogram _cgVP;
    6376    CGprogram _cgFP;
    6477
    65     void resetPrograms();
     78    static CGcontext _cgContext;
    6679};
    6780

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

    r2859 r2870  
    22#include <stdio.h>
    33
    4 #include "global.h"
     4#include <GL/glew.h>
     5#include <Cg/cgGL.h>
     6
    57#include "NvStdVertexShader.h"
    68
    … …  
    1618void NvStdVertexShader::init()
    1719{
    18     _cgVP = LoadCgSourceProgram(g_context, "vertex_std.cg", CG_PROFILE_VP30,
    19                                 "main");
     20    loadVertexProgram("vertex_std.cg", "main");
    2021    _mvp_vert_std_param = cgGetNamedParameter(_cgVP, "modelViewProjMatrix");
    2122    _mvi_vert_std_param = cgGetNamedParameter(_cgVP, "modelViewInv");

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

    r2859 r2870  
    33#include <string.h>
    44
    5 #include "global.h"
     5#include <GL/glew.h>
     6#include <Cg/cgGL.h>
     7
    68#include "NvZincBlendeVolumeShader.h"
    79
    … …  
    1719void NvZincBlendeVolumeShader::init()
    1820{
    19     _cgFP = LoadCgSourceProgram(g_context, "zincblende_volume.cg",
    20                                 CG_PROFILE_FP30, "main");
     21    loadFragmentProgram("zincblende_volume.cg", "main");
    2122    _tfParam = cgGetNamedParameter(_cgFP, "tf");
    2223    _volumeAParam = cgGetNamedParameter(_cgFP, "volumeA");

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

    r2862 r2870  
    2525#include "Texture2D.h"
    2626#include "Texture3D.h"
     27#include "NvShader.h"
    2728#include "Trace.h"
    2829
    … …  
    422423}
    423424
    424 void ParticleSystem::callbackForCgError()
    425 {
    426     CGerror lastError = cgGetError();
    427     if (lastError) {
    428         const char *listing = cgGetLastListing(_context);
    429         ERROR("\n---------------------------------------------------\n");
    430         ERROR("%s\n\n", cgGetErrorString(lastError));
    431         ERROR("%s\n", listing);
    432         ERROR("-----------------------------------------------------\n");
    433         ERROR("Cg error, exiting...\n");
    434 
    435         cgDestroyContext(_context);
    436         getchar();
    437         exit(-1);
    438     }
    439 }
    440 
    441425void ParticleSystem::initShaders()
    442426{
    443427    // TBD...
    444     _context = cgCreateContext();
    445     cgSetErrorCallback(callbackForCgError);
     428    _context = NvShader::getCgContext();
    446429
    447430    std::string path = vrFilePath::getInstance()->getPath("distance.cg");

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

    r2822 r2870  
    2424
    2525#include "Trace.h"
    26 #include "define.h"
    2726
    2827//check if occlusion query is supported

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

    r2863 r2870  
    1515 */
    1616
    17 #include "global.h"
    1817#include "PlaneRenderer.h"
    1918#include "Trace.h"

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

    r2863 r2870  
    2727#include <Cg/cgGL.h>
    2828
    29 #include "global.h"
    3029#include "NvColorTableShader.h"
    3130#include "TransferFunction.h"

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

    r2857 r2870  
    4040                                      4, image->getImageBuffer());
    4141    } else {
    42         ERROR("fail to load image [%s]\n", "particles2.bmp");
     42        ERROR("fail to load image [%s]\n", "particle2.bmp");
    4343    }
    4444
    … …  
    6969    glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    7070#endif
    71 
    72     glEnable(GL_POINT_SPRITE_ARB);
    7371
    7472    bool setSize = false;

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

    r2857 r2870  
    1111PointShader::PointShader() :
    1212    NvShader(),
    13     _normal(0)
     13    _normal(NULL)
    1414{
    1515    loadVertexProgram("pointsvp.cg", "main");

  • trunk/packages/vizservers/nanovis/R2/include/R2/R2.h

    r2841 r2870  
    33#define R2_H
    44
    5 #include <math.h>
    6 #include <string.h>
    7 
    8 #include <GL/glew.h>
    9 #include <GL/gl.h>
    10 
    11 #ifndef PI
    12 #   define PI 3.14159265358979323846f
    135#endif
    146
    15 enum R2COLORFORMAT {
    16     R2_LUMINANCE = GL_LUMINANCE, /*< GL_LIMINANCE */
    17     R2_RGB8 = GL_RGB8, /*< GL_RGB8 */
    18     R2_RGB = GL_RGB,            /*< GL_UNSIGNED_BYTE */
    19     R2_RGBA = GL_RGBA,          /*< GL_FLOAT */
    20     R2_FLOAT_RGBA32 = GL_FLOAT_RGBA32_NV
    21 };
    22 
    23 enum R2DATATYPE {
    24     R2_UBYTE = GL_UNSIGNED_BYTE,    /*< GL_UNSIGNED_BYTE */
    25     R2_FLOAT = GL_FLOAT,            /*< GL_FLOAT */
    26     R2_UINT = GL_UNSIGNED_INT,  /*< GL_UNSIGNED_INT */
    27     R2_INT = GL_INT /*< GL_INT */
    28 };
    29 
    30 enum R2TEXFILTER {
    31     R2_NEAREST = GL_NEAREST,        /*< GL_NEAREST */
    32     R2_LINEAR = GL_LINEAR           /*< GL_LINEAR */
    33 };
    34 
    35 enum R2TEXTARGET {
    36     R2_TEXTURE_1D = GL_TEXTURE_1D,  /*< R2_TEXTURE_1D */
    37     R2_TEXTURE_2D = GL_TEXTURE_2D,  /*< GL_TEXTURE_2D */
    38     R2_TEXTURE_RECTANGLE = GL_TEXTURE_RECTANGLE_NV, /*< GL_TEXTURE_RECTANGLE_NV */
    39     R2_TEXTURE_3D = GL_TEXTURE_3D  /*< GL_TEXTURE_3D */
    40 
    41 };
    42 enum R2TEXWRAP {
    43     R2_CLAMP = GL_CLAMP,                    /*< GL_CLAMP */
    44     R2_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,    /*< GL_CLAMP_TO_EDGE */
    45     R2_REPEAT = GL_REPEAT                   /*< GL_REPEAT */
    46 };
    47 
    48 #define R2Assert(s)
    49 
    50 extern void R2Init();
    51 extern void R2Exit();
    52 
    53 #endif
    54 

  • trunk/packages/vizservers/nanovis/R2/include/R2/R2string.h

    r2841 r2870  
    22#ifndef R2_STRING_H
    33#define R2_STRING_H
     4
     5#include <string.h>
    46
    57#include <R2/R2.h>

  • trunk/packages/vizservers/nanovis/R2/include/R2/graphics/R2Geometry.h

    r2827 r2870  
    1919
    2020public :
    21     R2Geometry(int primitive, R2VertexBuffer* vertexBuffer,
    22                R2IndexBuffer* indexBuffer);
    23     R2Geometry(int primitive, R2VertexBuffer* pointBuffer,
    24                R2VertexBuffer* colorBuffer, R2IndexBuffer* indexBuffer);
     21    R2Geometry(int primitive, R2VertexBuffer *vertexBuffer,
     22               R2IndexBuffer *indexBuffer);
     23    R2Geometry(int primitive, R2VertexBuffer *pointBuffer,
     24               R2VertexBuffer *colorBuffer, R2IndexBuffer *indexBuffer);
    2525    ~R2Geometry();
    2626

  • trunk/packages/vizservers/nanovis/R2/include/R2/graphics/R2IndexBuffer.h

    r2827 r2870  
    55class R2IndexBuffer
    66{
    7     int _indexCount;
    8     int *_data;
    9 
    107public:
    11     R2IndexBuffer(int indexCount, int* data, bool copy = true);
     8    R2IndexBuffer(int indexCount, int *data, bool copy = true);
    129    ~R2IndexBuffer();
    1310
    1411    int getIndexCount() const;
    15     const int* getData() const;
     12    const int *getData() const;
     13
     14private:
     15    int _indexCount;
     16    int *_data;
    1617};
    1718

  • trunk/packages/vizservers/nanovis/R2/src/R2Fonts.cpp

    r2841 r2870  
    11/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
    22#include <stdarg.h>
     3#include <string.h>
    34
    45#include <fstream>
     6
     7#include <GL/glew.h>
    58
    69#include <R2/R2Fonts.h>

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

    r2853 r2870  
    2424
    2525ScreenSnapper::ScreenSnapper(int w, int h, GLuint type,
    26                              int channel_per_pixel)
     26                             int channelsPerPixel)
    2727{
    28     width = w;
    29     height = h;
     28    _width = w;
     29    _height = h;
    3030
    3131    //only allow two types
    3232    assert(type == GL_FLOAT || type == GL_UNSIGNED_BYTE);
    33     data_type = type;
     33    _dataType = type;
    3434 
    3535    //only allow RGB or RGBA
    36     assert(channel_per_pixel == 3 || channel_per_pixel == 4);
    37     n_channels_per_pixel = channel_per_pixel;
     36    assert(channelsPerPixel == 3 || channelsPerPixel == 4);
     37    _numChannelsPerPixel = channelsPerPixel;
    3838
    3939    if (type == GL_FLOAT)
    40         data = new float[w*h*channel_per_pixel];
     40        _data = new float[w*h*channelsPerPixel];
    4141    else if (type == GL_UNSIGNED_BYTE)
    42         data = new unsigned char[w*h*channel_per_pixel];
     42        _data = new unsigned char[w*h*channelsPerPixel];
    4343 
    44     assert(data != 0);
     44    assert(_data != 0);
    4545    reset(0);   //reset data
    4646}
    … …  
    4848ScreenSnapper::~ScreenSnapper()
    4949{
    50     if (data_type == GL_FLOAT)
    51         delete[] (float*)data;
    52     else if(data_type == GL_UNSIGNED_BYTE)
    53         delete[] (unsigned char*)data;
     50    if (_dataType == GL_FLOAT)
     51        delete[] (float *)_data;
     52    else if(_dataType == GL_UNSIGNED_BYTE)
     53        delete[] (unsigned char*)_data;
    5454}
    5555
    … …  
    5858{
    5959    unsigned int elemSize;
    60     switch (data_type) {
     60    switch (_dataType) {
    6161    case GL_FLOAT:
    6262        elemSize = sizeof(float);
    … …  
    7070    }
    7171    unsigned int size;
    72     size = elemSize * width * height * n_channels_per_pixel;
    73     memset(data, size, c);
     72    size = elemSize * _width * _height * _numChannelsPerPixel;
     73    memset(_data, size, c);
    7474}
    7575
    … …  
    7777ScreenSnapper::capture()
    7878{
    79     if (data_type == GL_FLOAT) {
    80         if (n_channels_per_pixel == 3)
    81             glReadPixels(0, 0, width, height, GL_RGB, GL_FLOAT, data);
    82         else if (n_channels_per_pixel == 4)
    83             glReadPixels(0, 0, width, height, GL_RGBA, GL_FLOAT, data);
    84     } else if (data_type == GL_UNSIGNED_BYTE) {
    85         if (n_channels_per_pixel == 3)
    86             glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
    87         else if (n_channels_per_pixel == 4)
    88             glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
     79    if (_dataType == GL_FLOAT) {
     80        if (_numChannelsPerPixel == 3)
     81            glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, _data);
     82        else if (_numChannelsPerPixel == 4)
     83            glReadPixels(0, 0, _width, _height, GL_RGBA, GL_FLOAT, _data);
     84    } else if (_dataType == GL_UNSIGNED_BYTE) {
     85        if (_numChannelsPerPixel == 3)
     86            glReadPixels(0, 0, _width, _height, GL_RGB, GL_UNSIGNED_BYTE, _data);
     87        else if (_numChannelsPerPixel == 4)
     88            glReadPixels(0, 0, _width, _height, GL_RGBA, GL_UNSIGNED_BYTE, _data);
    8989    }
    9090    assert(glGetError() == 0);
    … …  
    9494ScreenSnapper::print()
    9595{
    96     for (int i = 0; i < width*height; i++) {
    97         if (data_type == GL_FLOAT) {
    98             if (n_channels_per_pixel == 3) {
    99                 TRACE("(%f %f %f) ", ((float*)data)[3*i],
    100                       ((float*)data)[3*i+1], ((float*)data)[3*i+2]);
    101             } else if (n_channels_per_pixel==4) {
    102                 TRACE("(%f %f %f %f) ", ((float*)data)[4*i],
    103                       ((float*)data)[4*i+1],
    104                       ((float*)data)[4*i+2],
    105                       ((float*)data)[4*i+3]);
     96    for (int i = 0; i < _width*_height; i++) {
     97        if (_dataType == GL_FLOAT) {
     98            if (_numChannelsPerPixel == 3) {
     99                TRACE("(%f %f %f) ", ((float *)_data)[3*i],
     100                      ((float*)_data)[3*i+1], ((float *)_data)[3*i+2]);
     101            } else if (_numChannelsPerPixel == 4) {
     102                TRACE("(%f %f %f %f) ", ((float *)_data)[4*i],
     103                      ((float *)_data)[4*i+1],
     104                      ((float *)_data)[4*i+2],
     105                      ((float *)_data)[4*i+3]);
    106106            }
    107         } else if (data_type == GL_UNSIGNED_BYTE) {
    108             if (n_channels_per_pixel==3) {
     107        } else if (_dataType == GL_UNSIGNED_BYTE) {
     108            if (_numChannelsPerPixel == 3) {
    109109                TRACE("(%d %d %d) ",
    110                       ((unsigned char*)data)[3*i],
    111                       ((unsigned char*)data)[3*i+1],
    112                       ((unsigned char*)data)[3*i+2]);
    113             } else if (n_channels_per_pixel == 4) {
     110                      ((unsigned char *)_data)[3*i],
     111                      ((unsigned char *)_data)[3*i+1],
     112                      ((unsigned char *)_data)[3*i+2]);
     113            } else if (_numChannelsPerPixel == 4) {
    114114                TRACE("(%d %d %d %d) ",
    115                       ((unsigned char*)data)[4*i],
    116                       ((unsigned char*)data)[4*i+1],
    117                       ((unsigned char*)data)[4*i+2],
    118                       ((unsigned char*)data)[4*i+3]);
     115                      ((unsigned char *)_data)[4*i],
     116                      ((unsigned char *)_data)[4*i+1],
     117                      ((unsigned char *)_data)[4*i+2],
     118                      ((unsigned char *)_data)[4*i+3]);
    119119            }
    120120        }

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

    r2853 r2870  
    2323#include <GL/glew.h>
    2424
    25 #include "define.h"
    26 
    2725class ScreenSnapper
    2826{
    … …  
    3836    void print();
    3937
    40     int width;  ///< width of the screen
    41     int height; ///< height of the screen
    42     GLuint data_type;   ///< GL_FLOAT or GL_UNSIGNED_BYTE
    43     int n_channels_per_pixel; ///< RGB(3) or RGBA(4)
     38private:
     39    int _width;  ///< width of the screen
     40    int _height;        ///< height of the screen
     41    GLuint _dataType;   ///< GL_FLOAT or GL_UNSIGNED_BYTE
     42    int _numChannelsPerPixel; ///< RGB(3) or RGBA(4)
    4443
    4544    /**
    … …  
    4948     * [rgb][rgb][rgb]... or [rgba][rgba][rgba]...
    5049     */
    51     void *data;
     50    void *_data;
    5251};
    5352

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

    r2857 r2870  
    1010#include <ImageLoader.h>
    1111
     12#include "nanovis.h"
    1213#include "VelocityArrowsSlice.h"
    13 #include "global.h"
     14#include "NvShader.h"
    1415
    1516VelocityArrowsSlice::VelocityArrowsSlice()
    … …  
    99100
    100101    _arrowColor.set(1, 1, 0);
     102
     103    GLfloat minMax[2];
     104    glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, minMax);
     105    TRACE("Aliased point size range: %g %g\n", minMax[0], minMax[1]);
     106    _maxPointSize = minMax[1];
     107    glGetFloatv(GL_SMOOTH_POINT_SIZE_RANGE, minMax);
     108    TRACE("Smooth point size range: %g %g\n", minMax[0], minMax[1]);
     109    _maxPointSize = minMax[1] > _maxPointSize ? minMax[1] : _maxPointSize;
     110    TRACE("Max point size: %g\n", _maxPointSize);
    101111
    102112    TRACE("Leaving VelocityArrowsSlice constructor\n");
    … …  
    255265                    glVertex3f(pos.x, pos.y, pos.z);
    256266                    glVertex3f(pos2.x, pos2.y, pos2.z);
    257                     /*v = pos - pos2;
    258                       v2.x = 1;
    259                       v2.y = 1;
    260                       v2.z = (-(x1-x2)-(y1-y2))/(z1-z2)
    261                       adj = v.length() / (4 * sqrt((x3^2)+(y3^2)+(z3^2)));
    262                       x3 *= adj
    263                       y3 *= adj
    264                       z3 *= adj
    265                     */
    266267                }
    267268            }
    … …  
    296297        glEnable(GL_BLEND);
    297298        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    298         glEnable(GL_POINT_SPRITE_NV);
     299        glEnable(GL_POINT_SPRITE_ARB);
    299300        glPointSize(20);
    300301        glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
    … …  
    305306        glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f);
    306307        glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f);
    307         glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, 100.0f);
     308        glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, _maxPointSize);
    308309        glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
    309310
    … …  
    317318
    318319        //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * 0.5) * _screenHeight * 0.5);
     320        cgSetParameter1f(_mvTanHalfFOVParam, tan(30. * 0.5) * NanoVis::win_height * 0.5);
    319321
    320322        cgGLSetStateMatrixParameter(_mvpParticleParam,

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

    r2857 r2870  
    9393    unsigned int _fbo;
    9494    unsigned int _tex;
     95    float _maxPointSize;
    9596
    9697    CGcontext _context;

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

    r2857 r2870  
    2222#include <R2/R2Object.h>
    2323
    24 #include "define.h"
    2524#include "Color.h"
    2625#include "Texture3D.h"

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

    r2831 r2870  
    1818
    1919#include <GL/glew.h>
    20 #include <Cg/cgGL.h>
    2120
    2221#define CHECK_FRAMEBUFFER_STATUS()                              \
    … …  
    6059} while(0)
    6160
     61inline void
     62draw_quad(int w, int h, int tw, int th)
     63{
     64    glBegin(GL_QUADS);
     65    glTexCoord2f(0,         0);         glVertex2f(0,        0);
     66    glTexCoord2f((float)tw, 0);         glVertex2f((float)w, 0);
     67    glTexCoord2f((float)tw, (float)th); glVertex2f((float)w, (float) h);
     68    glTexCoord2f(0,         (float)th); glVertex2f(0,        (float) h);
     69    glEnd();
     70}
     71
    6272#endif

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

    r2863 r2870  
    6363#include "HeightMap.h"
    6464#include "NvCamera.h"
     65#include "NvEventLog.h"
     66#include "RenderContext.h"
     67#include "NvShader.h"
    6568#include "NvColorTableRenderer.h"
    66 #include "NvEventLog.h"
    6769#include "NvFlowVisRenderer.h"
    6870#include "NvLIC.h"
    … …  
    7476#include "PointSet.h"
    7577#endif
    76 #include "RenderContext.h"
    7778#include "Switch.h"
    7879#include "Trace.h"
    … …  
    8485
    8586#define SIZEOF_BMP_HEADER   54
    86 
    87 extern void NvInitCG(); // in Shader.cpp
    8887
    8988/// Indicates "up" axis
    … …  
    192191
    193192PerfQuery *perf = NULL;                        //perfromance counter
    194 
    195 CGprogram m_passthru_fprog;
    196 CGparameter m_passthru_scale_param, m_passthru_bias_param;
    197193
    198194// Variables for mouse events
    … …  
    360356    removeAllData();
    361357
     358    NvShader::exitCg();
     359
    362360#ifdef EVENTLOG
    363361    NvExitEventLog();
    … …  
    373371    closelog();
    374372    exit(code);
    375 }
    376 
    377 CGprogram
    378 LoadCgSourceProgram(CGcontext context, const char *fileName, CGprofile profile,
    379                     const char *entryPoint)
    380 {
    381     const char *path = R2FilePath::getInstance()->getPath(fileName);
    382     if (path == NULL) {
    383         ERROR("can't find program \"%s\"\n", fileName);
    384     }
    385     TRACE("cg program compiling: %s\n", path);
    386     CGprogram program;
    387     program = cgCreateProgramFromFile(context, CG_SOURCE, path, profile,
    388                                       entryPoint, NULL);
    389     cgGLLoadProgram(program);
    390     CGerror LastError = cgGetError();
    391     if (LastError) {
    392         ERROR("Error message: %s\n", cgGetLastListing(context));
    393     }
    394     TRACE("successfully compiled program: %s\n", path);
    395     delete [] path;
    396     return program;
    397373}
    398374
    … …  
    719695void CgErrorCallback(void)
    720696{
    721     CGerror lastError = cgGetError();
    722 
    723     if (lastError) {
    724         TRACE("\n---------------------------------------------------\n");
    725         TRACE("%s\n\n", cgGetErrorString(lastError));
    726         TRACE("%s\n", cgGetLastListing(g_context));
    727         TRACE("-----------------------------------------------------\n");
     697    if (!NvShader::printErrorInfo()) {
    728698        TRACE("Cg error, exiting...\n");
    729         cgDestroyContext(g_context);
    730699        DoExit(-1);
    731700    }
    … …  
    735704{
    736705    // print system information
    737     system_info();
     706    TRACE("-----------------------------------------------------------\n");
     707    TRACE("OpenGL driver: %s %s\n", glGetString(GL_VENDOR),
     708          glGetString(GL_VERSION));
     709    TRACE("Graphics hardware: %s\n", glGetString(GL_RENDERER));
     710    TRACE("-----------------------------------------------------------\n");
    738711
    739712    if (path == NULL) {
    … …  
    758731    ImageLoaderFactory::getInstance()->addLoaderImpl("bmp", new BMPImageLoaderImpl());
    759732
    760     NvInitCG();
     733    NvShader::initCg();
    761734    NvShader::setErrorCallback(CgErrorCallback);
    762735
    … …  
    774747    licRenderer = new NvLIC(NMESH, NPIX, NPIX, lic_axis,
    775748                            Vector3(lic_slice_x, lic_slice_y, lic_slice_z),
    776                             g_context);
     749                            NvShader::getCgContext());
    777750
    778751    grid = new Grid();
    … …  
    841814    renderContext = new graphics::RenderContext();
    842815
    843     //create n 2D plane renderer
     816    //create a 2D plane renderer
    844817    plane_renderer = new PlaneRenderer(win_width, win_height);
    845818#if PROTOTYPE

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

    r2847 r2870  
    3030#include <rappture.h>
    3131
    32 #include "define.h"
    33 #include "global.h"
    3432#include "config.h"
    3533
Note: See TracChangeset for help on using the changeset viewer.