glslfx.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_IMAGING_HIO_GLSLFX_H
#define PXR_IMAGING_HIO_GLSLFX_H
 
 
#include "pxr/pxr.h"
#include "pxr/imaging/hio/api.h"
#include "pxr/imaging/hio/glslfxConfig.h"
 
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/staticTokens.h"
 
#include <string>
#include <vector>
#include <set>
#include <map>
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
// Version 1 - Added HioGlslfx::ExtractImports
//
#define HIO_GLSLFX_API_VERSION 1
 
#define HIO_GLSLFX_TOKENS       \
    (glslfx)                    \
                                \
    (fragmentShader)            \
    (geometryShader)            \
    (geometryShaderInjection)   \
    (preamble)                  \
    (tessControlShader)         \
    (tessEvalShader)            \
    (postTessControlShader)     \
    (postTessVertexShader)      \
    (vertexShader)              \
    (vertexShaderInjection)     \
                                \
    (surfaceShader)             \
    (displacementShader)        \
    (volumeShader)              \
    ((defVal, "default"))
 
 
TF_DECLARE_PUBLIC_TOKENS(HioGlslfxTokens, HIO_API, HIO_GLSLFX_TOKENS);
 
class HioGlslfx
{
public:
    HIO_API
    HioGlslfx();
 
    HIO_API
    HioGlslfx(
        std::string const & filePath,
        TfToken const & technique = HioGlslfxTokens->defVal);
 
    HIO_API
    HioGlslfx(
        std::istream &is,
        TfToken const & technique = HioGlslfxTokens->defVal);
 
    HIO_API
    HioGlslfxConfig::Parameters GetParameters() const;
 
    HIO_API
    HioGlslfxConfig::Textures GetTextures() const;
 
    HIO_API
    HioGlslfxConfig::Attributes GetAttributes() const;
 
    HIO_API
    HioGlslfxConfig::MetadataDictionary GetMetadata() const;
 
    HIO_API
    bool IsValid(std::string *reason=NULL) const;
 
 
    HIO_API
    std::string GetSurfaceSource() const;
 
    HIO_API
    std::string GetDisplacementSource() const;
 
    HIO_API
    std::string GetVolumeSource() const;
 
 
    HIO_API
    VtDictionary GetLayoutAsDictionary(const TfTokenVector &shaderStageKeys,
                                       std::string *errorStr) const;
 
    HIO_API
    std::string GetSource(const TfToken &shaderStageKey) const;
 
    const std::string &GetFilePath() const { return _globalContext.filename; }
 
    const std::set<std::string>& GetFiles() const { return _seenFiles; }
 
    size_t GetHash() const { return _hash; }
 
    HIO_API
    static std::vector<std::string> ExtractImports(const std::string& filename);
 
private:
    class _ParseContext {
    public:
        _ParseContext() { }
 
        _ParseContext(std::string const & filePath) :
            filename(filePath), lineNo(0), version(-1.0) { }
 
        std::string filename;
        int lineNo;
        double version;
        std::string currentLine;
        std::string currentSectionType;
        std::string currentSectionId;
        std::vector<std::string> imports;
    };
 
private:
    bool _ProcessFile(std::string const & filePath,
                      _ParseContext & context);
    bool _ProcessInput(std::istream * input,
                       _ParseContext & context);
    bool _ProcessImport(_ParseContext & context);
    bool _ParseSectionLine(_ParseContext & context);
    bool _ParseGLSLSectionLine(std::vector<std::string> const &tokens,
                               _ParseContext & context);
    bool _ParseLayoutSectionLine(std::vector<std::string> const &tokens,
                                 _ParseContext & context);
    bool _ParseVersionLine(std::vector<std::string> const &tokens,
                           _ParseContext & context);
    bool _ParseConfigurationLine(_ParseContext & context);
    bool _ComposeConfiguration(std::string *reason);
 
    std::string _GetLayout(const TfToken &shaderStageKey) const;
    std::string _GetSource(const TfToken &shaderStageKey) const;
 
    std::string _GetLayoutAsString(const TfTokenVector &shaderStageKeys) const;
 
private:
    _ParseContext _globalContext;
 
    typedef std::map<std::string, std::string> _SourceMap;
 
    _SourceMap _sourceMap;
    _SourceMap _layoutMap;
    _SourceMap _configMap;
    std::vector<std::string> _configOrder;
    std::set<std::string> _seenFiles;
 
    std::unique_ptr<HioGlslfxConfig> _config;
 
    TfToken _technique;
    
    bool _valid;
    std::string _invalidReason; // if _valid is false, reason why
    size_t _hash;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif