add terrain resource and shader

Author: benjamaan476

assets/shaders/Shader.Terrain.shadercfg

@@ -0,0 +1,30 @@
+version=1.0
+name=Shader.Terrain
+stages=vertex,fragment
+stagefiles=shaders/TerrainShader.vert.spv,shaders/TerrainShader.frag.spv
+depth_test=1
+depth_write=1
+
+# Attributes: type,name
+attribute=vec3,in_position
+attribute=vec3,in_normal
+attribute=vec2,in_texcoord
+attribute=vec4,in_colour
+attribute=vec4,in_tangent
+
+# Uniforms: type,scope,name
+# NOTE: For scope: 0=global, 1=instance, 2=local
+uniform=mat4,0,projection
+uniform=mat4,0,view
+uniform=vec4,0,ambient_colour
+uniform=vec3,0,view_position
+uniform=u32,0,mode
+uniform=vec4,1,diffuse_colour
+#uniform=samp,1,diffuse_texture
+#uniform=samp,1,specular_texture
+#uniform=samp,1,normal_texture
+uniform=struct32,1,dir_light
+uniform=struct480,1,point_lights
+uniform=i32,1,num_point_lights
+uniform=f32,1,shininess
+uniform=mat4,2,model

assets/shaders/TerrainShader.frag

@@ -0,0 +1,127 @@
+#version 450
+
+layout(location = 0) out vec4 out_colour;
+
+struct directional_light {
+    vec4 direction;
+    vec4 colour;
+};
+
+const int MAX_POINT_LIGHTS = 10;
+
+struct point_light {
+    vec4 position;
+    vec4 colour;
+    // Usually 1, make sure denominator never gets smaller than 1
+    float constant;
+    // Reduces light intensity linearly
+    float linear;
+    // Makes the light fall off slower at longer distances.
+    float quadratic;
+
+    float pad;
+};
+
+layout(set = 1, binding = 0) uniform local_uniform_object {
+    vec4 diffuse_colour;
+    directional_light dir_light;
+    point_light point_lights[MAX_POINT_LIGHTS];
+    int num_point_lights;
+    float shininess;
+} object_ubo;
+
+// // Samplers, diffuse, spec
+// const int SAMP_DIFFUSE = 0;
+// const int SAMP_SPECULAR = 1;
+// const int SAMP_NORMAL = 2;
+// layout(set = 1, binding = 1) uniform sampler2D samplers[3];
+
+layout(location = 0) flat in int in_mode;
+// Data Transfer Object
+layout(location = 1) in struct dto {
+    vec4 ambient;
+    vec2 tex_coord;
+    vec3 normal;
+    vec3 view_position;
+    vec3 frag_position;
+    vec4 colour;
+    vec4 tangent;
+} in_dto;
+
+mat3 TBN;
+
+vec4 calculate_directional_light(directional_light light, vec3 normal, vec3 view_direction);
+vec4 calculate_point_light(point_light light, vec3 normal, vec3 frag_position, vec3 view_direction);
+
+void main() {
+    vec3 normal = in_dto.normal;
+    vec3 tangent = in_dto.tangent.xyz;
+    tangent = (tangent - dot(tangent, normal) * normal);
+    vec3 bitangent = cross(in_dto.normal, in_dto.tangent.xyz) * in_dto.tangent.w;
+    TBN = mat3(tangent, bitangent, normal);
+
+    // Update the normal to use a sample from the normal map.
+    // vec3 localNormal = 2.0 * texture(samplers[SAMP_NORMAL], in_dto.tex_coord).rgb - 1.0;
+    // normal = normalize(TBN * localNormal);
+
+    if (in_mode == 0 || in_mode == 1) {
+        vec3 view_direction = normalize(in_dto.view_position - in_dto.frag_position);
+
+        out_colour = calculate_directional_light(object_ubo.dir_light, normal, view_direction);
+
+        for (int i = 0; i < object_ubo.num_point_lights; i++)
+        {
+            out_colour += calculate_point_light(object_ubo.point_lights[i], normal, in_dto.frag_position, view_direction);
+        }
+    } else if (in_mode == 2) {
+        out_colour = vec4(abs(normal), 1.0);
+    }
+}
+
+vec4 calculate_directional_light(directional_light light, vec3 normal, vec3 view_direction) {
+    float diffuse_factor = max(dot(normal, -light.direction.xyz), 0.0);
+
+    vec3 half_direction = normalize(view_direction - light.direction.xyz);
+    float specular_factor = pow(max(dot(half_direction, normal), 0.0), object_ubo.shininess);
+
+    vec4 diff_samp = vec4(1); //texture(samplers[SAMP_DIFFUSE], in_dto.tex_coord);
+    vec4 ambient = vec4(vec3(in_dto.ambient * object_ubo.diffuse_colour), diff_samp.a);
+    vec4 diffuse = vec4(vec3(light.colour * diffuse_factor), diff_samp.a);
+    vec4 specular = vec4(vec3(light.colour * specular_factor), diff_samp.a);
+
+    if (in_mode == 0) {
+        diffuse *= diff_samp;
+        ambient *= diff_samp;
+        // specular *= vec4(texture(samplers[SAMP_SPECULAR], in_dto.tex_coord).rgb, diffuse.a);
+    }
+
+    return (ambient + diffuse + specular);
+}
+
+vec4 calculate_point_light(point_light light, vec3 normal, vec3 frag_position, vec3 view_direction) {
+    vec3 light_direction = normalize(light.position.xyz - frag_position);
+    float diff = max(dot(normal, light_direction), 0.0);
+
+    vec3 reflect_direction = reflect(-light_direction, normal);
+    float spec = pow(max(dot(view_direction, reflect_direction), 0.0), object_ubo.shininess);
+
+    // Calculate attenuation, or light falloff over distance.
+    float distance = length(light.position.xyz - frag_position);
+    float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));
+
+    vec4 ambient = in_dto.ambient;
+    vec4 diffuse = light.colour * diff;
+    vec4 specular = light.colour * spec;
+
+    if (in_mode == 0) {
+        vec4 diff_samp = vec4(1); //texture(samplers[SAMP_DIFFUSE], in_dto.tex_coord);
+        diffuse *= diff_samp;
+        ambient *= diff_samp;
+        // specular *= vec4(texture(samplers[SAMP_SPECULAR], in_dto.tex_coord).rgb, diffuse.a);
+    }
+
+    ambient *= attenuation;
+    diffuse *= attenuation;
+    specular *= attenuation;
+    return (ambient + diffuse + specular);
+}

assets/shaders/TerrainShader.vert

@@ -0,0 +1,50 @@
+#version 450
+
+layout(location = 0) in vec3 in_position;
+layout(location = 1) in vec3 in_normal;
+layout(location = 2) in vec2 in_texcoord;
+layout(location = 3) in vec4 in_colour;
+layout(location = 4) in vec4 in_tangent;
+
+layout(set = 0, binding = 0) uniform global_uniform_object {
+    mat4 projection;
+    mat4 view;
+    vec4 ambient_colour;
+    vec3 view_position;
+    int mode;
+} global_ubo;
+
+layout(push_constant) uniform push_constants {
+
+    // Only guaranteed a total of 128 bytes.
+    mat4 model; // 64 bytes
+} u_push_constants;
+
+layout(location = 0) out int out_mode;
+
+// Data Transfer Object
+layout(location = 1) out struct dto {
+    vec4 ambient;
+    vec2 tex_coord;
+    vec3 normal;
+    vec3 view_position;
+    vec3 frag_position;
+    vec4 colour;
+    vec4 tangent;
+} out_dto;
+
+void main() {
+    out_dto.tex_coord = in_texcoord;
+    out_dto.colour = in_colour;
+    // Fragment position in world space.
+    out_dto.frag_position = vec3(u_push_constants.model * vec4(in_position, 1.0));
+    // Copy the normal over.
+    mat3 m3_model = mat3(u_push_constants.model);
+    out_dto.normal = normalize(m3_model * in_normal);
+    out_dto.tangent = vec4(normalize(m3_model * in_tangent.xyz), in_tangent.w);
+    out_dto.ambient = global_ubo.ambient_colour;
+    out_dto.view_position = global_ubo.view_position;
+    gl_Position = global_ubo.projection * global_ubo.view * u_push_constants.model * vec4(in_position, 1.0);
+
+    out_mode = global_ubo.mode;
+}

engine/CMakeLists.txt

@@ -53,7 +53,9 @@ set(SOURCES
     resources/skybox.cpp
     resources/texture.cpp
     resources/transform.cpp
+    resources/terrain.cpp
     resources/ui_text.cpp
+
     scenes/simple_scene.cpp
     systems/audio_system.cpp
     systems/camera_system.cpp

engine/plugins/renderer/vulkan/vulkan_shader.cpp

@@ -249,7 +249,7 @@ namespace egkr
 	binding_desc.setBinding(0).setStride(get_attribute_stride()).setInputRate(vk::VertexInputRate::eVertex);
 
 	pipeline_properties pipeline_properties{};
-	pipeline_properties.renderpass = (renderpass::vulkan_renderpass*)renderpass;
+	pipeline_properties.renderpass = renderpass;
 	pipeline_properties.descriptor_set_layout = descriptor_set_layout;
 	pipeline_properties.shader_stage_info = stage_create_infos;
 	pipeline_properties.is_wireframe = false;
@@ -329,7 +329,7 @@ namespace egkr
 	}
 
 	const auto image_index = context_->image_index;
-	auto& command_buffer = context_->graphics_command_buffers[image_index].get_handle();
+	const auto& command_buffer = context_->graphics_command_buffers[image_index].get_handle();
 
 	auto& object_state = instance_states[get_bound_instance_id()];
 	auto& object_descriptor_set = object_state.descriptor_set_state.descriptor_sets[image_index];

engine/renderer/passes/scene_pass.cpp

@@ -5,6 +5,7 @@
 #include <systems/material_system.h>
 
 #include "engine/engine.h"
+#include "systems/light_system.h"
 
 namespace egkr::pass
 {
@@ -63,6 +64,31 @@ namespace egkr::pass
 	    debug_shader_locations.view = debug_colour_shader->get_uniform_index("view");
 	    debug_shader_locations.model = debug_colour_shader->get_uniform_index("model");
 	}
+	{
+	    std::string terrain_shader_name = "Shader.Terrain";
+	    auto shader = resource_system::load(terrain_shader_name, egkr::resource::type::shader, nullptr);
+	    auto* properties = (shader::properties*)shader->data;
+	    shader_system::create_shader(*properties, renderpass.get());
+	    resource_system::unload(shader);
+
+	    terrain_shader = shader_system::get_shader(terrain_shader_name);
+	    terrain_shader->acquire_instance_resources({});
+
+	    terrain_shader_locations.projection = terrain_shader->get_uniform_index("projection");
+	    terrain_shader_locations.view = terrain_shader->get_uniform_index("view");
+	    terrain_shader_locations.shininess = terrain_shader->get_uniform_index("shininess");
+	    terrain_shader_locations.ambient_colour = terrain_shader->get_uniform_index("ambient_colour");
+	    terrain_shader_locations.diffuse_colour = terrain_shader->get_uniform_index("diffuse_colour");
+	    // terrain_shader_locations.diffuse_texture = terrain_shader->get_uniform_index("diffuse_texture");
+	    // terrain_shader_locations.specular_texture = terrain_shader->get_uniform_index("specular_texture");
+	    // terrain_shader_locations.normal_texture = terrain_shader->get_uniform_index("normal_texture");
+	    terrain_shader_locations.view_position = terrain_shader->get_uniform_index("view_position");
+	    terrain_shader_locations.model = terrain_shader->get_uniform_index("model");
+	    terrain_shader_locations.mode = terrain_shader->get_uniform_index("mode");
+	    terrain_shader_locations.point_light = terrain_shader->get_uniform_index("point_lights");
+	    terrain_shader_locations.directional_light = terrain_shader->get_uniform_index("dir_light");
+	    terrain_shader_locations.num_point_lights = terrain_shader->get_uniform_index("num_point_lights");
+	}
 
 	event::register_event(event::code::render_mode, this, on_event);
 	return true;
@@ -73,6 +99,47 @@ namespace egkr::pass
 	engine::get()->get_renderer()->set_active_viewport(viewport);
 	renderpass->begin(frame_data.render_target_index);
 
+	if (!data.terrain.empty())
+	{
+	    const float shininess{32};
+	    const float4 diffuse_colour{0.5, 0.5, 0.5, 1.0};
+	    shader_system::use(terrain_shader->get_id());
+	    shader_system::set_uniform(terrain_shader_locations.projection, &projection);
+	    shader_system::set_uniform(terrain_shader_locations.view, &view);
+	    shader_system::set_uniform(terrain_shader_locations.ambient_colour, &data.ambient_colour);
+	    shader_system::set_uniform(terrain_shader_locations.view_position, &view_position);
+	    shader_system::set_uniform(terrain_shader_locations.mode, &data.render_mode);
+
+	    shader_system::apply_global(true);
+
+	    shader_system::bind_instance(0);
+	    shader_system::set_uniform(terrain_shader_locations.diffuse_colour, &diffuse_colour);
+	    shader_system::set_uniform(terrain_shader_locations.directional_light, light_system::get_directional_light());
+	    shader_system::set_uniform(terrain_shader_locations.point_light, light_system::get_point_lights().data());
+	    auto num_point_lights = light_system::point_light_count();
+	    shader_system::set_uniform(terrain_shader_locations.num_point_lights, &num_point_lights);
+	    shader_system::set_uniform(terrain_shader_locations.shininess, &shininess);
+	    shader_system::apply_instance(true);
+
+	    for (const auto& terrain : data.terrain)
+	    {
+		const auto& world = terrain.transform.lock()->get_world();
+		shader_system::set_uniform(terrain_shader_locations.model, &world);
+	    }
+
+	    if (data.terrain.front().is_winding_reversed)
+	    {
+		engine::get()->get_renderer()->set_winding(winding::clockwise);
+	    }
+
+	    data.terrain.front().render_geometry->draw();
+
+	    if (data.terrain.front().is_winding_reversed)
+	    {
+		engine::get()->get_renderer()->set_winding(winding::counter_clockwise);
+	    }
+	}
+
 	shader_system::use(material_shader->get_id());
 	material_system::apply_global(material_shader->get_id(), frame_data, projection, view, data.ambient_colour, view_position, data.render_mode);
 

engine/renderer/passes/scene_pass.h

@@ -15,7 +15,7 @@ namespace egkr::pass
 	    uint32_t render_mode;
 	    float4 ambient_colour;
 	    egkr::vector<egkr::render_data> geometries;
-	    // egkr::vector<egkr::render_data> terrain;
+	    egkr::vector<egkr::render_data> terrain;
 	    egkr::vector<egkr::render_data> debug_geometries;
 	} data;
 
@@ -26,8 +26,27 @@ namespace egkr::pass
 	    uint32_t model{};
 	} debug_shader_locations;
 
+	struct terrain_shader_locations
+	{
+	    uint32_t projection{};
+	    uint32_t view{};
+	    uint32_t ambient_colour{};
+	    uint32_t view_position{};
+	    uint32_t diffuse_colour{};
+	    uint32_t diffuse_texture{};
+	    uint32_t specular_texture{};
+	    uint32_t normal_texture{};
+	    uint32_t shininess{};
+	    uint32_t model{};
+	    uint32_t mode{};
+	    uint32_t directional_light{};
+	    uint32_t point_light{};
+	    uint32_t num_point_lights{};
+	} terrain_shader_locations;
+
 	shader::shared_ptr material_shader;
 	shader::shared_ptr debug_colour_shader;
+	shader::shared_ptr terrain_shader;
 
 	static scene* create();
 	bool init() override;