source: trunk/packages/vizservers/nanovis/NvShader.h @ 3502

Last change on this file since 3502 was 3502, checked in by ldelgass, 7 years ago

Add basic VTK structured points reader to nanovis, update copyright dates.

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