material_resource.hpp

// Copyright [2015] Albert Huang

#ifndef SCENEVIEW_MATERIAL_RESOURCE_HPP__
#define SCENEVIEW_MATERIAL_RESOURCE_HPP__

#include <map>
#include <memory>
#include <utility>
#include <vector>

#include <sceneview/shader_resource.hpp>
#include <sceneview/geometry_resource.hpp>
#include <sceneview/shader_uniform.hpp>

class QOpenGLTexture;

namespace sv {

class MaterialResource {
  public:
    typedef std::shared_ptr<MaterialResource> Ptr;

    typedef std::shared_ptr<QOpenGLTexture> TexturePtr;

    typedef std::map<QString, TexturePtr> TextureDictionary;

    typedef std::map<QString, TexturePtr> Textures;

    const ShaderResource::Ptr& Shader() { return shader_; }

    ShaderUniformMap& ShaderParameters() { return shader_parameters_; }

    void SetParam(const QString& name, int val);

    void SetParam(const QString& name, const std::vector<int>& val);

    void SetParam(const QString& name, float val);

    void SetParam(const QString& name,
        float val1, float val2);

    void SetParam(const QString& name,
        float val1, float val2, float val3);

    void SetParam(const QString& name,
        float val1, float val2, float val3, float val4);

    void SetParam(const QString& name, const std::vector<float>& val);

    void SetParam(const QString& name, const QMatrix4x4& value);

    void AddTexture(const QString& name, const TexturePtr& texture);

    const TextureDictionary& GetTextures() { return textures_; }

    void SetTwoSided(bool two_sided);

    bool TwoSided() const { return two_sided_; }

    void SetDepthWrite(bool val) { depth_write_ = val; }

    bool DepthWrite() const { return depth_write_; }

    void SetDepthTest(bool val) { depth_test_ = val; }

    bool DepthTest() const { return depth_test_; }

    void SetDepthFunc(GLenum func) { depth_func_ = func; }

    GLenum DepthFunc() const { return depth_func_; }

    void SetColorWrite(bool val) { color_write_ = val; }

    bool ColorWrite() const { return color_write_; }

    void SetPointSize(float size) { point_size_ = size; }

    float PointSize() const { return point_size_; }

    void SetLineWidth(float line_width) { line_width_ = line_width; }

    float LineWidth() const { return line_width_; }

    void SetBlend(bool value) { blend_ = value; }

    bool Blend() const { return blend_; }

    void SetBlendFunc(GLenum sfactor, GLenum dfactor) {
      blend_sfactor_ = sfactor;
      blend_dfactor_ = dfactor;
    }

    void BlendFunc(GLenum* sfactor, GLenum* dfactor) {
      *sfactor = blend_sfactor_;
      *dfactor = blend_dfactor_;
    }

  private:
    friend class ResourceManager;

    MaterialResource(const QString& name, ShaderResource::Ptr shader);

    const QString name_;

    ShaderResource::Ptr shader_;

    ShaderUniformMap shader_parameters_;

    bool two_sided_ = false;

    bool depth_write_ = true;

    bool depth_test_ = true;

    GLenum depth_func_ = GL_LESS;

    bool color_write_ = true;

    float point_size_ = 1;

    float line_width_ = 1;

    bool blend_ = false;

    GLenum blend_sfactor_ = GL_ONE;

    GLenum blend_dfactor_ = GL_ZERO;

    TextureDictionary textures_;
};

}  // namespace sv

#endif  // SCENEVIEW_MATERIAL_RESOURCE_HPP__