rob/HydraV3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tessalation started

Browse Source
This commit is contained in:
Confideo-IOM
2026-09-28 15:31:22 +01:00
parent 6e1a531f94
commit 7a1eaa3654
24 changed files with 384 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
HydraEngine/source/HydraDefines.h
+2 -1
View File
@@ -69,7 +69,8 @@ enum class HYDRA_RENDERABLE_TYPE
HYDRA_TRANSPARENT,
HYDRA_LIGHTING,
HYDRA_OUTPUT,
HYDRA_TEXTURE_DEBUG
HYDRA_TEXTURE_DEBUG,
HYDRA_LANDSCAPE
};
enum class HYDRA_BUFFER_TYPE
HydraEngine/source/ShaderFiles/landscape_shader.frag
+79
View File
@@ -0,0 +1,79 @@
//*PIXEL*
#version 460 core
#extension GL_ARB_bindless_texture : require
uint INVALID_HYDRA_ID = 4294967295;
struct MaterialStore
{
vec4 diffuse_colour;
vec4 matalic_rough;
uint diffuse_texture_id;
uint metallic_rough_texture_id;
uint normal_texture_id;
uint padding[1];
};
layout(binding = 2, std430) readonly buffer material_buffer
{
MaterialStore materials[1000];
};
layout( std430, binding = 3) readonly buffer texture_buffer {
uvec2 textures[1000];
};
layout (location=0) in TE_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}vs_out;
layout (location=0) out vec4 diffuse_out;
layout (location=1) out vec4 metalic_rough_out;
layout (location=2) out vec4 normal_out;
layout (location=3) out vec4 position_out;
void main()
{
MaterialStore mat = materials[vs_out.vsMaterialID];
vec4 diffuse_val = mat.diffuse_colour;
vec4 mat_rough_val =mat.matalic_rough;
vec3 normal_val = vs_out.vsNormal;
if(mat.diffuse_texture_id != INVALID_HYDRA_ID)
{
uvec2 diffuse_handle = textures[mat.diffuse_texture_id];
diffuse_val = diffuse_val * texture(sampler2D(diffuse_handle), vs_out.vsUV.xy);
}
if(mat.metallic_rough_texture_id != INVALID_HYDRA_ID)
{
uvec2 metal_rough_handle = textures[mat.metallic_rough_texture_id];
mat_rough_val = texture(sampler2D(metal_rough_handle), vs_out.vsUV.xy);
}
if(mat.normal_texture_id != INVALID_HYDRA_ID)
{
uvec2 normal_handle = textures[mat.normal_texture_id];
normal_val = texture(sampler2D(normal_handle), vs_out.vsUV.xy).xyz;
normal_val = (normal_val * 2.0) - 1.0;
normal_val = normalize(vs_out.vsTBN * normal_val);
}
if(diffuse_val[3] <= 0.4)
{
discard;
}
diffuse_out = diffuse_val;
metalic_rough_out = mat_rough_val;
normal_out = vec4(normal_val,1);
position_out = vs_out.vsWorldPos;
}
HydraEngine/source/ShaderFiles/landscape_shader.tesc
+60
View File
@@ -0,0 +1,60 @@
// tessellation control shader
#version 450 core
// specify number of control points per patch output
// this value controls the size of the input and output arrays
layout (vertices=4) out;
layout (location=0) in VS_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}tc_in[];
layout (location=0) out TC_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}tc_out[];
void main()
{
// ----------------------------------------------------------------------
// pass attributes through
gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
tc_out[gl_InvocationID].vsUV = tc_in[gl_InvocationID].vsUV;
tc_out[gl_InvocationID].vsWorldPos = tc_in[gl_InvocationID].vsWorldPos;
tc_out[gl_InvocationID].vsNormal = tc_in[gl_InvocationID].vsNormal;
tc_out[gl_InvocationID].vsBiTangent = tc_in[gl_InvocationID].vsBiTangent;
tc_out[gl_InvocationID].vsTangent = tc_in[gl_InvocationID].vsTangent;
tc_out[gl_InvocationID].vsTBN = tc_in[gl_InvocationID].vsTBN;
tc_out[gl_InvocationID].vsChunkID = tc_in[gl_InvocationID].vsChunkID;
tc_out[gl_InvocationID].vsMaterialID = tc_in[gl_InvocationID].vsMaterialID;
// ----------------------------------------------------------------------
// invocation zero controls tessellation levels for the entire patch
if (gl_InvocationID == 0)
{
int divs = 63;
gl_TessLevelOuter[0] = divs;
gl_TessLevelOuter[1] = divs;
gl_TessLevelOuter[2] = divs;
gl_TessLevelOuter[3] = divs;
gl_TessLevelInner[0] = divs;
gl_TessLevelInner[1] = divs;
}
}
HydraEngine/source/ShaderFiles/landscape_shader.tese
+93
View File
@@ -0,0 +1,93 @@
// tessellation evaluation shader
#version 450 core
layout (quads, equal_spacing, ccw) in;
layout(std430, binding = 1) readonly buffer positions_buffer
{
mat4 model_matrix[];
};
layout(binding = 0) uniform uniform_per_frame
{
mat4 view;
mat4 proj;
vec3 viewer_pos;
uint light_count;
} ubo_per_frame;
// received from Tessellation Control Shader - all texture coordinates for the patch vertices
// varying input from vertex shader
layout (location=0) in TC_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}te_in[];
layout (location=0) out TE_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}te_out;
void main()
{
// get patch coordinate
te_out.vsUV.x = gl_TessCoord.x;
te_out.vsUV.y = gl_TessCoord.y;
// ----------------------------------------------------------------------
// retrieve control point texture coordinates
vec2 t00 = te_in[0].vsUV;
vec2 t01 = te_in[1].vsUV;
vec2 t10 = te_in[2].vsUV;
vec2 t11 = te_in[3].vsUV;
// t00|t10
// -------
// t10|t11
// ----------------------------------------------------------------------
// retrieve control point position coordinates
vec4 p00 = gl_in[0].gl_Position;
vec4 p01 = gl_in[1].gl_Position;
vec4 p10 = gl_in[2].gl_Position;
vec4 p11 = gl_in[3].gl_Position;
// compute patch surface normal
vec4 uVec = p01 - p00;
vec4 vVec = p10 - p00;
vec4 normal = normalize( vec4(cross(uVec.xyz, vVec.xyz), 1));
te_out.vsNormal = normal.xyz;
// bilinearly interpolate position coordinate across patch
vec4 p0 = (p01 - p00) * te_out.vsUV.x + p00;
vec4 p1 = (p11 - p10) * te_out.vsUV.x + p10;
vec4 p = (p1 - p0) * te_out.vsUV.y + p0;
// displace point along normal
// p += -normal * height;
//height = 0;
//p[3] = 1;
// ----------------------------------------------------------------------
// output patch point position in clip space
mat4 model = model_matrix[te_in[0].vsChunkID];
mat4 view = ubo_per_frame.view;
mat4 proj = ubo_per_frame.proj;
gl_Position = proj * view * model * p;
}
HydraEngine/source/ShaderFiles/landscape_shader.vert
+59
View File
@@ -0,0 +1,59 @@
#version 460 core
#extension GL_ARB_bindless_texture : require
layout(binding = 0) uniform uniform_per_frame
{
mat4 view;
mat4 proj;
vec3 viewer_pos;
uint light_count;
} ubo_per_frame;
layout(std430, binding = 1) readonly buffer positions_buffer
{
mat4 model_matrix[];
};
layout (location = 0) in vec3 inPos; //12 bytes : 0
layout (location = 1) in vec2 inUV; //8 Bytes : 12
layout (location = 2) in uvec3 inChunkID; //12 Bytes : 20
layout (location = 3) in vec3 inNormal; //8 Bytes : 12
layout (location = 4) in vec3 inBiTangent;
layout (location = 5) in vec3 inTangent;
layout(location=0) out VS_OUT
{
vec2 vsUV;
vec4 vsWorldPos;
vec3 vsNormal;
vec3 vsBiTangent;
vec3 vsTangent;
mat3 vsTBN;
flat uint vsChunkID;
flat uint vsMaterialID;
}vs_out;
out vec2 vertUV_out;
out ivec4 vertEdges_out;
out int vertChild_out;
void main()
{
uint chunkid = inChunkID[0];
mat4 model = model_matrix[chunkid];
mat4 view = ubo_per_frame.view;
mat4 proj = ubo_per_frame.proj;
//model = mat4(1);
gl_Position = proj * view * model * vec4(inPos, 1.0);
vs_out.vsWorldPos = model * vec4(inPos,1);
vs_out.vsNormal = normalize(vec3(model * vec4(normalize(inNormal),0)));
vs_out.vsTangent = normalize(vec3(model *vec4(inTangent,0))) ;
vs_out.vsBiTangent = normalize(vec3(model *vec4(inBiTangent,0)));
vs_out.vsTBN = mat3(vs_out.vsTangent, vs_out.vsBiTangent, vs_out.vsNormal);
vs_out.vsUV = inUV;
vs_out.vsChunkID = chunkid;
vs_out.vsMaterialID = inChunkID[1];
}
HydraEngine/source/pipeline/HydraDeferredPipeline.cpp
+55 -5
View File
@@ -30,7 +30,9 @@ void HydraDeferredPipeline::Initialise()
_CreateOutputActor();
_CreateFrameBuffer();
_CreateColourRenderStage();
_CreateLandscapeRenderStage();
_CreateOutputRenderStage();
//_CreateTextureDebugOutputStage();
}
@@ -120,8 +122,8 @@ void HydraDeferredPipeline::_CreateFrameBuffer()
HydraEngine* engine = GetEngine();
HydraTextureBufferManager* tex_buffer_manager = engine->TextureBufferManager();
HydraRenderSettings render_settings = engine->RenderSettings();
glGenFramebuffers(1, &m_frame_buffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, m_frame_buffer_id);
glGenFramebuffers(1, &m_frame_buffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, m_frame_buffer_id);
HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
@@ -207,7 +209,7 @@ void HydraDeferredPipeline::_CreateColourRenderStage()
std::vector<uint32_t> textures;
render_stage->Initialise(shader_path + "deferred_shader.vert",
shader_path + "deferred_shader.frag", "",
shader_path + "deferred_shader.frag", "", "", "",
shader_binding,
m_frame_buffer_id,
textures,
@@ -218,6 +220,54 @@ void HydraDeferredPipeline::_CreateColourRenderStage()
m_render_stages.push_back(render_stage);
}
void HydraDeferredPipeline::_CreateLandscapeRenderStage()
{
HydraRenderStage* render_stage = new HydraRenderStage();
std::string shader_path = std::string(shader_base);
HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
HydraID mat_buffer_id = buffer_manager->FindBuffer("MaterialBuffer");
HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
HydraID per_frame_buffer_id = buffer_manager->FindBuffer("DeferredPerFrameUBO");
HydraShaderBinding shader_binding = {};
shader_binding.block_name.push_back("positions_buffer");
shader_binding.binding_point.push_back(1);
shader_binding.buffer_id.push_back(pos_buffer_id);
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
shader_binding.block_name.push_back("material_buffer");
shader_binding.binding_point.push_back(2);
shader_binding.buffer_id.push_back(mat_buffer_id);
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
shader_binding.block_name.push_back("texture_buffer");
shader_binding.binding_point.push_back(3);
shader_binding.buffer_id.push_back(tex_buffer_id);
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
shader_binding.block_name.push_back("uniform_per_frame");
shader_binding.binding_point.push_back(0);
shader_binding.buffer_id.push_back(per_frame_buffer_id);
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
std::vector<uint32_t> textures;
render_stage->Initialise(shader_path + "landscape_shader.vert",
shader_path + "landscape_shader.frag",
"",
shader_path + "landscape_shader.tesc",
shader_path + "landscape_shader.tese",
shader_binding,
m_frame_buffer_id,
textures,
true,
GL_BACK,
true,
HYDRA_RENDERABLE_TYPE::HYDRA_LANDSCAPE);
m_render_stages.push_back(render_stage);
}
void HydraDeferredPipeline::_CreateOutputRenderStage()
{
@@ -283,7 +333,7 @@ void HydraDeferredPipeline::_CreateOutputRenderStage()
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
render_stage->Initialise(shader_path + "deferred_output_shader.vert",
shader_path + "deferred_output_shader.frag", "",
shader_path + "deferred_output_shader.frag", "", "", "",
shader_binding,
0,
textures,
@@ -328,7 +378,7 @@ void HydraDeferredPipeline::_CreateTextureDebugOutputStage()
shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
render_stage->Initialise(shader_path + "texture_debug_shader.vert",
shader_path + "texture_debug_shader.frag", "",
shader_path + "texture_debug_shader.frag", "", "", "",
shader_binding,
0,
textures,
HydraEngine/source/pipeline/HydraDeferredPipeline.h
+1 -1
View File
@@ -32,7 +32,7 @@ class HydraDeferredPipeline : public HydraPipeline
void _UpdateUBO();
void _CreateFrameBuffer();
void _CreateLandscapeRenderStage();
void _CreateColourRenderStage();
void _CreateOutputRenderStage();
void _CreateOutputActor();
HydraEngine/source/pipeline/HydraForwardPipeline.cpp
+1 -1
View File
@@ -36,7 +36,7 @@ void HydraForwardPipeline::Initialise()
std::vector<uint32_t> textures;
std::vector<uint32_t> rb_attachments;
render_stage->Initialise(shader_path + "forward_shader.vert", shader_path + "forward_shader.frag", "", shader_binding, 0, textures, true, GL_BACK, true, HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
render_stage->Initialise(shader_path + "forward_shader.vert", shader_path + "forward_shader.frag", "", "", "", shader_binding, 0, textures, true, GL_BACK, true, HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
m_render_stages.push_back(render_stage);
m_per_frame_ubo = buffer_manager->CreateGPUBuffer("PerFrameUBO",
HydraEngine/source/pipeline/HydraRenderStage.cpp
+24 -13
View File
@@ -15,6 +15,8 @@
void HydraRenderStage::Initialise(std::string vertex_shader_file,
std::string fragment_shader_file,
std::string geometry_shader_file,
std::string tess_control_shader_file,
std::string tess_evaluation_shader_file,
HydraShaderBinding shader_binding,
uint32_t framebuffer_id,
std::vector<uint32_t> textures,
@@ -46,6 +48,16 @@ void HydraRenderStage::Initialise(std::string vertex_shader_file,
m_geometry_shader = _LoadShader(geometry_shader_file, GL_GEOMETRY_SHADER);
glAttachShader(m_program, m_geometry_shader);
}
if (tess_control_shader_file.length() > 0)
{
m_tess_control_shader = _LoadShader(tess_control_shader_file, GL_TESS_CONTROL_SHADER);
glAttachShader(m_program, m_tess_control_shader);
}
if (tess_evaluation_shader_file.length() > 0)
{
m_tess_evaluation_shader = _LoadShader(tess_evaluation_shader_file, GL_TESS_EVALUATION_SHADER);
glAttachShader(m_program, m_tess_evaluation_shader);
}
glLinkProgram(m_program);
int success;
@@ -123,12 +135,12 @@ void HydraRenderStage::Render(std::set<HydraID> &entities, uint32_t framebuffer_
HydraVertexBuffer &vertex_buffer = vert_buffer_mananger->GetVertexBuffer(mesh_comp.vertex_buffer_id);
glBindVertexArray(vertex_buffer.vao);
glDrawElements(GL_TRIANGLES, vertex_buffer.triangle_count, GL_UNSIGNED_INT, (void *)0);
glDrawElements(GL_TRIANGLES, vertex_buffer.triangle_count, GL_UNSIGNED_INT, (void *)0);
}
}
}
}
glBindVertexArray(0);
glBindVertexArray(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
@@ -180,19 +192,18 @@ void HydraRenderStage::_BindBuffers()
for (uint32_t bind_idx = 0; bind_idx < m_shader_binding.block_name.size(); bind_idx++)
{
HydraBuffer buffer = buffer_manager->GetBuffer(m_shader_binding.buffer_id[bind_idx]);
switch (m_shader_binding.buffer_type[bind_idx])
{
case HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER:
{
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
break;
}
case HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER:
{
glBindBufferBase(GL_UNIFORM_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
break;
}
case HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER:
{
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
break;
}
case HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER:
{
glBindBufferBase(GL_UNIFORM_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
break;
}
}
}
}
HydraEngine/source/pipeline/HydraRenderStage.h
+4
View File
@@ -13,6 +13,8 @@ class HydraRenderStage : public HydraObject
void Initialise(std::string vertex_shader_file,
std::string fragment_shader_file,
std::string geometry_shader_file,
std::string tess_control_shader_file,
std::string tess_evaluation_shader_file,
HydraShaderBinding shader_binding,
uint32_t framebuffer_id,
std::vector<uint32_t> textures,
@@ -32,6 +34,8 @@ class HydraRenderStage : public HydraObject
uint32_t m_vertex_shader = GL_INVALID_VALUE;
uint32_t m_fragment_shader = GL_INVALID_VALUE;
uint32_t m_geometry_shader = GL_INVALID_VALUE;
uint32_t m_tess_control_shader = GL_INVALID_VALUE;
uint32_t m_tess_evaluation_shader = GL_INVALID_VALUE;
uint32_t m_program = GL_INVALID_VALUE;
uint32_t m_renderable_type;
uint32_t m_framebuffer_id = 0;
HydraEngine/source/pipeline/HydraShadowPipeline.cpp
+3 -1
View File
@@ -158,6 +158,7 @@ void HydraShadowPipeline::_CreatePointRenderStage()
render_stage->Initialise(shader_path + "shadow_point_shader.vert",
shader_path + "shadow_point_shader.frag",
shader_path + "shadow_point_shader.geom",
"", "",
shader_binding,
0,
textures,
@@ -212,6 +213,7 @@ void HydraShadowPipeline::_CreateDirectionalRenderStage()
render_stage->Initialise(shader_path + "shadow_cascade_shader.vert",
shader_path + "shadow_cascade_shader.frag",
shader_path + "shadow_cascade_shader.geom",
"","",
shader_binding,
0,
textures,
@@ -265,7 +267,7 @@ void HydraShadowPipeline::_CreateSpotRenderStage()
render_stage->Initialise(shader_path + "shadow_spot_shader.vert",
shader_path + "shadow_spot_shader.frag",
"",
"", "", "",
shader_binding,
0,
textures,
HydraEngine/source/renderer/HydraRenderer.cpp
+1
View File
@@ -26,6 +26,7 @@ void HydraRenderer::Initialise(HydraRenderSettings render_settings)
glEnable(GL_DEPTH_TEST);
glEnable(GL_DEBUG_OUTPUT);
glfwSwapInterval(0);
// glDebugMessageCallback(MessageCallback, 0);
}