source: nanovis/branches/1.1/Shader.h @ 4906

Last change on this file since 4906 was 4904, checked in by ldelgass, 5 years ago

Merge serveral changes from trunk. Does not include threading, world space
changes, etc.

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