Shader.h

//
//  Shader.h
//  libraries/gpu/src/gpu
//
//  Created by Sam Gateau on 2/27/2015.
//  Copyright 2014 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_gpu_Shader_h
#define hifi_gpu_Shader_h
 
#include "Resource.h"
#include <string>
#include <memory>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <map>
#include <functional>
#include <shaders/Shaders.h>
#include <QUrl>
 
namespace gpu {
 
class Shader {
public:
    // unique identifier of a shader
    using ID = uint32_t;
 
    enum Type
    {
        VERTEX = 0,
        PIXEL,
        FRAGMENT = PIXEL,
        GEOMETRY,
        NUM_DOMAINS,
 
        PROGRAM,
    };
 
    typedef std::shared_ptr<Shader> Pointer;
    typedef std::vector<Pointer> Shaders;
 
    using Source = shader::Source;
    using Reflection = shader::Reflection;
    using Dialect = shader::Dialect;
    using Variant = shader::Variant;
 
    struct CompilationLog {
        std::string message;
 
        bool compiled{ false };
 
        CompilationLog() {}
        CompilationLog(const CompilationLog& src) : message(src.message), compiled(src.compiled) {}
    };
    using CompilationLogs = std::vector<CompilationLog>;
 
    static const Source& getShaderSource(uint32_t id);
 
    static const Source& getVertexShaderSource(uint32_t id) { return getShaderSource(id); }
 
    static const Source& getFragmentShaderSource(uint32_t id) { return getShaderSource(id); }
 
    static Pointer createVertex(const Source& source);
 
    static Pointer createPixel(const Source& source);
 
    static Pointer createVertex(uint32_t shaderId);
 
    static Pointer createPixel(uint32_t shaderId);
 
    static Pointer createProgram(uint32_t programId);
 
    static Pointer createProgram(const Pointer& vertexShader, const Pointer& pixelShader);
 
    ~Shader();
 
    ID getID() const;
 
    Type getType() const { return _type; }
 
    bool isProgram() const { return getType() > NUM_DOMAINS; }
 
    bool isDomain() const { return getType() < NUM_DOMAINS; }
 
    const Source& getSource() const { return _source; }
 
    const Shaders& getShaders() const { return _shaders; }
 
    Reflection getReflection(shader::Dialect dialect, shader::Variant variant) const;
 
    Reflection getReflection() const;
 
 
    using CompilationHandler = std::function<bool(const Shader&, const std::string&, CompilationLog&, std::string&)>;
 
    bool compilationHasFailed() const { return _compilationHasFailed; }
 
    const CompilationLogs& getCompilationLogs() const { return _compilationLogs; }
 
    void setCompilationHasFailed(bool compilationHasFailed) { _compilationHasFailed = compilationHasFailed; }
 
    void setCompilationLogs(const CompilationLogs& logs) const;
 
    // Object representing shader on the API-specific backend side.
    const GPUObjectPointer gpuObject{};
 
protected:
    Shader(Type type, const Source& source, bool dynamic);
 
    Shader(Type type, const Pointer& vertex, const Pointer& geometry, const Pointer& pixel);
 
    const Source _source;
 
    const Shaders _shaders;
 
     
    const Type _type;
 
    mutable CompilationLogs _compilationLogs;
 
    bool _compilationHasFailed{ false };
 
    static ShaderPointer createOrReuseDomainShader(Type type, uint32_t sourceId);
 
    //. The IDs of the shaders in a program make its key.
    using ProgramMapKey = glm::uvec3;
 
    class ProgramKeyLess {
    public:
        bool operator()(const ProgramMapKey& l, const ProgramMapKey& r) const {
            if (l.x == r.x) {
                if (l.y == r.y) {
                    return (l.z < r.z);
                } else {
                    return (l.y < r.y);
                }
            } else {
                return (l.x < r.x);
            }
        }
    };
    using ProgramMap = std::map<ProgramMapKey, std::weak_ptr<Shader>, ProgramKeyLess>;
 
    static ProgramMap _programMap;
 
    static ShaderPointer createOrReuseProgramShader(Type type,
                                                    const Pointer& vertexShader,
                                                    const Pointer& geometryShader,
                                                    const Pointer& pixelShader);
    friend class Serializer;
    friend class Deserializer;
};
 
typedef Shader::Pointer ShaderPointer;
typedef std::vector<ShaderPointer> Shaders;
 
};  // namespace gpu
 
#endif