source: nanovis/trunk/Shader.h @ 4795

Last change on this file since 4795 was 3875, checked in by ldelgass, 6 years ago

Add config.h option USE_ARB_PROGRAMS, which will use ARB_vertex/fragment_program
extensions as the Cg compile target instead of NV_vertex_program3 and
NV_fragment_program2. Note that glyph texture style rendering in flows will not
work if this define is set (however, the default style is line arrows which will
work).

  • Property svn:eol-style set to native
File size: 8.6 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    bool isVertexProgramLoaded()
52    {
53        return (getVP() == NULL);
54    }
55
56    bool isFragmentProgramLoaded()
57    {
58        return (getFP() == NULL);
59    }
60
61    void setVPParameter1f(const char *name, float val)
62    {
63        Parameter param = getVPParam(name);
64        if (param == NULL)
65            return;
66        cgSetParameter1f(param, val);
67    }
68
69    void setFPParameter1f(const char *name, float val)
70    {
71        Parameter param = getFPParam(name);
72        if (param == NULL)
73            return;
74        cgSetParameter1f(param, val);
75    }
76
77    void setVPParameter2f(const char *name, float val1, float val2)
78    {
79        Parameter param = getVPParam(name);
80        if (param == NULL)
81            return;
82        cgSetParameter2f(param, val1, val2);
83    }
84
85    void setFPParameter2f(const char *name, float val1, float val2)
86    {
87        Parameter param = getFPParam(name);
88        if (param == NULL)
89            return;
90        cgSetParameter2f(param, val1, val2);
91    }
92
93    void setVPParameter3f(const char *name, float val1, float val2, float val3)
94    {
95        Parameter param = getVPParam(name);
96        if (param == NULL)
97            return;
98        cgSetParameter3f(param, val1, val2, val3);
99    }
100
101    void setFPParameter3f(const char *name, float val1, float val2, float val3)
102    {
103        Parameter param = getFPParam(name);
104        if (param == NULL)
105            return;
106        cgSetParameter3f(param, val1, val2, val3);
107    }
108
109    void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
110    {
111        Parameter param = getVPParam(name);
112        if (param == NULL)
113            return;
114        cgSetParameter4f(param, val1, val2, val3, val4);
115    }
116
117    void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
118    {
119        Parameter param = getFPParam(name);
120        if (param == NULL)
121            return;
122        cgSetParameter4f(param, val1, val2, val3, val4);
123    }
124
125    void setVPMatrixParameterf(const char *name, float *mat)
126    {
127        Parameter param = getVPParam(name);
128        if (param == NULL)
129            return;
130        cgSetMatrixParameterfc(param, mat);
131    }
132
133    void setFPMatrixParameterf(const char *name, float *mat)
134    {
135        Parameter param = getFPParam(name);
136        if (param == NULL)
137            return;
138        cgSetMatrixParameterfc(param, mat);
139    }
140
141    void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
142    {
143        Parameter param = getVPParam(name);
144        if (param == NULL)
145            return;
146        cgGLSetTextureParameter(param, texobj);
147        if (enable)
148            cgGLEnableTextureParameter(param);
149    }
150
151    void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
152    {
153        Parameter param = getFPParam(name);
154        if (param == NULL)
155            return;
156        cgGLSetTextureParameter(param, texobj);
157        if (enable)
158            cgGLEnableTextureParameter(param);
159    }
160
161    void enableVPTextureParameter(const char *name)
162    {
163        Parameter param = getVPParam(name);
164        if (param == NULL)
165            return;
166        cgGLEnableTextureParameter(param);
167    }
168
169    void enaableFPTextureParameter(const char *name)
170    {
171        Parameter param = getFPParam(name);
172        if (param == NULL)
173            return;
174        cgGLEnableTextureParameter(param);
175    }
176
177    void disableVPTextureParameter(const char *name)
178    {
179        Parameter param = getVPParam(name);
180        if (param == NULL)
181            return;
182        cgGLDisableTextureParameter(param);
183    }
184
185    void disableFPTextureParameter(const char *name)
186    {
187        Parameter param = getFPParam(name);
188        if (param == NULL)
189            return;
190        cgGLDisableTextureParameter(param);
191    }
192
193    void setGLStateMatrixVPParameter(const char *name, GLMatrix matrix,
194                                     GLMatrixType type = MATRIX_IDENTITY)
195    {
196        Parameter param = getVPParam(name);
197        if (param == NULL)
198            return;
199        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
200    }
201
202    void setGLStateMatrixFPParameter(const char *name, GLMatrix matrix,
203                                     GLMatrixType type = MATRIX_IDENTITY)
204    {
205        Parameter param = getFPParam(name);
206        if (param == NULL)
207            return;
208        cgGLSetStateMatrixParameter(param, (CGGLenum)matrix, (CGGLenum)type);
209    }
210
211    virtual void bind()
212    {
213        if (_cgVP) {
214            cgGLBindProgram(_cgVP);
215            enableVertexProfile();
216        }
217        if (_cgFP) {
218            cgGLBindProgram(_cgFP);
219            enableFragmentProfile();
220        }
221    }
222
223    virtual void unbind()
224    {
225        if (_cgVP)
226            disableVertexProfile();
227        if (_cgFP)
228            disableFragmentProfile();
229    }
230
231    static void init();
232
233    static void exit();
234
235    static bool printErrorInfo();
236
237    static void setErrorCallback(ShaderCallbackFunction callback);
238
239private:
240    typedef CGparameter Parameter;
241    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
242
243    Parameter getNamedParameterFromFP(const char *paramName)
244    {
245        if (_cgFP) {
246            return cgGetNamedParameter(_cgFP, paramName);
247        }
248        ERROR("Unknown fragment program parameter: %s", paramName);
249        return 0;
250    }
251
252    Parameter getNamedParameterFromVP(const char *paramName)
253    {
254        if (_cgVP) {
255            return cgGetNamedParameter(_cgVP, paramName);
256        }
257        ERROR("Unknown vertex program parameter: %s", paramName);
258        return 0;
259    }
260
261    Parameter getVPParam(const char *name)
262    {
263        Parameter param;
264        ParameterHashmap::iterator itr = _vpParams.find(name);
265        if (itr == _vpParams.end()) {
266            param = getNamedParameterFromVP(name);
267            if (param != NULL)
268                _vpParams[name] = param;
269            else
270                ERROR("Unknown vertex program parameter: %s", name);
271        } else {
272            param = itr->second;
273        }
274        return param;
275    }
276
277    Parameter getFPParam(const char *name)
278    {
279        Parameter param;
280        ParameterHashmap::iterator itr = _fpParams.find(name);
281        if (itr == _fpParams.end()) {
282            param = getNamedParameterFromFP(name);
283            if (param != NULL)
284                _fpParams[name] = param;
285            else
286                ERROR("Unknown fragment program parameter: %s", name);
287        } else {
288            param = itr->second;
289        }
290        return param;
291    }
292
293
294    void resetPrograms();
295
296    CGprogram getVP()
297    {
298        return _cgVP;
299    }
300
301    CGprogram getFP()
302    {
303        return _cgFP;
304    }
305
306    void enableVertexProfile()
307    {
308        cgGLEnableProfile(_vertexProfile);
309    }
310
311    void disableVertexProfile()
312    {
313        cgGLDisableProfile(_vertexProfile);
314    }
315
316    void enableFragmentProfile()
317    {
318        cgGLEnableProfile(_fragmentProfile);
319    }
320
321    void disableFragmentProfile()
322    {
323        cgGLDisableProfile(_fragmentProfile);
324    }
325
326    static CGcontext getCgContext()
327    {
328        return _cgContext;
329    }
330
331    std::string _vpFile;
332    std::string _fpFile;
333
334    ParameterHashmap _vpParams;
335    ParameterHashmap _fpParams;
336
337    CGprofile _vertexProfile;
338    CGprofile _fragmentProfile;
339
340    CGprogram _cgVP;
341    CGprogram _cgFP;
342
343    static CGprofile _defaultVertexProfile;
344    static CGprofile _defaultFragmentProfile;
345    static CGcontext _cgContext;
346
347    static CGprogram
348    loadCgSourceProgram(CGcontext context, const char *filename, 
349                        CGprofile profile, const char *entryPoint);
350};
351
352}
353
354#endif
Note: See TracBrowser for help on using the repository browser.