Ignore:
Timestamp:
Dec 22, 2014, 7:18:59 AM (5 years ago)
Author:
ldelgass
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • nanovis/branches/1.1/Shader.h

    r4889 r4904  
    3131    };
    3232
    33     typedef void CgCallbackFunction(void);
     33    typedef void (*ShaderCallbackFunction)(void);
    3434
    3535    Shader();
     
    3838
    3939    /**
    40      * @brief create a Cg vertex program and load it
    41      * @param fileName the name of Cg program file
    42      * @param entryPoint a entry point of the Cg program
     40     * \brief Load and compile a vertex shader
     41     * \param fileName the name of the shader source file
    4342     */
    44     void loadVertexProgram(const char *fileName, const char *entryPoint);
     43    void loadVertexProgram(const char *fileName);
    4544
    4645    /**
    47      * @brief create a Cg fragment program and load it
    48      * @param fileName the name of Cg program file
    49      * @param entryPoint a entry point of the Cg program
     46     * \brief Load and compile a fragment shader
     47     * \param fileName the name of the shader source file
    5048     */
    51     void loadFragmentProgram(const char *fileName, const char *entryPoint);
    52 
    53     CGparameter getNamedParameterFromFP(const char *paramName)
    54     {
    55         if (_cgFP) {
    56             return cgGetNamedParameter(_cgFP, paramName);
    57         }
    58         ERROR("Unknown fragment program parameter: %s", paramName);
    59         return 0;
    60     }
    61 
    62     CGparameter getNamedParameterFromVP(const char *paramName)
    63     {
    64         if (_cgVP) {
    65             return cgGetNamedParameter(_cgVP, paramName);
    66         }
    67         ERROR("Unknown vertex program parameter: %s", paramName);
    68         return 0;
     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);
    6959    }
    7060
    7161    void setVPParameter1f(const char *name, float val)
    7262    {
    73         CGparameter param = getVPParam(name);
     63        Parameter param = getVPParam(name);
    7464        if (param == NULL)
    7565            return;
     
    7969    void setFPParameter1f(const char *name, float val)
    8070    {
    81         CGparameter param = getFPParam(name);
     71        Parameter param = getFPParam(name);
    8272        if (param == NULL)
    8373            return;
     
    8777    void setVPParameter2f(const char *name, float val1, float val2)
    8878    {
    89         CGparameter param = getVPParam(name);
     79        Parameter param = getVPParam(name);
    9080        if (param == NULL)
    9181            return;
     
    9585    void setFPParameter2f(const char *name, float val1, float val2)
    9686    {
    97         CGparameter param = getFPParam(name);
     87        Parameter param = getFPParam(name);
    9888        if (param == NULL)
    9989            return;
     
    10393    void setVPParameter3f(const char *name, float val1, float val2, float val3)
    10494    {
    105         CGparameter param = getVPParam(name);
     95        Parameter param = getVPParam(name);
    10696        if (param == NULL)
    10797            return;
     
    111101    void setFPParameter3f(const char *name, float val1, float val2, float val3)
    112102    {
    113         CGparameter param = getFPParam(name);
     103        Parameter param = getFPParam(name);
    114104        if (param == NULL)
    115105            return;
     
    119109    void setVPParameter4f(const char *name, float val1, float val2, float val3, float val4)
    120110    {
    121         CGparameter param = getVPParam(name);
     111        Parameter param = getVPParam(name);
    122112        if (param == NULL)
    123113            return;
     
    127117    void setFPParameter4f(const char *name, float val1, float val2, float val3, float val4)
    128118    {
    129         CGparameter param = getFPParam(name);
     119        Parameter param = getFPParam(name);
    130120        if (param == NULL)
    131121            return;
     
    135125    void setVPMatrixParameterf(const char *name, float *mat)
    136126    {
    137         CGparameter param = getVPParam(name);
     127        Parameter param = getVPParam(name);
    138128        if (param == NULL)
    139129            return;
     
    143133    void setFPMatrixParameterf(const char *name, float *mat)
    144134    {
    145         CGparameter param = getFPParam(name);
     135        Parameter param = getFPParam(name);
    146136        if (param == NULL)
    147137            return;
     
    151141    void setVPTextureParameter(const char *name, GLuint texobj, bool enable = true)
    152142    {
    153         CGparameter param = getVPParam(name);
     143        Parameter param = getVPParam(name);
    154144        if (param == NULL)
    155145            return;
     
    161151    void setFPTextureParameter(const char *name, GLuint texobj, bool enable = true)
    162152    {
    163         CGparameter param = getFPParam(name);
     153        Parameter param = getFPParam(name);
    164154        if (param == NULL)
    165155            return;
     
    171161    void enableVPTextureParameter(const char *name)
    172162    {
    173         CGparameter param = getVPParam(name);
     163        Parameter param = getVPParam(name);
    174164        if (param == NULL)
    175165            return;
     
    179169    void enaableFPTextureParameter(const char *name)
    180170    {
    181         CGparameter param = getFPParam(name);
     171        Parameter param = getFPParam(name);
    182172        if (param == NULL)
    183173            return;
     
    187177    void disableVPTextureParameter(const char *name)
    188178    {
    189         CGparameter param = getVPParam(name);
     179        Parameter param = getVPParam(name);
    190180        if (param == NULL)
    191181            return;
     
    195185    void disableFPTextureParameter(const char *name)
    196186    {
    197         CGparameter param = getFPParam(name);
     187        Parameter param = getFPParam(name);
    198188        if (param == NULL)
    199189            return;
     
    204194                                     GLMatrixType type = MATRIX_IDENTITY)
    205195    {
    206         CGparameter param = getVPParam(name);
     196        Parameter param = getVPParam(name);
    207197        if (param == NULL)
    208198            return;
     
    213203                                     GLMatrixType type = MATRIX_IDENTITY)
    214204    {
    215         CGparameter param = getFPParam(name);
     205        Parameter param = getFPParam(name);
    216206        if (param == NULL)
    217207            return;
     
    239229    }
    240230
    241     void enableVertexProfile()
    242     {
    243         cgGLEnableProfile(_vertexProfile);
    244     }
    245 
    246     void disableVertexProfile()
    247     {
    248         cgGLDisableProfile(_vertexProfile);
    249     }
    250 
    251     void enableFragmentProfile()
    252     {
    253         cgGLEnableProfile(_fragmentProfile);
    254     }
    255 
    256     void disableFragmentProfile()
    257     {
    258         cgGLDisableProfile(_fragmentProfile);
    259     }
    260 
    261     static void initCg(CGprofile defaultVertexProfile = CG_PROFILE_VP40,
    262                        CGprofile defaultFragmentProfile = CG_PROFILE_FP40);
    263 
    264     static void exitCg();
     231    static void init();
     232
     233    static void exit();
    265234
    266235    static bool printErrorInfo();
    267236
    268     static void setErrorCallback(CgCallbackFunction callback);
     237    static void setErrorCallback(ShaderCallbackFunction callback);
    269238
    270239    static CGcontext getCgContext()
     
    274243
    275244protected:
    276     typedef std::tr1::unordered_map<std::string, CGparameter> ParameterHashmap;
    277 
    278     CGprogram getVP()
    279     {
    280         return _cgVP;
    281     }
    282 
    283     CGprogram getFP()
    284     {
    285         return _cgFP;
    286     }
    287 
    288     CGparameter getVPParam(const char *name)
    289     {
    290         CGparameter param;
     245    typedef CGparameter Parameter;
     246    typedef std::tr1::unordered_map<std::string, Parameter> ParameterHashmap;
     247
     248    Parameter getNamedParameterFromFP(const char *paramName)
     249    {
     250        if (_cgFP) {
     251            return cgGetNamedParameter(_cgFP, paramName);
     252        }
     253        ERROR("Unknown fragment program parameter: %s", paramName);
     254        return 0;
     255    }
     256
     257    Parameter getNamedParameterFromVP(const char *paramName)
     258    {
     259        if (_cgVP) {
     260            return cgGetNamedParameter(_cgVP, paramName);
     261        }
     262        ERROR("Unknown vertex program parameter: %s", paramName);
     263        return 0;
     264    }
     265
     266    Parameter getVPParam(const char *name)
     267    {
     268        Parameter param;
    291269        ParameterHashmap::iterator itr = _vpParams.find(name);
    292270        if (itr == _vpParams.end()) {
     
    302280    }
    303281
    304     CGparameter getFPParam(const char *name)
    305     {
    306         CGparameter param;
     282    Parameter getFPParam(const char *name)
     283    {
     284        Parameter param;
    307285        ParameterHashmap::iterator itr = _fpParams.find(name);
    308286        if (itr == _fpParams.end()) {
     
    320298    void resetPrograms();
    321299
     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
     330    std::string _vpFile;
     331    std::string _fpFile;
     332
     333    ParameterHashmap _vpParams;
     334    ParameterHashmap _fpParams;
     335
    322336    CGprofile _vertexProfile;
    323337    CGprofile _fragmentProfile;
    324     std::string _vpFile;
     338
    325339    CGprogram _cgVP;
    326     std::string _fpFile;
    327340    CGprogram _cgFP;
    328     ParameterHashmap _vpParams;
    329     ParameterHashmap _fpParams;
    330341
    331342    static CGprofile _defaultVertexProfile;
Note: See TracChangeset for help on using the changeset viewer.