material.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include "gpu_program.h"
#include <engine/assets/asset_handle.h>
 
#include <graphics/format.h>
#include <graphics/graphics.h>
#include <graphics/texture.h>
#include <math/math.h>
#include <reflection/registration.h>
#include <serialization/serialization.h>
 
 
namespace unravel
{
 
struct shadow_cutout_state;
 
enum class cull_type : std::uint32_t
{
    none,              
    clockwise,         
    counter_clockwise, 
};
 
enum class alpha_mode : std::uint32_t
{
    opaque, 
    mask,   
    blend,  
};
 
class material : public crtp_meta_type<material>
{
public:
    SERIALIZABLE(material)
 
    using sptr = std::shared_ptr<material>;
    using wptr = std::weak_ptr<material>;
    using uptr = std::unique_ptr<material>;
 
    material() = default;
    virtual ~material() = default;
 
 
    virtual auto submit(gpu_program* program) const -> bool;
 
    auto get_cull_type() const -> cull_type;
 
    void set_cull_type(cull_type val);
 
    virtual auto get_render_states(bool apply_cull = true, bool depth_write = true, bool depth_test = true) const
        -> uint64_t;
 
    static auto default_color_map() -> asset_handle<gfx::texture>&;
 
    static auto default_normal_map() -> asset_handle<gfx::texture>&;
 
    virtual auto clone() const -> material::sptr;
 
protected:
    cull_type cull_type_ = cull_type::counter_clockwise;
};
 
class pbr_material : public crtp_meta_type<pbr_material, material>
{
public:
    SERIALIZABLE(pbr_material)
 
    auto clone() const -> std::shared_ptr<material> override;
 
    auto get_base_color() const -> const math::color&
    {
        return base_color_;
    }
 
    void set_base_color(const math::color& val)
    {
        base_color_ = val;
    }
 
    auto get_subsurface_color() const -> const math::color&
    {
        return subsurface_color_;
    }
 
    void set_subsurface_color(const math::color& val)
    {
        subsurface_color_ = val;
    }
 
    auto get_emissive_color() const -> const math::color&
    {
        return emissive_color_;
    }
 
    void set_emissive_color(const math::color& val)
    {
        emissive_color_ = val;
    }
 
    auto get_emissive_intensity() const -> float
    {
        return emissive_intensity_;
    }
 
    void set_emissive_intensity(float val)
    {
        emissive_intensity_ = val;
    }
 
    auto get_roughness() const -> float
    {
        return surface_data_.x;
    }
 
    void set_roughness(float roughness)
    {
        surface_data_.x = roughness;
    }
 
    auto get_metalness() const -> float
    {
        return surface_data_.y;
    }
 
    void set_metalness(float metalness)
    {
        surface_data_.y = metalness;
    }
 
    auto get_bumpiness() const -> float
    {
        return surface_data_.z;
    }
 
    void set_bumpiness(float bumpiness)
    {
        surface_data_.z = bumpiness;
    }
 
    auto get_alpha_mode() const -> alpha_mode
    {
        return alpha_mode_;
    }
 
    void set_alpha_mode(alpha_mode mode);
 
    auto get_alpha_cutoff() const -> float
    {
        return alpha_cutoff_;
    }
 
    void set_alpha_cutoff(float cutoff);
 
    [[nodiscard]] auto uses_alpha_cutout() const -> bool;
 
    [[nodiscard]] auto casts_shadow() const -> bool;
 
    [[nodiscard]] auto make_shadow_cutout_state() const -> shadow_cutout_state;
 
    void infer_alpha_mode_from_legacy_cutoff();
 
    auto get_surface_data() const -> const math::vec4&
    {
        return surface_data_;
    }
 
    auto get_surface_data2() const -> math::vec4
    {
        math::vec4 surface_data2{};
 
        surface_data2[0] = metalness_roughness_combined() ? 1.0f : 0.0f;
        const auto& normal_map = normal_map_ ? normal_map_ : default_normal_map();
        const auto normal_texture = normal_map.get();
        surface_data2[1] =
            normal_texture && gfx::normal_map_needs_z_reconstruction(normal_texture->info.format) ? 1.0f : 0.0f;
 
        return surface_data2;
    }
 
    auto metalness_roughness_combined() const -> bool
    {
        return metalness_map_ == roughness_map_;
    }
 
    auto get_tiling() const -> const math::vec2&
    {
        return tiling_;
    }
 
    void set_tiling(const math::vec2& tiling)
    {
        tiling_ = tiling;
    }
 
    auto get_dither_threshold() const -> const math::vec2&
    {
        return dither_threshold_;
    }
 
    void set_dither_threshold(const math::vec2& threshold)
    {
        dither_threshold_ = threshold;
    }
 
    auto get_color_map() const -> const asset_handle<gfx::texture>&
    {
        return color_map_;
    }
 
    void set_color_map(const asset_handle<gfx::texture>& val)
    {
        color_map_ = val;
    }
 
    auto get_normal_map() const -> const asset_handle<gfx::texture>&
    {
        return normal_map_;
    }
 
    void set_normal_map(const asset_handle<gfx::texture>& val)
    {
        normal_map_ = val;
    }
 
    auto get_roughness_map() const -> const asset_handle<gfx::texture>&
    {
        return roughness_map_;
    }
 
    void set_roughness_map(const asset_handle<gfx::texture>& val)
    {
        roughness_map_ = val;
    }
 
    auto get_metalness_map() const -> const asset_handle<gfx::texture>&
    {
        return metalness_map_;
    }
 
    void set_metalness_map(const asset_handle<gfx::texture>& val)
    {
        metalness_map_ = val;
    }
 
    auto get_ao_map() const -> const asset_handle<gfx::texture>&
    {
        return ao_map_;
    }
 
    void set_ao_map(const asset_handle<gfx::texture>& val)
    {
        ao_map_ = val;
    }
 
    auto get_emissive_map() const -> const asset_handle<gfx::texture>&
    {
        return emissive_map_;
    }
 
    void set_emissive_map(const asset_handle<gfx::texture>& val)
    {
        emissive_map_ = val;
    }
 
private:
    void sync_surface_alpha_channel();
 
    math::color base_color_{
        1.0f,
        1.0f,
        1.0f, 
        1.0f  
    };
    math::color subsurface_color_{
        0.0f,
        0.0f,
        0.0f, 
        0.8f  
    };
    math::color emissive_color_{
        0.0f,
        0.0f,
        0.0f, 
        0.0f  
    };
    float emissive_intensity_{1.0f};
    alpha_mode alpha_mode_{alpha_mode::opaque};
    float alpha_cutoff_{0.5f};
    math::vec4 surface_data_{
        0.3f, 
        0.0f, 
        1.0f, 
        0.25f 
    };
    math::vec2 tiling_{
        1.0f,
        1.0f 
    };
    math::vec2 dither_threshold_{
        0.5f, 
        0.0f  
    };
 
    asset_handle<gfx::texture> color_map_;
    asset_handle<gfx::texture> normal_map_;
    asset_handle<gfx::texture> roughness_map_;
    asset_handle<gfx::texture> metalness_map_;
    asset_handle<gfx::texture> emissive_map_;
    asset_handle<gfx::texture> ao_map_;
};
 
} // namespace unravel