zy4n/Z3D
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed bugs in lazy shader compilation.

Browse Source
This commit is contained in:
zy4n
2025-03-03 20:45:30 +01:00
parent 925125e99b
commit fde6a2fd7b
26 changed files with 234 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -181,6 +181,8 @@ add_executable(z3d main.cpp
include/opengl/data_uploaders/shader_program_compiler.hpp include/opengl/data_uploaders/shader_program_compiler.hpp
include/shader_program/metadata_type.hpp include/shader_program/metadata_type.hpp
source/opengl/data_uploaders/shader_compiler.cpp source/opengl/data_uploaders/shader_compiler.cpp
include/shader_program/geometry.hpp
include/shader_program/stage.hpp
) )
target_include_directories(z3d PRIVATE include) target_include_directories(z3d PRIVATE include)

3
include/assets/components/mesh_vertex_components.hpp
View File

@@ -22,7 +22,8 @@ inline constexpr type color = 3;
inline constexpr type reflectance = 4; inline constexpr type reflectance = 4;
} }
enum class flags : std::uint8_t { enum class flags : std::uint8_t
{
none = 0, none = 0,
position = 1 << indices::position, position = 1 << indices::position,
normal = 1 << indices::normal, normal = 1 << indices::normal,

3
include/assets/components/point_cloud_vertex_components.hpp
View File

@@ -20,7 +20,8 @@ inline constexpr type color = 2;
inline constexpr type reflectance = 3; inline constexpr type reflectance = 3;
} // namespace indices } // namespace indices
enum class flags : std::uint8_t { enum class flags : std::uint8_t
{
none = 0, none = 0,
position = 1 << indices::position, position = 1 << indices::position,
normal = 1 << indices::normal, normal = 1 << indices::normal,

3
include/assets/components/texture_components.hpp
View File

@@ -11,7 +11,8 @@ using green = std::uint8_t;
using blue = std::uint8_t; using blue = std::uint8_t;
using luminance = std::uint8_t; using luminance = std::uint8_t;
enum class flags : std::uint8_t { enum class flags : std::uint8_t
{
none = 0, none = 0,
luminance = 1 << 1, luminance = 1 << 1,
red = 1 << 2, red = 1 << 2,

86
include/rendering/requirements/mesh_requirements.hpp
View File

@@ -3,6 +3,7 @@
#include "assets/components/material_components.hpp" #include "assets/components/material_components.hpp"
#include "assets/components/mesh_vertex_components.hpp" #include "assets/components/mesh_vertex_components.hpp"
#include "shader_program/features/mesh_features.hpp" #include "shader_program/features/mesh_features.hpp"
#include "util/enum_bitfield_operators.hpp"
#include <array> #include <array>
@@ -11,16 +12,16 @@ namespace rendering::requirements::mesh
struct type struct type
{ {
shader_program::capabilities::mesh::indices::type shader_program_requirement_index{}; shader_program::features::mesh::indices::type shader_program_requirement_index{};
components::mesh_vertex::flags vertex_requirements{ components::mesh_vertex::flags vertex_requirements{
components::mesh_vertex::flags::none components::mesh_vertex::flags::none
}; };
material_component::flags material_requirements{ components::material::flags material_requirements{
material_component::flags::none components::material::flags::none
}; };
}; };
enum class flags : int enum class flags : std::uint8_t
{ {
none = 0, none = 0,
position = 1 << 0, position = 1 << 0,
@@ -32,33 +33,33 @@ enum class flags : int
}; };
constexpr inline auto position = type{ constexpr inline auto position = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::position, .shader_program_requirement_index = shader_program::features::mesh::indices::position,
.vertex_requirements = components::mesh_vertex::flags::position .vertex_requirements = components::mesh_vertex::flags::position
}; };
constexpr inline auto lit = type{ constexpr inline auto lit = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::lit, .shader_program_requirement_index = shader_program::features::mesh::indices::lit,
.vertex_requirements = components::mesh_vertex::flags::normal, .vertex_requirements = components::mesh_vertex::flags::normal,
.material_requirements = material_component::flags::surface_properties .material_requirements = components::material::flags::surface_properties
}; };
constexpr inline auto point = type{ constexpr inline auto point = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::point .shader_program_requirement_index = shader_program::features::mesh::indices::point
}; };
constexpr inline auto textured = type{ constexpr inline auto textured = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::textured, .shader_program_requirement_index = shader_program::features::mesh::indices::textured,
.vertex_requirements = components::mesh_vertex::flags::tex_coord, .vertex_requirements = components::mesh_vertex::flags::tex_coord,
.material_requirements = material_component::flags::texture, .material_requirements = components::material::flags::texture,
}; };
constexpr inline auto uniform_color = type{ constexpr inline auto uniform_color = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::uniform_color .shader_program_requirement_index = shader_program::features::mesh::indices::uniform_color
}; };
constexpr inline auto uniform_alpha = type{ constexpr inline auto uniform_alpha = type{
.shader_program_requirement_index = shader_program::capabilities::mesh::indices::uniform_alpha, .shader_program_requirement_index = shader_program::features::mesh::indices::uniform_alpha,
.material_requirements = material_component::flags::transparency .material_requirements = components::material::flags::transparency
}; };
constexpr inline auto all = std::array{ constexpr inline auto all = std::array{
@@ -67,61 +68,4 @@ constexpr inline auto all = std::array{
} }
DEFINE_ENUM_BITFIELD_OPERATORS(rendering::requirements::mesh::flags)
[[nodiscard]] constexpr rendering::requirements::mesh::flags operator|(
const rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b
) {
return static_cast<rendering::requirements::mesh::flags>(static_cast<int>(a) | static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::mesh::flags operator&(
const rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b
) {
return static_cast<rendering::requirements::mesh::flags>(static_cast<int>(a) & static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::mesh::flags operator^(
const rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b
) {
return static_cast<rendering::requirements::mesh::flags>(static_cast<int>(a) ^ static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::mesh::flags operator~(const rendering::requirements::mesh::flags& a) {
return static_cast<rendering::requirements::mesh::flags>(~static_cast<int>(a));
}
constexpr rendering::requirements::mesh::flags& operator|=(rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b) {
return a = a | b;
}
constexpr rendering::requirements::mesh::flags& operator&=(rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b) {
return a = a & b;
}
constexpr rendering::requirements::mesh::flags& operator^=(rendering::requirements::mesh::flags& a, const rendering::requirements::mesh::flags& b) {
return a = a ^ b;
}
[[nodiscard]] constexpr bool operator<(
rendering::requirements::mesh::flags lhs, rendering::requirements::mesh::flags rhs
) {
return static_cast<int>(lhs) < static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator<=(
rendering::requirements::mesh::flags lhs, rendering::requirements::mesh::flags rhs
) {
return static_cast<int>(lhs) <= static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator>(
rendering::requirements::mesh::flags lhs, rendering::requirements::mesh::flags rhs
) {
return static_cast<int>(lhs) > static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator>=(
rendering::requirements::mesh::flags lhs, rendering::requirements::mesh::flags rhs
) {
return static_cast<int>(lhs) >= static_cast<int>(rhs);
}

76
include/rendering/requirements/point_cloud_requirements.hpp
View File

@@ -4,20 +4,21 @@
#include "shader_program/features/point_cloud_features.hpp" #include "shader_program/features/point_cloud_features.hpp"
#include <array> #include <array>
#include "util/enum_bitfield_operators.hpp"
namespace rendering::requirements::point_cloud namespace rendering::requirements::point_cloud
{ {
struct type struct type
{ {
shader_program::capabilities::point_cloud::indices::type shader_program_requirement_index{}; shader_program::features::point_cloud::indices::type shader_program_requirement_index{};
components::point_cloud_vertex::flags vertex_requirements{ components::point_cloud_vertex::flags vertex_requirements{
components::point_cloud_vertex::flags::none components::point_cloud_vertex::flags::none
}; };
}; };
enum class flags : int enum class flags : std::uint8_t
{ {
none = 0, none = 0,
position = 1 << 0, position = 1 << 0,
@@ -30,30 +31,30 @@ enum class flags : int
constexpr inline auto position = type{ constexpr inline auto position = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::position, .shader_program_requirement_index = shader_program::features::point_cloud::indices::position,
.vertex_requirements = components::point_cloud_vertex::flags::position .vertex_requirements = components::point_cloud_vertex::flags::position
}; };
constexpr inline auto rainbow = type{ constexpr inline auto rainbow = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::rainbow .shader_program_requirement_index = shader_program::features::point_cloud::indices::rainbow
}; };
constexpr inline auto vertex_color = type{ constexpr inline auto vertex_color = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::vertex_color, .shader_program_requirement_index = shader_program::features::point_cloud::indices::vertex_color,
.vertex_requirements = components::point_cloud_vertex::flags::color .vertex_requirements = components::point_cloud_vertex::flags::color
}; };
constexpr inline auto uniform_color = type{ constexpr inline auto uniform_color = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::uniform_color .shader_program_requirement_index = shader_program::features::point_cloud::indices::uniform_color
}; };
constexpr inline auto normal = type{ constexpr inline auto normal = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::normal, .shader_program_requirement_index = shader_program::features::point_cloud::indices::normal,
.vertex_requirements = components::point_cloud_vertex::flags::normal .vertex_requirements = components::point_cloud_vertex::flags::normal
}; };
constexpr inline auto reflectance = type{ constexpr inline auto reflectance = type{
.shader_program_requirement_index = shader_program::capabilities::point_cloud::indices::reflectance, .shader_program_requirement_index = shader_program::features::point_cloud::indices::reflectance,
.vertex_requirements = components::point_cloud_vertex::flags::reflectance .vertex_requirements = components::point_cloud_vertex::flags::reflectance
}; };
@@ -62,61 +63,4 @@ constexpr inline auto all = std::array{
}; };
} }
DEFINE_ENUM_BITFIELD_OPERATORS(rendering::requirements::point_cloud::flags)
[[nodiscard]] constexpr rendering::requirements::point_cloud::flags operator|(
const rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b
) {
return static_cast<rendering::requirements::point_cloud::flags>(static_cast<int>(a) | static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::point_cloud::flags operator&(
const rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b
) {
return static_cast<rendering::requirements::point_cloud::flags>(static_cast<int>(a) & static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::point_cloud::flags operator^(
const rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b
) {
return static_cast<rendering::requirements::point_cloud::flags>(static_cast<int>(a) ^ static_cast<int>(b));
}
[[nodiscard]] constexpr rendering::requirements::point_cloud::flags operator~(const rendering::requirements::point_cloud::flags& a) {
return static_cast<rendering::requirements::point_cloud::flags>(~static_cast<int>(a));
}
constexpr rendering::requirements::point_cloud::flags& operator|=(rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b) {
return a = a | b;
}
constexpr rendering::requirements::point_cloud::flags& operator&=(rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b) {
return a = a & b;
}
constexpr rendering::requirements::point_cloud::flags& operator^=(rendering::requirements::point_cloud::flags& a, const rendering::requirements::point_cloud::flags& b) {
return a = a ^ b;
}
[[nodiscard]] constexpr bool operator<(
rendering::requirements::point_cloud::flags lhs, rendering::requirements::point_cloud::flags rhs
) {
return static_cast<int>(lhs) < static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator<=(
rendering::requirements::point_cloud::flags lhs, rendering::requirements::point_cloud::flags rhs
) {
return static_cast<int>(lhs) <= static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator>(
rendering::requirements::point_cloud::flags lhs, rendering::requirements::point_cloud::flags rhs
) {
return static_cast<int>(lhs) > static_cast<int>(rhs);
}
[[nodiscard]] constexpr bool operator>=(
rendering::requirements::point_cloud::flags lhs, rendering::requirements::point_cloud::flags rhs
) {
return static_cast<int>(lhs) >= static_cast<int>(rhs);
}

3
include/shader_program/attributes/mesh_attributes.hpp
View File

@@ -8,7 +8,8 @@
namespace shader_program::attributes::mesh namespace shader_program::attributes::mesh
{ {
enum class flags : unsigned { enum class flags : std::uint8_t
{
none = 0, none = 0,
position = 1 << 0, position = 1 << 0,
normal = 1 << 1, normal = 1 << 1,

3
include/shader_program/attributes/point_cloud_attributes.hpp
View File

@@ -8,7 +8,8 @@
namespace shader_program::attributes::point_cloud namespace shader_program::attributes::point_cloud
{ {
enum class flags : unsigned { enum class flags : std::uint8_t
{
none = 0, none = 0,
position = 1 << 0, position = 1 << 0,
normal = 1 << 1, normal = 1 << 1,

4
include/shader_program/features/mesh_features.hpp
View File

@@ -35,7 +35,7 @@ constexpr inline type texture = 7;
constexpr inline type uniform_color = 8; constexpr inline type uniform_color = 8;
} }
enum class flags : unsigned enum class flags : std::uint16_t
{ {
none = 0, none = 0,
face = 1 << indices::face, face = 1 << indices::face,
@@ -46,7 +46,7 @@ enum class flags : unsigned
alpha = 1 << indices::alpha, alpha = 1 << indices::alpha,
lighting = 1 << indices::lighting, lighting = 1 << indices::lighting,
texture = 1 << indices::texture, texture = 1 << indices::texture,
uniform_color = 1 << indices::uniform_color, uniform_color = 1 << indices::uniform_color
}; };
constexpr inline auto face = type{ constexpr inline auto face = type{

2
include/shader_program/features/point_cloud_features.hpp
View File

@@ -33,7 +33,7 @@ constexpr inline type uniform_color = 5;
constexpr inline type rainbow = 6; constexpr inline type rainbow = 6;
} }
enum class flags : unsigned enum class flags : std::uint8_t
{ {
none = 0, none = 0,
square = 1 << indices::square, square = 1 << indices::square,

21
include/shader_program/geometry.hpp Normal file
View File

@@ -0,0 +1,21 @@
#pragma once
#include <cinttypes>
#include <array>
#include <string_view>
namespace shader_program::geometry
{
enum class types : std::uint8_t
{
mesh = 0,
point_cloud = 1
};
inline constexpr auto names = std::array<std::string_view, 2>{
"mesh", "point_cloud"
};
}

233
include/shader_program/metadata_type.hpp
View File

@@ -3,28 +3,14 @@
#include <limits> #include <limits>
#include <utility> #include <utility>
#include "geometry.hpp"
#include "stage.hpp"
#include "features/mesh_features.hpp" #include "features/mesh_features.hpp"
#include "features/point_cloud_features.hpp" #include "features/point_cloud_features.hpp"
namespace shader_program namespace shader_program
{ {
enum class geometries : int
{
mesh = 0,
point_cloud = 1
};
enum class stages : GLenum
{
vertex = GL_VERTEX_SHADER,
geometry = GL_GEOMETRY_SHADER,
fragment = GL_FRAGMENT_SHADER
};
union combined_feature_type union combined_feature_type
{ {
features::mesh::flags mesh; features::mesh::flags mesh;
@@ -35,185 +21,164 @@ union combined_feature_type
std::underlying_type_t<features::point_cloud::flags> std::underlying_type_t<features::point_cloud::flags>
>; >;
generic_type generic(const geometries geometry) const noexcept [[nodiscard]] generic_type generic(const geometry::types geometry) const noexcept
{ {
switch (geometry) switch (geometry)
{ {
case geometries::mesh: case geometry::types::mesh:
return static_cast<generic_type>(mesh); return static_cast<generic_type>(mesh);
case geometries::point_cloud: case geometry::types::point_cloud:
return static_cast<generic_type>(point_cloud); return static_cast<generic_type>(point_cloud);
} }
std::unreachable(); std::unreachable();
} }
void from_generic( void from_generic(
const geometries geometry, const geometry::types geometry,
generic_type new_features generic_type new_features
) noexcept { ) noexcept {
switch (geometry) switch (geometry)
{ {
case geometries::mesh: case geometry::types::mesh:
mesh = static_cast<features::mesh::flags>(new_features); mesh = static_cast<features::mesh::flags>(new_features);
case geometries::point_cloud: case geometry::types::point_cloud:
point_cloud = static_cast<features::point_cloud::flags>(new_features); point_cloud = static_cast<features::point_cloud::flags>(new_features);
} }
std::unreachable(); std::unreachable();
} }
}; };
template<typename T>
struct shader_features_set
{
T features, static_enable, dynamic_enable;
template<typename U>
[[nodiscard]] shader_features_set<U> cast() const noexcept
{
return {
.features = static_cast<U>(features),
.static_enable = static_cast<U>(static_enable),
.dynamic_enable = static_cast<U>(dynamic_enable)
};
}
[[nodiscard]] auto operator<=>(const shader_features_set& other) const noexcept requires std::unsigned_integral<T>
{
std::array<T, 6> pop_counts;
std::ranges::transform(
{
this->features, this->static_enable, this->dynamic_enable,
other.features, other.static_enable, other.dynamic_enable
},
pop_counts.begin(),
std::popcount<T>
);
return (
std::tie(pop_counts[0], pop_counts[1], pop_counts[2]) <=>
std::tie(pop_counts[3], pop_counts[4], pop_counts[5])
);
}
[[nodiscard]] auto operator<=>(const shader_features_set& other) const noexcept requires std::is_enum_v<T>
{
using integer_type = std::underlying_type_t<T>;
return this->cast<integer_type>() <=> other.cast<integer_type>();
}
// TODO this may not compile
[[nodiscard]] bool operator==(const shader_features_set& other) const noexcept = default;
};
struct metadata_type struct metadata_type
{ {
geometries geometry; union combined_feature_set_type {
stages stage; shader_features_set<features::mesh::flags> mesh;
combined_feature_type features; shader_features_set<features::point_cloud::flags> point_cloud;
combined_feature_type feature_toggles; };
std::pair<combined_feature_type::generic_type, combined_feature_type::generic_type> generic() const noexcept using generic_feature_type = std::common_type_t<
std::underlying_type_t<features::mesh::flags>,
std::underlying_type_t<features::point_cloud::flags>
>;
using generic_feature_set_type = shader_features_set<generic_feature_type>;
stage::types stage;
geometry::types geometry;
combined_feature_set_type feature_set;
[[nodiscard]] generic_feature_set_type generic_feature_set() const noexcept
{ {
switch (geometry) switch (geometry)
{ {
case geometries::mesh: case geometry::types::mesh:
return { return feature_set.mesh.cast<generic_feature_type>();
static_cast<combined_feature_type::generic_type>(features.mesh), case geometry::types::point_cloud:
static_cast<combined_feature_type::generic_type>(feature_toggles.mesh) return feature_set.point_cloud.cast<generic_feature_type>();
}; default:
case geometries::point_cloud:
return {
static_cast<combined_feature_type::generic_type>(features.point_cloud),
static_cast<combined_feature_type::generic_type>(feature_toggles.point_cloud)
};
}
std::unreachable(); std::unreachable();
} }
}
void from_generic( void from_generic_feature_set(const generic_feature_set_type& generic_feature_set) noexcept
combined_feature_type::generic_type new_features, {
combined_feature_type::generic_type new_feature_toggles
) noexcept {
switch (geometry) switch (geometry)
{ {
case geometries::mesh: case geometry::types::mesh:
features.mesh = static_cast<features::mesh::flags>(new_features); feature_set.mesh = generic_feature_set.cast<features::mesh::flags>();
feature_toggles.mesh = static_cast<features::mesh::flags>(new_feature_toggles); case geometry::types::point_cloud:
case geometries::point_cloud: feature_set.point_cloud = generic_feature_set.cast<features::point_cloud::flags>();
features.point_cloud = static_cast<features::point_cloud::flags>(new_features);
feature_toggles.point_cloud = static_cast<features::point_cloud::flags>(new_feature_toggles);
} }
std::unreachable(); std::unreachable();
} }
auto operator<=>(const metadata_type& other) const noexcept auto operator<=>(const metadata_type& other) const noexcept
{ {
if (this->geometry == other.geometry) if (this->stage != other.stage)
{ {
switch (this->geometry) return this->stage <=> other.stage;
{
case geometries::mesh:
return (
std::tie(this->stage, this->features.mesh, this->feature_toggles.mesh) <=>
std::tie(other.stage, other.features.mesh, other.feature_toggles.mesh)
);
case geometries::point_cloud:
return (
std::tie(this->stage, this->features.point_cloud, this->feature_toggles.point_cloud) <=>
std::tie(other.stage, other.features.point_cloud, other.feature_toggles.point_cloud)
);
} }
std::unreachable();
} if (this->geometry != other.geometry)
else
{ {
return this->geometry <=> other.geometry; return this->geometry <=> other.geometry;
} }
return this->generic_feature_set() <=> other.generic_feature_set();
} }
bool operator==(const metadata_type& other) const noexcept bool operator==(const metadata_type& other) const noexcept
{ {
if (this->geometry == other.geometry) if (this->stage != other.stage)
{ {
switch (this->geometry)
{
case geometries::mesh:
return (
std::tie(this->stage, this->features.mesh, this->feature_toggles.mesh) ==
std::tie(other.stage, other.features.mesh, other.feature_toggles.mesh)
);
case geometries::point_cloud:
return (
std::tie(this->stage, this->features.point_cloud, this->feature_toggles.point_cloud) ==
std::tie(other.stage, other.features.point_cloud, other.feature_toggles.point_cloud)
);
}
std::unreachable();
}
return false; return false;
} }
if (this->geometry != other.geometry)
{
return false;
}
return this->generic_feature_set() == other.generic_feature_set();
}
struct feature_ignorant_less struct feature_ignorant_less
{ {
bool operator()(const metadata_type& a, const metadata_type& b) const bool operator()(const metadata_type& a, const metadata_type& b) const
{ {
return ( return (
std::tie(a.geometry, a.stage) < std::tie(a.stage, a.geometry) <
std::tie(a.geometry, b.stage) std::tie(b.stage, a.geometry)
); );
} }
}; };
struct feature_count_less
{
bool operator()(const metadata_type& a, const metadata_type& b) const
{
if (a.geometry == b.geometry)
{
int feature_count{}, feature_toggle_count{};
int other_feature_count{}, other_feature_toggle_count{};
constexpr auto count_features = []<typename T>(const T features)
{
using int_type = std::underlying_type_t<T>;
using uint_type = std::make_unsigned_t<int_type>;
return std::popcount(static_cast<uint_type>(static_cast<int_type>(features)));
};
switch (a.geometry)
{
case geometries::mesh:
for (auto& [ count, features ] : {
std::tie(feature_count, a.features.mesh),
std::tie(feature_toggle_count, a.feature_toggles.mesh),
std::tie(other_feature_count, b.features.mesh),
std::tie(other_feature_toggle_count, b.feature_toggles.mesh)
}) {
count = count_features(features);
}
case geometries::point_cloud:
for (auto& [ count, features ] : {
std::tie(feature_count, a.features.point_cloud),
std::tie(feature_toggle_count, a.feature_toggles.point_cloud),
std::tie(other_feature_count, b.features.point_cloud),
std::tie(other_feature_toggle_count, b.feature_toggles.point_cloud)
}) {
count = count_features(features);
}
default:
std::unreachable();
}
return (
std::tie(a.stage, feature_count, feature_toggle_count) <
std::tie(b.stage, other_feature_count, other_feature_toggle_count)
);
}
else
{
return a.geometry < b.geometry;
}
}
};
}; };
inline constexpr auto my_size = sizeof(metadata_type);
inline constexpr auto ma_align = alignof(metadata_type);
} }

29
include/shader_program/stage.hpp Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <cinttypes>
#include <array>
#include <string_view>
#include <GL/glew.h>
namespace shader_program::stage
{
enum class types : std::uint8_t
{
vertex = 0,
geometry = 1,
fragment = 2
};
inline constexpr auto names = std::array<std::string_view, 3>{
"vertex", "geometry", "fragment"
};
inline constexpr auto gl_enums = std::array<GLenum, 3>{
GL_VERTEX_SHADER,
GL_GEOMETRY_SHADER,
GL_FRAGMENT_SHADER
};
}

2
include/shader_program/uniforms/mesh_uniforms.hpp
View File

@@ -7,7 +7,7 @@
namespace shader_program::uniforms::mesh namespace shader_program::uniforms::mesh
{ {
enum class flags : unsigned enum class flags : std::uint16_t
{ {
none = 0, none = 0,
mvp_matrix = 1 << 0, mvp_matrix = 1 << 0,

2
include/shader_program/uniforms/point_cloud_uniforms.hpp
View File

@@ -6,7 +6,7 @@
namespace shader_program::uniforms::point_cloud namespace shader_program::uniforms::point_cloud
{ {
enum class flags : unsigned enum class flags : std::uint8_t
{ {
none = 0, none = 0,
mvp_matrix = 1 << 0, mvp_matrix = 1 << 0,

4
include/util/enum_bitfield_operators.hpp
View File

@@ -44,12 +44,12 @@ constexpr ENUM_TYPE operator<<( \
); \ ); \
} \ } \
\ \
constexpr ENUM_TYPE operator<<( \ constexpr ENUM_TYPE operator>>( \
ENUM_TYPE& lhs, \ ENUM_TYPE& lhs, \
int shift \ int shift \
) { \ ) { \
return static_cast<ENUM_TYPE>( \ return static_cast<ENUM_TYPE>( \
static_cast<std::underlying_type_t<ENUM_TYPE>>(lhs) << shift \ static_cast<std::underlying_type_t<ENUM_TYPE>>(lhs) >> shift \
); \ ); \
} \ } \
\ \

3
shaders/fragment_mesh_face.glsl
View File

@@ -1,7 +1,8 @@
#pragma STAGE: FRAGMENT #pragma STAGE: FRAGMENT
#pragma GEOMETRY: MESH #pragma GEOMETRY: MESH
#pragma FEATURES: FACE LINE V_L V_RGB V_A LIGHTING TEXTURE U_RGBA #pragma FEATURES: FACE LINE V_L V_RGB V_A LIGHTING TEXTURE U_RGBA
#pragma FEATURE_TOGGLES: LIGHTING TEXTURE #pragma STATIC_ENABLE: LIGHTING TEXTURE
#pragma DYNAMIC_ENABLE: FACE LINE V_L V_RGB V_A U_RGBA
//------------[ Uniforms ]------------// //------------[ Uniforms ]------------//

3
shaders/fragment_mesh_point.glsl
View File

@@ -1,7 +1,8 @@
#pragma STAGE: FRAGMENT #pragma STAGE: FRAGMENT
#pragma GEOMETRY: MESH #pragma GEOMETRY: MESH
#pragma FEATURES: POINT V_L V_RGB V_A LIGHTING U_RGBA #pragma FEATURES: POINT V_L V_RGB V_A LIGHTING U_RGBA
#pragma FEATURE_TOGGLES: #pragma STATIC_ENABLE:
#pragma DYNAMIC_ENABLE: V_L V_RGB V_A LIGHTING U_RGBA
//------------[ Inputs ]------------// //------------[ Inputs ]------------//

4
shaders/fragment_point_cloud.glsl
View File

@@ -1,8 +1,8 @@
#pragma STAGE: FRAGMENT #pragma STAGE: FRAGMENT
#pragma GEOMETRY: POINT_CLOUD #pragma GEOMETRY: POINT_CLOUD
#pragma FEATURES: SQUARE V_L V_RGB V_A LIGHTING U_RGBA RAINBOW #pragma FEATURES: SQUARE V_L V_RGB V_A LIGHTING U_RGBA RAINBOW
#pragma FEATURE_TOGGLES: #pragma STATIC_ENABLE:
#pragma DYNAMIC_ENABLE: V_L V_RGB V_A LIGHTING U_RGBA RAINBOW
//------------[ Inputs ]------------// //------------[ Inputs ]------------//
layout (location = 0) in vec4 frag_color; layout (location = 0) in vec4 frag_color;

4
shaders/vertex_mesh_face.glsl
View File

@@ -1,8 +1,8 @@
#pragma STAGE: VERTEX #pragma STAGE: VERTEX
#pragma GEOMETRY: MESH #pragma GEOMETRY: MESH
#pragma FEATURES: FACE LINE V_L V_RGB V_A LIGHTING TEXTURE U_RGBA #pragma FEATURES: FACE LINE V_L V_RGB V_A LIGHTING TEXTURE U_RGBA
#pragma FEATURE_TOGGLES: V_L V_RGB V_A LIGHTING TEXTURE U_RGBA #pragma STATIC_ENABLE: V_L V_RGB V_A LIGHTING TEXTURE U_RGBA
#pragma DYNAMIC_ENABLE: FACE LINE
#ifdef V_L #ifdef V_L
#ifdef V_RGB #ifdef V_RGB

4
shaders/vertex_mesh_point.glsl
View File

@@ -1,8 +1,8 @@
#pragma STAGE: VERTEX #pragma STAGE: VERTEX
#pragma GEOMETRY: MESH #pragma GEOMETRY: MESH
#pragma FEATURES: POINT V_L V_RGB V_A LIGHTING U_RGBA #pragma FEATURES: POINT V_L V_RGB V_A LIGHTING U_RGBA
#pragma FEATURE_TOGGLES: V_L V_RGB V_A LIGHTING U_RGBA #pragma STATIC_ENABLE: V_L V_RGB V_A LIGHTING U_RGBA
#pragma DYNAMIC_ENABLE:
#ifdef V_L #ifdef V_L
#ifdef V_RGB #ifdef V_RGB

4
shaders/vertex_point_cloud.glsl
View File

@@ -1,8 +1,8 @@
#pragma STAGE: VERTEX #pragma STAGE: VERTEX
#pragma GEOMETRY: POINT_CLOUD #pragma GEOMETRY: POINT_CLOUD
#pragma FEATURES: SQUARE V_L V_RGB V_A LIGHTING U_RGBA RAINBOW #pragma FEATURES: SQUARE V_L V_RGB V_A LIGHTING U_RGBA RAINBOW
#pragma FEATURE_TOGGLES: V_L V_RGB V_A LIGHTING U_RGBA RAINBOW #pragma STATIC_ENABLE: V_L V_RGB V_A LIGHTING U_RGBA RAINBOW
#pragma DYNAMIC_ENABLE:
#ifdef V_L #ifdef V_L
#ifdef V_RGB #ifdef V_RGB

47
source/opengl/data_uploaders/shader_compiler.cpp
View File

@@ -153,10 +153,10 @@ bool zgl::shader_program_compiler::parse_features_declaration(
) { ) {
switch (metadata.geometry) switch (metadata.geometry)
{ {
case shader_program::geometries::mesh: case shader_program::geometry::types::mesh:
parse_feature_tokens(tokens, mesh_feature_lookup, metadata.features.mesh); parse_feature_tokens(tokens, mesh_feature_lookup, metadata.features.mesh);
break; break;
case shader_program::geometries::point_cloud: case shader_program::geometry::types::point_cloud:
parse_feature_tokens(tokens, point_cloud_feature_lookup, metadata.features.point_cloud); parse_feature_tokens(tokens, point_cloud_feature_lookup, metadata.features.point_cloud);
break; break;
default: default:
@@ -172,11 +172,11 @@ bool zgl::shader_program_compiler::parse_feature_toggles_declaration(
) { ) {
switch (metadata.geometry) switch (metadata.geometry)
{ {
case shader_program::geometries::mesh: case shader_program::geometry::types::mesh:
parse_feature_tokens(tokens, mesh_feature_lookup, metadata.feature_toggles.mesh); parse_feature_tokens(tokens, mesh_feature_lookup, metadata.static_enable.mesh);
break; break;
case shader_program::geometries::point_cloud: case shader_program::geometry::types::point_cloud:
parse_feature_tokens(tokens, point_cloud_feature_lookup, metadata.feature_toggles.point_cloud); parse_feature_tokens(tokens, point_cloud_feature_lookup, metadata.static_enable.point_cloud);
break; break;
default: default:
ztu::logger::warn("Internal error: Unknown geometry index %.", static_cast<int>(metadata.geometry)); ztu::logger::warn("Internal error: Unknown geometry index %.", static_cast<int>(metadata.geometry));
@@ -236,27 +236,28 @@ auto zgl::shader_program_compiler::find_compatible_shader_source(
&std::pair<shader_program::metadata_type, dynamic_shader_source_store::id_type>::first &std::pair<shader_program::metadata_type, dynamic_shader_source_store::id_type>::first
); );
if (lower_it == shader_lookup.end()) { auto generic_requirement_feature_set = requirements.generic_feature_set();
return std::nullopt; const auto& required_features = generic_requirement_feature_set.features;
}
const auto required_features = requirements.features.generic(requirements.geometry);
while ( while (
lower_it != shader_lookup.end() and
lower_it->first.geometry == requirements.geometry and lower_it->first.geometry == requirements.geometry and
lower_it->first.stage == requirements.stage lower_it->first.stage == requirements.stage
) { ) {
const auto& data = lower_it->first; const auto& data = lower_it->first;
const auto& [ features, feature_toggles ] = data.generic(); const auto& [ features, static_enable, dynamic_enable ] = data.generic_feature_set();
const auto missing_features = required_features & ~features; const auto missing_features = required_features & ~features;
const auto extra_features = ~required_features & features; const auto unwanted_features = ~required_features & features;
const auto untoggleable_extra_features = extra_features & ~feature_toggles; const auto fixed_unwanted_features = unwanted_features & ~static_enable & ~dynamic_enable;
if (missing_features == 0 and untoggleable_extra_features == 0) if (missing_features == 0 and fixed_unwanted_features == 0)
{ {
const auto to_be_toggled = required_features & feature_toggles; // Tell caller which features need to be toggled before compilation
requirements.feature_toggles.from_generic(requirements.geometry, to_be_toggled); // and which features can still be dynamically enabled after compilation.
generic_requirement_feature_set.static_enable = required_features & static_enable;
generic_requirement_feature_set.dynamic_enable = dynamic_enable;
requirements.from_generic_feature_set(generic_requirement_feature_set);
return lower_it->second; return lower_it->second;
} }
@@ -325,11 +326,11 @@ void zgl::shader_program_compiler::compile_shaders(
shader_strings.clear(); shader_strings.clear();
switch (requirements.geometry) { switch (requirements.geometry) {
case shader_program::geometries::mesh: case shader_program::geometry::types::mesh:
add_required_feature_defines(requirements.feature_toggles.mesh, mesh_feature_defines, shader_strings); add_required_feature_defines(requirements.feature_set.mesh.static_enable, mesh_feature_defines, shader_strings);
break; break;
case shader_program::geometries::point_cloud: case shader_program::geometry::types::point_cloud:
add_required_feature_defines(requirements.feature_toggles.point_cloud, point_cloud_feature_defines, shader_strings); add_required_feature_defines(requirements.feature_set.point_cloud.static_enable, point_cloud_feature_defines, shader_strings);
break; break;
default: default:
std::unreachable(); std::unreachable();
@@ -339,7 +340,7 @@ void zgl::shader_program_compiler::compile_shaders(
shader_id = glCreateShader(static_cast<GLenum>(requirements.stage)); shader_id = glCreateShader(static_cast<GLenum>(requirements.stage));
glShaderSource(shader_id, shader_strings.size(), shader_strings.data(), nullptr); glShaderSource(shader_id, static_cast<GLsizei>(shader_strings.size()), shader_strings.data(), nullptr);
glCompileShader(shader_id); glCompileShader(shader_id);
GLint success; GLint success;
@@ -399,7 +400,7 @@ void zgl::shader_program_compiler::register_shader_sources(
const auto it = std::ranges::upper_bound( const auto it = std::ranges::upper_bound(
shader_lookup, shader_lookup,
*metadata, *metadata,
shader_program::metadata_type::feature_count_less{}, std::less{},
&std::pair<shader_program::metadata_type, dynamic_shader_source_store::id_type>::first &std::pair<shader_program::metadata_type, dynamic_shader_source_store::id_type>::first
); );

2
source/rendering/batch_renderers/mesh_batch_renderer.cpp
View File

@@ -65,7 +65,7 @@ std::optional<mesh_batch_renderer::id_type> mesh_batch_renderer::add(
ztu::logger::debug("vertex_comps: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(vertex_comps)) }); ztu::logger::debug("vertex_comps: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(vertex_comps)) });
ztu::logger::debug("material_comps: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(material_comps)) }); ztu::logger::debug("material_comps: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(material_comps)) });
ztu::logger::debug("lit reqs: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(shader_program::capabilities::mesh::lit.uniforms)) }); ztu::logger::debug("lit reqs: %", std::bitset<32>{ static_cast<unsigned long long>(static_cast<int>(shader_program::features::mesh::lit.uniforms)) });
for (std::size_t i{}; i != requirements::mesh::all.size(); ++i) for (std::size_t i{}; i != requirements::mesh::all.size(); ++i)

4
source/rendering/shader_program_lookups/mesh_lookup.cpp
View File

@@ -19,7 +19,7 @@ void mesh_lookup::add(
std::optional<zgl::shader_program_handle> mesh_lookup::find( std::optional<zgl::shader_program_handle> mesh_lookup::find(
requirements::mesh::flags requirements requirements::mesh::flags requirements
) const { ) const {
auto capability = shader_program::capabilities::mesh::type{}; auto capability = shader_program::features::mesh::type{};
auto index = std::size_t{}; auto index = std::size_t{};
@@ -30,7 +30,7 @@ std::optional<zgl::shader_program_handle> mesh_lookup::find(
if (requirement_flags & 1) if (requirement_flags & 1)
{ {
const auto shader_requirements_index = requirements::mesh::all[index].shader_program_requirement_index; const auto shader_requirements_index = requirements::mesh::all[index].shader_program_requirement_index;
const auto& [ attributes, uniforms ] = shader_program::capabilities::mesh::all[shader_requirements_index]; const auto& [ attributes, uniforms ] = shader_program::features::mesh::all[shader_requirements_index];
capability.attributes |= attributes; capability.attributes |= attributes;
capability.uniforms |= uniforms; capability.uniforms |= uniforms;
} }

4
source/rendering/shader_program_lookups/point_cloud_lookup.cpp
View File

@@ -17,7 +17,7 @@ void point_cloud_lookup::add(
std::optional<zgl::shader_program_handle> point_cloud_lookup::find( std::optional<zgl::shader_program_handle> point_cloud_lookup::find(
requirements::point_cloud::flags requirements requirements::point_cloud::flags requirements
) const { ) const {
auto capability = shader_program::capabilities::point_cloud::type{}; auto capability = shader_program::features::point_cloud::type{};
auto index = std::size_t{}; auto index = std::size_t{};
@@ -28,7 +28,7 @@ std::optional<zgl::shader_program_handle> point_cloud_lookup::find(
if (requirement_flags & 1) if (requirement_flags & 1)
{ {
const auto shader_requirements_index = requirements::point_cloud::all[index].shader_program_requirement_index; const auto shader_requirements_index = requirements::point_cloud::all[index].shader_program_requirement_index;
const auto& [ attributes, uniforms ] = shader_program::capabilities::point_cloud::all[shader_requirements_index]; const auto& [ attributes, uniforms ] = shader_program::features::point_cloud::all[shader_requirements_index];
capability.attributes |= attributes; capability.attributes |= attributes;
capability.uniforms |= uniforms; capability.uniforms |= uniforms;
} }