source: trunk/packages/vizservers/nanovis/Shader.h @ 3630

Last change on this file since 3630 was 3630, checked in by ldelgass, 8 years ago

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

  • Property svn:eol-style set to native
File size: 8.4 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright (c) 2004-2013  HUBzero Foundation, LLC
4 *
5 */
6#ifndef NV_SHADER_H
7#define NV_SHADER_H
8
9#include <string>
10#include <tr1/unordered_map>
11
12#include <GL/glew.h>
13#include <Cg/cg.h>
14#include <Cg/cgGL.h>
15
16#include "Trace.h"
17
18namespace nv {
19
20class Shader
21{
22public:
23    enum GLMatrix {
24        MODELVIEW_MATRIX = CG_GL_MODELVIEW_MATRIX,
25        PROJECTION_MATRIX = CG_GL_PROJECTION_MATRIX,
26        MODELVIEW_PROJECTION_MATRIX = CG_GL_MODELVIEW_PROJECTION_MATRIX
27    };
28    enum GLMatrixType {
29        MATRIX_IDENTITY = CG_GL_MATRIX_IDENTITY,
30        MATRIX_INVERSE = CG_GL_MATRIX_INVERSE
31    };
32
33    typedef void (*ShaderCallbackFunction)(void);
34
35    Shader();
36
37    virtual ~Shader();
38
39    /**
40     * \brief Load and compile a vertex shader
41     * \param fileName the name of the shader source file
42     */
43    void loadVertexProgram(const char *fileName);
44
45    /**
46     * \brief Load and compile a fragment shader
47     * \param fileName the name of the shader source file
48     */
49    void loadFragmentProgram(const char *fileName);
50
51    void setVPParameter1f(const char *name, float val)
52    {
53        Parameter param = getVPParam(name);
54        if (param == NULL)
55            return;
56        cgSetParameter1f(param, val);
57    }
58
59    void setFPParameter1f(const char *name, float val)
60    {
61        Parameter param = getFPParam(name);
62        if (param == NULL)
63            return;
64        cgSetParameter1f(param, val);
65    }
66
67    void setVPParameter2f(const char *name, float val1, float val2)
68    {
69        Parameter param = getVPParam(name);
70        if (param == NULL)
71            return;
72        cgSetParameter2f(param, val1, val2);
73    }
74
75    void setFPParameter2f(const char *name, float val1, float val2)
76    {
77        Parameter param = getFPParam(name);
78        if (param == NULL)
79            return;
80        cgSetParameter2f(param, val1, val2);
81    }
82
83    void setVPParameter3f(const char *name, float val1, float val2, float val3)
84    {
85        Parameter param = getVPParam(name);
86        if (param == NULL)
87            return;
88        cgSetParameter3f(param, val1, val2, val3);
89    }
90
91    void setFPParameter3f(const char *name, float val1, float val2, float val3)
92    {
93        Parameter param = getFPParam(name);
94        if (param == NULL)
95            return;
96        cgSetParameter3f(param, val1, val2, val3);
97    }
98
99    void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
100    {
101        Parameter param = getVPParam(name);
102        if (param == NULL)
103            return;
104        cgSetParameter4f(param, val1, val2, val3, val4);
105    }
106
107    void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
108    {
109        Parameter param = getFPParam(name);
110        if (param == NULL)
111            return;
112        cgSetParameter4f(param, val1, val2, val3, val4);
113    }
114
115    void setVPMatrixParameterf(const char *name, float *mat)
116    {
117        Parameter param = getVPParam(name);
118        if (param == NULL)
119            return;
120        cgSetMatrixParameterfc(param, mat);
121    }
122
123    void setFPMatrixParameterf(const char *name, float *mat)
124    {
125        Parameter param = getFPParam(name);
126        if (param == NULL)
127            return;
128        cgSetMatrixParameterfc(param, mat);
129    }
130
131    void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
132    {
133        Parameter param = getVPParam(name);
134        if (param == NULL)
135            return;
136        cgGLSetTextureParameter(param, texobj);
137        if (enable)
138            cgGLEnableTextureParameter(param);
139    }
140
141    void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
142    {
143        Parameter param = getFPParam(name);
144        if (param == NULL)
145            return;
146        cgGLSetTextureParameter(param, texobj);
147        if (enable)
148            cgGLEnableTextureParameter(param);
149    }
150
151    void enableVPTextureParameter(const char *name)
152    {
153        Parameter param = getVPParam(name);
154        if (param == NULL)
155            return;
156        cgGLEnableTextureParameter(param);
157    }
158
159    void enaableFPTextureParameter(const char *name)
160    {
161        Parameter param = getFPParam(name);
162        if (param == NULL)
163            return;
164        cgGLEnableTextureParameter(param);
165    }
166
167    void disableVPTextureParameter(const char *name)
168    {
169        Parameter param = getVPParam(name);
170        if (param == NULL)
171            return;
172        cgGLDisableTextureParameter(param);
173    }
174
175    void disableFPTextureParameter(const char *name)
176    {
177        Parameter param = getFPParam(name);
178        if (param == NULL)
179            return;
180        cgGLDisableTextureParameter(param);
181    }
182
183    void setGLStateMatrixVPParameter(const char *name, GLMatrix matrix,
184                                     GLMatrixType type = MATRIX_IDENTITY)
185    {
186        Parameter param = getVPParam(name);
187        if (param == NULL)
188            return;
189        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
190    }
191
192    void setGLStateMatrixFPParameter(const char *name, GLMatrix matrix,
193                                     GLMatrixType type = MATRIX_IDENTITY)
194    {
195        Parameter param = getFPParam(name);
196        if (param == NULL)
197            return;
198        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
199    }
200
201    virtual void bind()
202    {
203        if (_cgVP) {
204            cgGLBindProgram(_cgVP);
205            enableVertexProfile();
206        }
207        if (_cgFP) {
208            cgGLBindProgram(_cgFP);
209            enableFragmentProfile();
210        }
211    }
212
213    virtual void unbind()
214    {
215        if (_cgVP)
216            disableVertexProfile();
217        if (_cgFP)
218            disableFragmentProfile();
219    }
220
221    static void init();
222
223    static void exit();
224
225    static bool printErrorInfo();
226
227    static void setErrorCallback(ShaderCallbackFunction callback);
228
229private:
230    typedef CGparameter Parameter;
231    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
232
233    Parameter getNamedParameterFromFP(const char *paramName)
234    {
235        if (_cgFP) {
236            return cgGetNamedParameter(_cgFP, paramName);
237        }
238        ERROR("Unknown fragment program parameter: %s", paramName);
239        return 0;
240    }
241
242    Parameter getNamedParameterFromVP(const char *paramName)
243    {
244        if (_cgVP) {
245            return cgGetNamedParameter(_cgVP, paramName);
246        }
247        ERROR("Unknown vertex program parameter: %s", paramName);
248        return 0;
249    }
250
251    Parameter getVPParam(const char *name)
252    {
253        Parameter param;
254        ParameterHashmap::iterator itr = _vpParams.find(name);
255        if (itr == _vpParams.end()) {
256            param = getNamedParameterFromVP(name);
257            if (param != NULL)
258                _vpParams[name] = param;
259            else
260                ERROR("Unknown vertex program parameter: %s", name);
261        } else {
262            param = itr->second;
263        }
264        return param;
265    }
266
267    Parameter getFPParam(const char *name)
268    {
269        Parameter param;
270        ParameterHashmap::iterator itr = _fpParams.find(name);
271        if (itr == _fpParams.end()) {
272            param = getNamedParameterFromFP(name);
273            if (param != NULL)
274                _fpParams[name] = param;
275            else
276                ERROR("Unknown fragment program parameter: %s", name);
277        } else {
278            param = itr->second;
279        }
280        return param;
281    }
282
283
284    void resetPrograms();
285
286
287    CGprogram getVP()
288    {
289        return _cgVP;
290    }
291
292    CGprogram getFP()
293    {
294        return _cgFP;
295    }
296
297    void enableVertexProfile()
298    {
299        cgGLEnableProfile(_vertexProfile);
300    }
301
302    void disableVertexProfile()
303    {
304        cgGLDisableProfile(_vertexProfile);
305    }
306
307    void enableFragmentProfile()
308    {
309        cgGLEnableProfile(_fragmentProfile);
310    }
311
312    void disableFragmentProfile()
313    {
314        cgGLDisableProfile(_fragmentProfile);
315    }
316
317    static CGcontext getCgContext()
318    {
319        return _cgContext;
320    }
321
322    std::string _vpFile;
323    std::string _fpFile;
324
325    ParameterHashmap _vpParams;
326    ParameterHashmap _fpParams;
327
328    CGprofile _vertexProfile;
329    CGprofile _fragmentProfile;
330
331    CGprogram _cgVP;
332    CGprogram _cgFP;
333
334    static CGprofile _defaultVertexProfile;
335    static CGprofile _defaultFragmentProfile;
336    static CGcontext _cgContext;
337
338    static CGprogram
339    loadCgSourceProgram(CGcontext context, const char *filename,
340                        CGprofile profile, const char *entryPoint);
341};
342
343}
344
345#endif
Note: See TracBrowser for help on using the repository browser.