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)            \
    (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
    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 _ParseVersionLine(std::vector<std::string> const &tokens,
                           _ParseContext & context);
    bool _ParseConfigurationLine(_ParseContext & context);
    bool _ComposeConfiguration(std::string *reason);
    std::string _GetSource(const TfToken &shaderStageKey) const;

private:
    _ParseContext _globalContext;

    typedef std::map<std::string, std::string> _SourceMap;

    _SourceMap _sourceMap;
    _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