RENDERER: added planegrid renderer

https://dev.to/javiersalcedopuyo/simple-infinite-grid-shader-5fah

Author: mgerhardy

src/modules/render/CMakeLists.txt

@@ -10,6 +10,7 @@ set(SHADERS
 	combine2
 	convolution
 	texture
+	planegrid
 )
 set(SRCS_SHADERS)
 foreach (SHADER ${SHADERS})

src/modules/render/GridRenderer.cpp

@@ -3,6 +3,7 @@
  */
 
 #include "GridRenderer.h"
+#include "PlanegridShader.h"
 #include "core/Color.h"
 #include "core/GLM.h"
 #include "core/GLMConst.h"
@@ -11,12 +12,17 @@
 #include "math/AABB.h"
 #include "math/Plane.h"
 #include "video/Camera.h"
+#include "video/RendererInterface.h"
 #include "video/ScopedState.h"
+#include "video/Shader.h"
+#include "video/Types.h"
+#include "video/gl/GLTypes.h"
 
 namespace render {
 
 GridRenderer::GridRenderer(bool renderAABB, bool renderGrid, bool renderPlane)
-	: _renderAABB(renderAABB), _renderGrid(renderGrid), _renderPlane(renderPlane) {
+	: _planeShader(shader::PlanegridShader::getInstance()), _renderAABB(renderAABB), _renderGrid(renderGrid),
+	  _renderPlane(renderPlane) {
 }
 
 bool GridRenderer::init() {
@@ -25,6 +31,13 @@ bool GridRenderer::init() {
 		return false;
 	}
 
+	if (!_planeShader.setup()) {
+		Log::error("Failed to setup color shader");
+		return false;
+	}
+	core_assert_always(_uniformBlock.create(_uniformBlockData));
+	core_assert_always(_planeShader.setUniformblock(_uniformBlock.getUniformblockUniformBuffer()));
+
 	return true;
 }
 
@@ -189,13 +202,20 @@ void GridRenderer::renderPlane(const video::Camera &camera) {
 	if (!_renderPlane) {
 		return;
 	}
-	if (_dirtyPlane) {
-		createPlane();
-		_dirtyPlane = false;
-	}
-	_shapeRenderer.hide(_plane, false);
-	_shapeRenderer.render(_plane, camera);
-	_shapeRenderer.hide(_plane, true);
+	video::ScopedShader scopedShader(_planeShader);
+	_uniformBlockData.cameraPos = camera.eye();
+	_uniformBlockData.proj = camera.projectionMatrix();
+	_uniformBlockData.view = camera.viewMatrix();
+	core_assert_always(_uniformBlock.update(_uniformBlockData));
+	core_assert_always(_planeShader.setUniformblock(_uniformBlock.getUniformblockUniformBuffer()));
+
+	video::bindVertexArray(video::InvalidId);
+	core_assert(video::boundVertexArray() == video::InvalidId);
+	video::unbindBuffer(video::BufferType::IndexBuffer);
+	core_assert(video::boundBuffer(video::BufferType::IndexBuffer) == video::InvalidId);
+	video::unbindBuffer(video::BufferType::ArrayBuffer);
+	core_assert(video::boundBuffer(video::BufferType::ArrayBuffer) == video::InvalidId);
+	video::drawArrays(video::Primitive::TriangleStrip, 4);
 }
 
 void GridRenderer::renderForwardArrow(const video::Camera &camera) {
@@ -217,6 +237,8 @@ void GridRenderer::shutdown() {
 	_plane = -1;
 	_shapeRenderer.shutdown();
 	_shapeBuilder.shutdown();
+	_planeShader.shutdown();
+	_uniformBlock.shutdown();
 }
 
 } // namespace render

src/modules/render/GridRenderer.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "PlanegridShader.h"
 #include "core/Log.h"
 #include "render/ShapeRenderer.h"
 #include "video/ShapeBuilder.h"
@@ -26,6 +27,9 @@ class GridRenderer {
 protected:
 	video::ShapeBuilder _shapeBuilder;
 	render::ShapeRenderer _shapeRenderer;
+	shader::PlanegridShader &_planeShader;
+	alignas(16) mutable shader::PlanegridData::UniformblockData _uniformBlockData;
+	mutable shader::PlanegridData _uniformBlock;
 	math::AABB<float> _aabb;
 
 	int32_t _aabbMeshIndex = -1;

src/modules/render/shaders/planeconstant.glsl

@@ -0,0 +1,22 @@
+const float grid_size = 100.0;
+const float cell_size = 1.0;
+const float half_cell_size = cell_size * 0.5;
+const float cell_line_thickness = 0.005;
+
+const float subcell_size = 0.1;
+const float half_subcell_size = subcell_size * 0.5;
+const float subcell_line_thickness = 0.001;
+
+const vec4 cell_color = vec4(0.75, 0.75, 0.75, 0.5);
+const vec4 subcell_color = vec4(0.5, 0.5, 0.5, 0.5);
+
+const float height_to_fade_distance_ratio = 25.0;
+const float min_fade_distance = grid_size * 0.05;
+const float max_fade_distance = grid_size * 0.5;
+
+const vec4 positions[4] = vec4[4](
+	vec4(-0.5, 0.0,  0.5, 1.0),
+	vec4( 0.5, 0.0,  0.5, 1.0),
+	vec4(-0.5, 0.0, -0.5, 1.0),
+	vec4( 0.5, 0.0, -0.5, 1.0)
+);

src/modules/render/shaders/planegrid.frag

@@ -0,0 +1,48 @@
+// https://dev.to/javiersalcedopuyo/simple-infinite-grid-shader-5fah
+
+#extension GL_ARB_shading_language_420pack : enable
+
+in VertexOut {
+	vec4 position;
+	vec3 camera_pos;
+	vec2 coords;
+} v_in;
+
+out vec4 o_color;
+
+#include "planeconstant.glsl"
+
+// Fragment shader
+void main() {
+	// Offset coordinates for grid alignment
+	vec2 cell_coords = mod(v_in.coords + half_cell_size, cell_size);
+	vec2 subcell_coords = mod(v_in.coords + half_subcell_size, subcell_size);
+
+	// Distance to edges
+	vec2 distance_to_cell = abs(cell_coords - half_cell_size);
+	vec2 distance_to_subcell = abs(subcell_coords - half_subcell_size);
+
+	// Line thickness adjustment
+	vec2 d = fwidth(v_in.coords);
+	float adjusted_cell_line_thickness = 0.5 * (cell_line_thickness + d.x);
+	float adjusted_subcell_line_thickness = 0.5 * (subcell_line_thickness + d.x);
+
+	vec4 color = vec4(0.0);
+	if (any(lessThan(distance_to_subcell, vec2(adjusted_subcell_line_thickness)))) {
+		color = subcell_color;
+	}
+	if (any(lessThan(distance_to_cell, vec2(adjusted_cell_line_thickness)))) {
+		color = cell_color;
+	}
+
+	// Fade out effect
+	float opacity_falloff;
+	{
+		float distance_to_camera = length(v_in.coords - v_in.camera_pos.xz);
+		float fade_distance = abs(v_in.camera_pos.y) * height_to_fade_distance_ratio;
+		fade_distance = clamp(fade_distance, min_fade_distance, max_fade_distance);
+		opacity_falloff = smoothstep(1.0, 0.0, distance_to_camera / fade_distance);
+	}
+
+	o_color = color * opacity_falloff;
+}

src/modules/render/shaders/planegrid.vert

@@ -0,0 +1,32 @@
+// https://dev.to/javiersalcedopuyo/simple-infinite-grid-shader-5fah
+#extension GL_ARB_shading_language_420pack : enable
+
+layout(std140, binding = 0) uniform u_uniformblock {
+	vec3 camera_pos;
+	mat4 view;
+	mat4 proj;
+};
+
+#include "planeconstant.glsl"
+
+// Vertex input and output
+layout(location = 0) in uint a_vertex_id;
+
+out VertexOut {
+	vec4 position;
+	vec3 camera_pos;
+	vec2 coords;
+} v_out;
+
+// Vertex shader
+void main() {
+	vec4 world_pos = positions[a_vertex_id];
+	world_pos.xyz *= grid_size;
+	world_pos.xz += camera_pos.xz; // Make the quad follows the camera for "infinity"
+
+	v_out.position = proj * view * world_pos;
+	v_out.camera_pos = camera_pos;
+	v_out.coords = world_pos.xz;
+
+	gl_Position = v_out.position;
+}