libs/render/src/eu/render/shader_resource.cc
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | #include "eu/render/shader_resource.h" | ||
| 2 | |||
| 3 | #include "eu/assert/assert.h" | ||
| 4 | |||
| 5 | |||
| 6 | #include "eu/render/camera.h" | ||
| 7 | #include "eu/render/constants.h" | ||
| 8 | #include "eu/render/fullscreen.h" | ||
| 9 | #include "eu/render/render_settings.h" | ||
| 10 | #include "eu/render/shader.h" | ||
| 11 | #include "eu/render/shader.source.h" | ||
| 12 | |||
| 13 | |||
| 14 | namespace internal | ||
| 15 | { | ||
| 16 | namespace | ||
| 17 | { | ||
| 18 | using namespace eu; | ||
| 19 | using namespace eu::render; | ||
| 20 | |||
| 21 | |||
| 22 | ✗ | std::optional<Uniform> get_uniform( | |
| 23 | ShaderProgram& prog, const std::string& name, PostProcSetup setup, PostProcSetup flag | ||
| 24 | ) | ||
| 25 | { | ||
| 26 | ✗ | if (is_flag_set(setup, flag)) | |
| 27 | { | ||
| 28 | ✗ | return prog.get_uniform(name); | |
| 29 | } | ||
| 30 | else | ||
| 31 | { | ||
| 32 | ✗ | return std::nullopt; | |
| 33 | } | ||
| 34 | } | ||
| 35 | |||
| 36 | |||
| 37 | using BaseShaderData = std::vector<core::VertexType>; | ||
| 38 | |||
| 39 | |||
| 40 | |||
| 41 | template<std::size_t count> | ||
| 42 | ✗ | BaseShaderData get_vertex_types(const std::array<const core::ShaderVertexAttributes*, count>& vas) | |
| 43 | { | ||
| 44 | ✗ | std::set<core::VertexType> unique_types; | |
| 45 | ✗ | auto ret = BaseShaderData{}; | |
| 46 | ✗ | for (const auto& va : vas) | |
| 47 | { | ||
| 48 | ✗ | for (const auto& v : *va) | |
| 49 | { | ||
| 50 | ✗ | const auto [_, is_unique] = unique_types.insert(v.type); | |
| 51 | ✗ | if (is_unique) | |
| 52 | { | ||
| 53 | ✗ | ret.emplace_back(v.type); | |
| 54 | } | ||
| 55 | } | ||
| 56 | } | ||
| 57 | ✗ | return ret; | |
| 58 | ✗ | } | |
| 59 | |||
| 60 | |||
| 61 | |||
| 62 | // todo(Gustav): should this be a tuple instead? this way the members are named | ||
| 63 | struct LoadedShader | ||
| 64 | { | ||
| 65 | ✗ | LoadedShader(std::shared_ptr<ShaderProgram> p, core::CompiledGeomVertexAttributes l) | |
| 66 | ✗ | : program(std::move(p)) | |
| 67 | ✗ | , geom_layout(std::move(l)) | |
| 68 | ✗ | {} | |
| 69 | |||
| 70 | std::shared_ptr<ShaderProgram> program; | ||
| 71 | core::CompiledGeomVertexAttributes geom_layout; | ||
| 72 | }; | ||
| 73 | |||
| 74 | ✗ | std::optional<int> get_instance_start_index(const LoadedShader* shader) | |
| 75 | { | ||
| 76 | ✗ | if (shader == nullptr) | |
| 77 | { | ||
| 78 | ✗ | return std::nullopt; | |
| 79 | } | ||
| 80 | |||
| 81 | ✗ | const core::CompiledGeomVertexAttributes& layout = shader->geom_layout; | |
| 82 | |||
| 83 | ✗ | int max = 0; | |
| 84 | |||
| 85 | ✗ | for (const auto& entry : layout.elements) | |
| 86 | { | ||
| 87 | ✗ | max = std::max(entry.index, max); | |
| 88 | } | ||
| 89 | |||
| 90 | ✗ | return max + 1; | |
| 91 | } | ||
| 92 | |||
| 93 | ✗ | LoadedShader load_shader(DEBUG_LABEL_ARG_MANY const BaseShaderData& base_layout, const ShaderSource_withLayout& source, TransformSource model_source, const LoadedShader* instance_base = nullptr) | |
| 94 | { | ||
| 95 | ✗ | auto layout_compiler = compile_attribute_layouts(base_layout, { source.layout }); | |
| 96 | ✗ | const auto geom_layout = get_geom_layout(layout_compiler); | |
| 97 | |||
| 98 | ✗ | std::optional<core::InstanceProp> instance_prop = std::nullopt; | |
| 99 | ✗ | std::optional<int> start_index = std::nullopt; | |
| 100 | ✗ | switch (model_source) | |
| 101 | { | ||
| 102 | ✗ | case TransformSource::instanced_mat4: | |
| 103 | ✗ | instance_prop = core::InstanceProp | |
| 104 | { | ||
| 105 | .type = core::VertexType::instance_transform, | ||
| 106 | ✗ | .name = "u_world_from_local" | |
| 107 | ✗ | }; | |
| 108 | ✗ | start_index = get_instance_start_index(instance_base); | |
| 109 | ✗ | break; | |
| 110 | ✗ | case TransformSource::uniform: break; | |
| 111 | ✗ | default: ASSERT(false && "unhandled ModelSource"); | |
| 112 | } | ||
| 113 | |||
| 114 | ✗ | const auto compiled_layout = compile_shader_layout(layout_compiler, source.layout, instance_prop, start_index); | |
| 115 | |||
| 116 | ✗ | auto program = std::make_shared<ShaderProgram>(USE_DEBUG_LABEL_MANY(debug_label) source.vertex, source.fragment, compiled_layout); | |
| 117 | |||
| 118 | ✗ | return { program, geom_layout }; | |
| 119 | ✗ | } | |
| 120 | } | ||
| 121 | } | ||
| 122 | |||
| 123 | |||
| 124 | namespace eu::render | ||
| 125 | { | ||
| 126 | |||
| 127 | |||
| 128 | |||
| 129 | ✗ | void CameraUniformBuffer::set_props(const CompiledCamera& cc) // NOLINT(readability-make-member-function-const) | |
| 130 | { | ||
| 131 | ✗ | buffer->set_mat4(clip_from_view_uni, cc.clip_from_view); | |
| 132 | ✗ | buffer->set_mat4(view_from_world_uni, cc.view_from_world); | |
| 133 | ✗ | } | |
| 134 | |||
| 135 | |||
| 136 | |||
| 137 | ✗ | LoadedShader_SingleColor::LoadedShader_SingleColor( | |
| 138 | std::shared_ptr<ShaderProgram> p, core::CompiledGeomVertexAttributes l, const CameraUniformBuffer& desc | ||
| 139 | ✗ | ) | |
| 140 | ✗ | : program(std::move(p)) | |
| 141 | ✗ | , geom_layout(std::move(l)) | |
| 142 | ✗ | , tint_color_uni(program->get_uniform("u_material.diffuse_tint")) | |
| 143 | ✗ | , world_from_local_uni(program->get_uniform("u_world_from_local")) | |
| 144 | { | ||
| 145 | ✗ | program->setup_uniform_block(desc.setup); | |
| 146 | ✗ | } | |
| 147 | |||
| 148 | |||
| 149 | |||
| 150 | ✗ | LoadedShader_Skybox::LoadedShader_Skybox( | |
| 151 | std::shared_ptr<ShaderProgram> p, core::CompiledGeomVertexAttributes l, const CameraUniformBuffer& desc | ||
| 152 | ✗ | ) | |
| 153 | ✗ | : program(std::move(p)) | |
| 154 | ✗ | , geom_layout(std::move(l)) | |
| 155 | ✗ | , tex_skybox_uniform(program->get_uniform("u_skybox_tex")) | |
| 156 | { | ||
| 157 | ✗ | setup_textures(program.get(), {&tex_skybox_uniform}); | |
| 158 | ✗ | program->setup_uniform_block(desc.setup); | |
| 159 | ✗ | } | |
| 160 | |||
| 161 | ✗ | LoadedShader_OnlyDepth::LoadedShader_OnlyDepth( | |
| 162 | TransformSource model_source, | ||
| 163 | std::shared_ptr<ShaderProgram> p, | ||
| 164 | core::CompiledGeomVertexAttributes l, | ||
| 165 | const CameraUniformBuffer& desc | ||
| 166 | ✗ | ) | |
| 167 | ✗ | : program(std::move(p)) | |
| 168 | ✗ | , geom_layout(std::move(l)) | |
| 169 | ✗ | , world_from_local_uni( | |
| 170 | ✗ | model_source == TransformSource::uniform ? std::optional<Uniform>{program->get_uniform("u_world_from_local")} | |
| 171 | : std::nullopt | ||
| 172 | ) | ||
| 173 | { | ||
| 174 | ✗ | program->setup_uniform_block(desc.setup); | |
| 175 | ✗ | } | |
| 176 | |||
| 177 | ✗ | LoadedShader_Unlit::LoadedShader_Unlit( | |
| 178 | TransformSource model_source, | ||
| 179 | std::shared_ptr<ShaderProgram> p, | ||
| 180 | const CameraUniformBuffer& desc | ||
| 181 | ✗ | ) | |
| 182 | ✗ | : program(std::move(p)) | |
| 183 | ✗ | , tint_color_uni(program->get_uniform("u_material.diffuse_tint")) | |
| 184 | ✗ | , tex_diffuse_uniform(program->get_uniform("u_material.diffuse_tex")) | |
| 185 | ✗ | , world_from_local_uni( | |
| 186 | ✗ | model_source == TransformSource::uniform ? std::optional<Uniform>{program->get_uniform("u_world_from_local")} : std::nullopt | |
| 187 | ) | ||
| 188 | { | ||
| 189 | ✗ | setup_textures(program.get(), {&tex_diffuse_uniform}); | |
| 190 | ✗ | program->setup_uniform_block(desc.setup); | |
| 191 | ✗ | } | |
| 192 | |||
| 193 | |||
| 194 | |||
| 195 | ✗ | DirectionalLightUniforms::DirectionalLightUniforms(const ShaderProgram* program, const std::string& base) | |
| 196 | ✗ | : light_diffuse_color_uni(program->get_uniform(base + "diffuse")) | |
| 197 | ✗ | , light_specular_color_uni(program->get_uniform(base + "specular")) | |
| 198 | ✗ | , dir_uni(program->get_uniform(base + "dir")) | |
| 199 | { | ||
| 200 | ✗ | } | |
| 201 | |||
| 202 | |||
| 203 | |||
| 204 | ✗ | PointLightUniforms::PointLightUniforms(const ShaderProgram* program, const std::string& base) | |
| 205 | ✗ | : light_diffuse_color_uni(program->get_uniform(base + "diffuse")) | |
| 206 | ✗ | , light_specular_color_uni(program->get_uniform(base + "specular")) | |
| 207 | ✗ | , light_attenuation_uni(program->get_uniform(base + "attenuation")) | |
| 208 | ✗ | , light_world_uni(program->get_uniform(base + "world_pos")) | |
| 209 | { | ||
| 210 | ✗ | } | |
| 211 | |||
| 212 | |||
| 213 | |||
| 214 | ✗ | FrustumLightUniforms::FrustumLightUniforms(const ShaderProgram* program, const std::string& base) | |
| 215 | ✗ | : diffuse_uni(program->get_uniform(base + "diffuse")) | |
| 216 | ✗ | , specular_uni(program->get_uniform(base + "specular")) | |
| 217 | ✗ | , attenuation_uni(program->get_uniform(base + "attenuation")) | |
| 218 | ✗ | , clip_from_world_uni(program->get_uniform(base + "clip_from_world")) | |
| 219 | ✗ | , world_pos_uni(program->get_uniform(base + "world_pos")) | |
| 220 | ✗ | , tex_cookie_uniform(program->get_uniform(base + "cookie")) | |
| 221 | { | ||
| 222 | ✗ | } | |
| 223 | |||
| 224 | |||
| 225 | |||
| 226 | ✗ | PostProcSetup operator|(PostProcSetup lhs, PostProcSetup rhs) | |
| 227 | { | ||
| 228 | ✗ | return static_cast<PostProcSetup>(base_cast(lhs) | base_cast(rhs)); | |
| 229 | } | ||
| 230 | |||
| 231 | |||
| 232 | |||
| 233 | |||
| 234 | |||
| 235 | |||
| 236 | ✗ | LoadedPostProcShader::LoadedPostProcShader(std::shared_ptr<ShaderProgram> s, PostProcSetup setup) | |
| 237 | ✗ | : program(std::move(s)) | |
| 238 | ✗ | , tex_input_uniform(program->get_uniform("u_texture")) | |
| 239 | ✗ | , factor_uni(internal::get_uniform(*program, "u_factor", setup, PostProcSetup::factor)) | |
| 240 | ✗ | , resolution_uni(internal::get_uniform(*program, "u_resolution", setup, PostProcSetup::resolution)) | |
| 241 | ✗ | , time_uni(internal::get_uniform(*program, "u_time", setup, PostProcSetup::time)) | |
| 242 | { | ||
| 243 | ✗ | setup_textures(program.get(), {&tex_input_uniform}); | |
| 244 | ✗ | } | |
| 245 | |||
| 246 | |||
| 247 | |||
| 248 | ✗ | LoadedShader_Default::LoadedShader_Default( | |
| 249 | TransformSource model_source, | ||
| 250 | std::shared_ptr<ShaderProgram> p, | ||
| 251 | const RenderSettings& settings, | ||
| 252 | const CameraUniformBuffer& desc | ||
| 253 | ✗ | ) | |
| 254 | ✗ | : program(std::move(p)) | |
| 255 | ✗ | , tint_color_uni(program->get_uniform("u_material.diffuse_tint")) | |
| 256 | ✗ | , tex_directional_light_depth_uni(program->get_uniform("u_directional_light_depth_tex")) | |
| 257 | ✗ | , directional_shadow_clip_from_world_uni(program->get_uniform("u_directional_shadow_clip_from_world")) | |
| 258 | ✗ | , tex_diffuse_uniform(program->get_uniform("u_material.diffuse_tex")) | |
| 259 | ✗ | , tex_specular_uniform(program->get_uniform("u_material.specular_tex")) | |
| 260 | ✗ | , tex_emissive_uniform(program->get_uniform("u_material.emissive_tex")) | |
| 261 | ✗ | , ambient_tint_uni(program->get_uniform("u_material.ambient_tint")) | |
| 262 | ✗ | , specular_color_uni(program->get_uniform("u_material.specular_tint")) | |
| 263 | ✗ | , shininess_uni(program->get_uniform("u_material.shininess")) | |
| 264 | ✗ | , emissive_factor_uni(program->get_uniform("u_material.emissive_factor")) | |
| 265 | ✗ | , world_from_local_uni( | |
| 266 | ✗ | model_source == TransformSource::uniform ? std::optional<Uniform>{program->get_uniform("u_world_from_local")} : std::nullopt | |
| 267 | ) | ||
| 268 | ✗ | , view_position_uni(program->get_uniform("u_view_position")) | |
| 269 | ✗ | , light_ambient_color_uni(program->get_uniform("u_ambient_light")) | |
| 270 | { | ||
| 271 | ✗ | for (int index = 0; index < settings.number_of_directional_lights; index += 1) | |
| 272 | { | ||
| 273 | ✗ | const std::string base = fmt::format("u_directional_lights[{}].", index); | |
| 274 | ✗ | directional_lights.emplace_back(program.get(), base); | |
| 275 | ✗ | } | |
| 276 | |||
| 277 | ✗ | for (int index = 0; index < settings.number_of_point_lights; index += 1) | |
| 278 | { | ||
| 279 | ✗ | const std::string base = fmt::format("u_point_lights[{}].", index); | |
| 280 | ✗ | point_lights.emplace_back(program.get(), base); | |
| 281 | ✗ | } | |
| 282 | |||
| 283 | ✗ | for (int index = 0; index < settings.number_of_frustum_lights; index += 1) | |
| 284 | { | ||
| 285 | ✗ | const std::string base = fmt::format("u_frustum_lights[{}].", index); | |
| 286 | ✗ | frustum_lights.emplace_back(program.get(), base); | |
| 287 | ✗ | } | |
| 288 | |||
| 289 | ✗ | std::vector<Uniform*> textures = {&tex_directional_light_depth_uni, &tex_diffuse_uniform, &tex_specular_uniform, &tex_emissive_uniform}; | |
| 290 | ✗ | for (auto& fl: frustum_lights) | |
| 291 | { | ||
| 292 | ✗ | textures.emplace_back(&fl.tex_cookie_uniform); | |
| 293 | } | ||
| 294 | |||
| 295 | ✗ | setup_textures(program.get(), textures); | |
| 296 | ✗ | program->setup_uniform_block(desc.setup); | |
| 297 | ✗ | } | |
| 298 | |||
| 299 | |||
| 300 | |||
| 301 | ✗ | bool LoadedShader_Unlit_Container::is_loaded() const | |
| 302 | { | ||
| 303 | ✗ | return default_shader.program->is_loaded() && transparency_shader.program->is_loaded(); | |
| 304 | } | ||
| 305 | |||
| 306 | |||
| 307 | |||
| 308 | ✗ | const LoadedShader_Unlit& shader_from_container(const LoadedShader_Unlit_Container& container, const RenderContext& rc) | |
| 309 | { | ||
| 310 | ✗ | return rc.use_transparency == UseTransparency::yes ? container.transparency_shader : container.default_shader; | |
| 311 | } | ||
| 312 | |||
| 313 | ✗ | const LoadedShader_Default& shader_from_container(const LoadedShader_Default_Container& container, const RenderContext& rc) | |
| 314 | { | ||
| 315 | ✗ | switch (rc.model_source) | |
| 316 | { | ||
| 317 | ✗ | case TransformSource::uniform: | |
| 318 | ✗ | return rc.use_transparency == UseTransparency::yes ? container.transparency_shader : container.default_shader; | |
| 319 | ✗ | case TransformSource::instanced_mat4: | |
| 320 | ✗ | ASSERT(rc.use_transparency == UseTransparency::no); // not currently supporting instanced transparency | |
| 321 | ✗ | return container.default_shader_instance; | |
| 322 | ✗ | default: ASSERT(false && "unhandled"); return container.default_shader; | |
| 323 | } | ||
| 324 | } | ||
| 325 | |||
| 326 | |||
| 327 | |||
| 328 | |||
| 329 | ✗ | bool LoadedShader_Default_Container::is_loaded() const | |
| 330 | { | ||
| 331 | ✗ | return default_shader.program->is_loaded() && transparency_shader.program->is_loaded(); | |
| 332 | } | ||
| 333 | |||
| 334 | |||
| 335 | |||
| 336 | |||
| 337 | ✗ | RealizeShader::RealizeShader(std::shared_ptr<ShaderProgram> s) | |
| 338 | ✗ | : program(std::move(s)) | |
| 339 | ✗ | , tex_input_uniform(program->get_uniform("u_texture")) | |
| 340 | ✗ | , tex_blurred_bloom_uniform(program->get_uniform("u_blurred_bloom")) | |
| 341 | ✗ | , use_blur_uniform(program->get_uniform("u_use_blur")) | |
| 342 | ✗ | , gamma_uniform(program->get_uniform("u_gamma")) | |
| 343 | ✗ | , exposure_uniform(program->get_uniform("u_exposure")) | |
| 344 | { | ||
| 345 | ✗ | setup_textures(program.get(), {&tex_input_uniform, &tex_blurred_bloom_uniform}); | |
| 346 | ✗ | } | |
| 347 | |||
| 348 | |||
| 349 | |||
| 350 | ✗ | ExtractShader::ExtractShader(std::shared_ptr<LoadedPostProcShader>&& sh) | |
| 351 | ✗ | : shader(std::move(sh)) | |
| 352 | ✗ | , cutoff_uniform(shader->program->get_uniform("u_cutoff")) | |
| 353 | ✗ | , softness_uniform(shader->program->get_uniform("u_softness")) | |
| 354 | { | ||
| 355 | ✗ | } | |
| 356 | |||
| 357 | ✗ | PingPongBlurShader::PingPongBlurShader(std::shared_ptr<LoadedPostProcShader>&& sh) | |
| 358 | ✗ | : shader(std::move(sh)) | |
| 359 | ✗ | , is_horizontal_uniform(shader->program->get_uniform("u_is_horizontal")) | |
| 360 | { | ||
| 361 | ✗ | } | |
| 362 | |||
| 363 | |||
| 364 | |||
| 365 | ✗ | bool ShaderResource::is_loaded() const | |
| 366 | { | ||
| 367 | ✗ | return single_color_shader.program->is_loaded() | |
| 368 | ✗ | && depth_transform_uniform.program->is_loaded() | |
| 369 | ✗ | && depth_transform_instanced_mat4.program->is_loaded() | |
| 370 | ✗ | && skybox_shader.program->is_loaded() | |
| 371 | ✗ | && unlit_shader_container.is_loaded() | |
| 372 | ✗ | && default_shader_container.is_loaded() | |
| 373 | ✗ | && pp_realize.program->is_loaded(); | |
| 374 | } | ||
| 375 | |||
| 376 | |||
| 377 | |||
| 378 | ✗ | ShaderResource load_shaders(const Assets& assets, const CameraUniformBuffer& desc, const RenderSettings& settings, const FullScreenGeom& full_screen) | |
| 379 | { | ||
| 380 | ✗ | const auto& default_shader_source = assets.default_shader_source; | |
| 381 | ✗ | const auto& skybox_shader_source = assets.skybox_shader_source; | |
| 382 | |||
| 383 | ✗ | const auto single_color_shader = load_shader_source(default_shader_source, {}, desc.setup.source); | |
| 384 | |||
| 385 | ✗ | ShaderOptions depth_shader_options; | |
| 386 | ✗ | depth_shader_options.only_depth = true; | |
| 387 | ✗ | const auto depth_transform_uniform = load_shader_source(default_shader_source, depth_shader_options, desc.setup.source); | |
| 388 | ✗ | const auto depth_transform_instanced_mat4 = load_shader_source(default_shader_source, depth_shader_options.with_instanced_mat4(), desc.setup.source); | |
| 389 | |||
| 390 | ✗ | const auto skybox_source = load_skybox_source(skybox_shader_source, desc.setup.source); | |
| 391 | const auto skybox_shader = ShaderSource_withLayout{ | ||
| 392 | .layout = core::ShaderVertexAttributes | ||
| 393 | { | ||
| 394 | { | ||
| 395 | .type = core::VertexType::position3, | ||
| 396 | ✗ | .name = "a_position" | |
| 397 | } | ||
| 398 | ✗ | }, | |
| 399 | .vertex = skybox_source.vertex, | ||
| 400 | .fragment = skybox_source.fragment | ||
| 401 | ✗ | }; | |
| 402 | |||
| 403 | const internal::BaseShaderData global_shader_data = internal::get_vertex_types<3> | ||
| 404 | ({ | ||
| 405 | &single_color_shader.layout, | ||
| 406 | &depth_transform_uniform.layout, | ||
| 407 | &depth_transform_instanced_mat4.layout | ||
| 408 | ✗ | }); | |
| 409 | |||
| 410 | ✗ | ShaderOptions unlit_shader_options; | |
| 411 | ✗ | unlit_shader_options.use_texture = true; | |
| 412 | |||
| 413 | ✗ | ShaderOptions default_shader_options; | |
| 414 | ✗ | default_shader_options.use_lights = true; | |
| 415 | ✗ | default_shader_options.use_texture = true; | |
| 416 | ✗ | default_shader_options.number_of_directional_lights = settings.number_of_directional_lights; | |
| 417 | ✗ | default_shader_options.number_of_point_lights = settings.number_of_point_lights; | |
| 418 | ✗ | default_shader_options.number_of_frustum_lights = settings.number_of_frustum_lights; | |
| 419 | |||
| 420 | auto loaded_unlit = internal::load_shader( | ||
| 421 | ✗ | USE_DEBUG_LABEL_MANY("unlit") | |
| 422 | global_shader_data, | ||
| 423 | ✗ | load_shader_source(default_shader_source, unlit_shader_options.with_transparent_cutoff(), desc.setup.source), | |
| 424 | TransformSource::uniform | ||
| 425 | ✗ | ); | |
| 426 | auto loaded_default = internal::load_shader( | ||
| 427 | ✗ | USE_DEBUG_LABEL_MANY("default") | |
| 428 | global_shader_data, | ||
| 429 | ✗ | load_shader_source(default_shader_source, default_shader_options.with_transparent_cutoff(), desc.setup.source), | |
| 430 | TransformSource::uniform | ||
| 431 | ✗ | ); | |
| 432 | auto loaded_default_instanced = internal::load_shader( | ||
| 433 | ✗ | USE_DEBUG_LABEL_MANY("default instanced") | |
| 434 | global_shader_data, | ||
| 435 | ✗ | load_shader_source(default_shader_source, default_shader_options.with_transparent_cutoff().with_instanced_mat4(), desc.setup.source), | |
| 436 | TransformSource::instanced_mat4 | ||
| 437 | ✗ | ); | |
| 438 | |||
| 439 | auto loaded_unlit_transparency = internal::load_shader( | ||
| 440 | ✗ | USE_DEBUG_LABEL_MANY("unlit transparency") | |
| 441 | ✗ | global_shader_data, load_shader_source(default_shader_source, unlit_shader_options, desc.setup.source), TransformSource::uniform | |
| 442 | ✗ | ); | |
| 443 | auto loaded_default_transparency = internal::load_shader( | ||
| 444 | ✗ | USE_DEBUG_LABEL_MANY("default transparency") | |
| 445 | ✗ | global_shader_data, load_shader_source(default_shader_source, default_shader_options, desc.setup.source), TransformSource::uniform | |
| 446 | ✗ | ); | |
| 447 | |||
| 448 | // todo(Gustav): should the asserts here be runtime errors? currently all setups are compile-time... | ||
| 449 | ✗ | ASSERT(loaded_unlit.geom_layout.debug_types == loaded_unlit_transparency.geom_layout.debug_types); | |
| 450 | ✗ | ASSERT(loaded_default.geom_layout.debug_types == loaded_default_transparency.geom_layout.debug_types); | |
| 451 | ✗ | ASSERT( | |
| 452 | loaded_default.geom_layout.debug_types == loaded_default_instanced.geom_layout.debug_types | ||
| 453 | ); // is this valid? should this fail? | ||
| 454 | |||
| 455 | #if TODO_ADD_CUSTOM_EFFECTS | ||
| 456 | auto pp_invert = std::make_shared<LoadedPostProcShader>( | ||
| 457 | std::make_shared<ShaderProgram>( | ||
| 458 | USE_DEBUG_LABEL_MANY("pp invert") | ||
| 459 | std::string{PP_VERT_GLSL}, std::string{PP_INVERT_FRAG_GLSL}, full_screen.layout | ||
| 460 | ), | ||
| 461 | PostProcSetup::factor | ||
| 462 | ); | ||
| 463 | auto pp_grayscale = std::make_shared<LoadedPostProcShader>( | ||
| 464 | std::make_shared<ShaderProgram>( | ||
| 465 | USE_DEBUG_LABEL_MANY("pp grayscale") | ||
| 466 | std::string{PP_VERT_GLSL}, std::string{PP_GRAYSCALE_FRAG_GLSL}, full_screen.layout | ||
| 467 | ), | ||
| 468 | PostProcSetup::factor | ||
| 469 | ); | ||
| 470 | auto pp_damage = std::make_shared<LoadedPostProcShader>( | ||
| 471 | std::make_shared<ShaderProgram>( | ||
| 472 | USE_DEBUG_LABEL_MANY("pp damage") | ||
| 473 | std::string{PP_VERT_GLSL}, std::string{PP_DAMAGE_FRAG_GLSL}, full_screen.layout | ||
| 474 | ), | ||
| 475 | PostProcSetup::factor | PostProcSetup::resolution | PostProcSetup::time | ||
| 476 | ); | ||
| 477 | |||
| 478 | constexpr IsGauss use_gauss = | ||
| 479 | #if FF_HAS(BLUR_USE_GAUSS) | ||
| 480 | IsGauss::yes | ||
| 481 | #else | ||
| 482 | IsGauss::no | ||
| 483 | #endif | ||
| 484 | ; | ||
| 485 | |||
| 486 | auto pp_blurv = std::make_shared<LoadedPostProcShader>( | ||
| 487 | std::make_shared<ShaderProgram>( | ||
| 488 | USE_DEBUG_LABEL_MANY("pp blur vert") | ||
| 489 | std::string{PP_VERT_GLSL}, | ||
| 490 | generate_blur(PP_BLUR_FRAG_GLSL, {BlurType::vertical, blur_samples, use_gauss}), | ||
| 491 | full_screen.layout | ||
| 492 | ), | ||
| 493 | PostProcSetup::factor | ||
| 494 | ); | ||
| 495 | auto pp_blurh = std::make_shared<LoadedPostProcShader>( | ||
| 496 | std::make_shared<ShaderProgram>( | ||
| 497 | USE_DEBUG_LABEL_MANY("pp blur hor") | ||
| 498 | std::string{PP_VERT_GLSL}, | ||
| 499 | generate_blur(PP_BLUR_FRAG_GLSL, {BlurType::horizontal, blur_samples, use_gauss}), | ||
| 500 | full_screen.layout | ||
| 501 | ), | ||
| 502 | PostProcSetup::factor | PostProcSetup::resolution | ||
| 503 | ); | ||
| 504 | #endif | ||
| 505 | |||
| 506 | ✗ | auto pp_realize = RealizeShader{std::make_shared<ShaderProgram>( | |
| 507 | USE_DEBUG_LABEL_MANY("pp realize") | ||
| 508 | ✗ | assets.pp_vert_glsl, assets.pp_realize_frag_glsl, full_screen.layout | |
| 509 | ✗ | )}; | |
| 510 | ✗ | auto pp_extract = ExtractShader{std::make_shared<LoadedPostProcShader>( | |
| 511 | ✗ | std::make_shared<ShaderProgram>( | |
| 512 | ✗ | USE_DEBUG_LABEL_MANY("pp extract") assets.pp_vert_glsl, | |
| 513 | ✗ | assets.pp_extract_frag_glsl, | |
| 514 | ✗ | full_screen.layout | |
| 515 | ), | ||
| 516 | ✗ | PostProcSetup::none | |
| 517 | ✗ | )}; | |
| 518 | ✗ | auto pp_ping = PingPongBlurShader{std::make_shared<LoadedPostProcShader>( | |
| 519 | ✗ | std::make_shared<ShaderProgram>( | |
| 520 | ✗ | USE_DEBUG_LABEL_MANY("pp ping-pong") assets.pp_vert_glsl, | |
| 521 | ✗ | assets.pp_ping_pong_blur_frag_glsl, | |
| 522 | ✗ | full_screen.layout | |
| 523 | ), | ||
| 524 | ✗ | PostProcSetup::none | |
| 525 | ✗ | )}; | |
| 526 | |||
| 527 | auto loaded_single_color = internal::load_shader( | ||
| 528 | ✗ | USE_DEBUG_LABEL_MANY("single color") global_shader_data, single_color_shader, TransformSource::uniform | |
| 529 | ✗ | ); | |
| 530 | auto loaded_depth_transform_uniform = internal::load_shader( | ||
| 531 | ✗ | USE_DEBUG_LABEL_MANY("depth transform uniform") global_shader_data, depth_transform_uniform, TransformSource::uniform | |
| 532 | ✗ | ); | |
| 533 | auto loaded_depth_transform_instanced_mat4 = load_shader( | ||
| 534 | ✗ | USE_DEBUG_LABEL_MANY("depth transform instanced") global_shader_data, depth_transform_instanced_mat4, TransformSource::instanced_mat4, &loaded_default_instanced | |
| 535 | ✗ | ); | |
| 536 | auto loaded_skybox_shader | ||
| 537 | ✗ | = internal::load_shader(USE_DEBUG_LABEL_MANY("skybox"){}, skybox_shader, TransformSource::uniform); | |
| 538 | |||
| 539 | |||
| 540 | ✗ | return ShaderResource{ | |
| 541 | // todo(Gustav): not really happy with sending "the same" argument twice, loaded_X.program and loaded_X.geom_layout | ||
| 542 | ✗ | .single_color_shader = LoadedShader_SingleColor{std::move(loaded_single_color.program), loaded_single_color.geom_layout, desc}, | |
| 543 | .depth_transform_uniform = LoadedShader_OnlyDepth{ | ||
| 544 | ✗ | TransformSource::uniform, std::move(loaded_depth_transform_uniform.program), | |
| 545 | loaded_depth_transform_uniform.geom_layout, | ||
| 546 | desc | ||
| 547 | ✗ | }, | |
| 548 | .depth_transform_instanced_mat4 = LoadedShader_OnlyDepth{ | ||
| 549 | TransformSource::instanced_mat4, | ||
| 550 | ✗ | std::move(loaded_depth_transform_instanced_mat4.program), | |
| 551 | loaded_depth_transform_instanced_mat4.geom_layout, | ||
| 552 | desc | ||
| 553 | ✗ | }, | |
| 554 | ✗ | .skybox_shader = LoadedShader_Skybox{std::move(loaded_skybox_shader.program), loaded_skybox_shader.geom_layout, desc}, | |
| 555 | .unlit_shader_container = LoadedShader_Unlit_Container{ | ||
| 556 | .geom_layout = loaded_unlit.geom_layout, | ||
| 557 | ✗ | .default_shader = LoadedShader_Unlit{TransformSource::uniform, std::move(loaded_unlit.program), desc}, | |
| 558 | ✗ | .transparency_shader = LoadedShader_Unlit{TransformSource::uniform, std::move(loaded_unlit_transparency.program), desc} | |
| 559 | }, | ||
| 560 | .default_shader_container = LoadedShader_Default_Container{ | ||
| 561 | .geom_layout = loaded_default.geom_layout, | ||
| 562 | ✗ | .default_shader = LoadedShader_Default{TransformSource::uniform, std::move(loaded_default.program), settings, desc}, | |
| 563 | ✗ | .transparency_shader = LoadedShader_Default{TransformSource::uniform, std::move(loaded_default_transparency.program), settings, desc}, | |
| 564 | ✗ | .default_shader_instance = LoadedShader_Default{TransformSource::instanced_mat4, std::move(loaded_default_instanced.program), settings, desc} | |
| 565 | }, | ||
| 566 | // .pp_invert = pp_invert, | ||
| 567 | // .pp_grayscale = pp_grayscale, | ||
| 568 | // .pp_damage = pp_damage, | ||
| 569 | // .pp_blurv = pp_blurv, | ||
| 570 | // .pp_blurh = pp_blurh, | ||
| 571 | .pp_realize = pp_realize, | ||
| 572 | .pp_extract = pp_extract, | ||
| 573 | .pp_ping = pp_ping | ||
| 574 | ✗ | }; | |
| 575 | ✗ | } | |
| 576 | |||
| 577 | |||
| 578 | |||
| 579 | } // namespace eu::render | ||
| 580 |