1 files changed, 148 insertions, 43 deletions

diff --git a/drivers/gles3/rasterizer_canvas_gles3.h b/drivers/gles3/rasterizer_canvas_gles3.h
index 372ac00493..d672d05e14 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.h
+++ b/drivers/gles3/rasterizer_canvas_gles3.h
@@ -40,6 +40,7 @@
 #include "storage/texture_storage.h"
 
 #include "shaders/canvas.glsl.gen.h"
+#include "shaders/canvas_occlusion.glsl.gen.h"
 
 class RasterizerSceneGLES3;
 
@@ -96,6 +97,63 @@ class RasterizerCanvasGLES3 : public RendererCanvasRender {
 		DEFAULT_MAX_LIGHTS_PER_RENDER = 256,
 	};
 
+	/******************/
+	/**** LIGHTING ****/
+	/******************/
+
+	struct CanvasLight {
+		RID texture;
+		struct {
+			bool enabled = false;
+			float z_far;
+			float y_offset;
+			Transform2D directional_xform;
+		} shadow;
+	};
+
+	RID_Owner<CanvasLight> canvas_light_owner;
+
+	struct OccluderPolygon {
+		RS::CanvasOccluderPolygonCullMode cull_mode = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+		int line_point_count = 0;
+		GLuint vertex_buffer = 0;
+		GLuint vertex_array = 0;
+		GLuint index_buffer = 0;
+
+		int sdf_point_count = 0;
+		int sdf_index_count = 0;
+		GLuint sdf_vertex_buffer = 0;
+		GLuint sdf_vertex_array = 0;
+		GLuint sdf_index_buffer = 0;
+		bool sdf_is_lines = false;
+	};
+
+	RID_Owner<OccluderPolygon> occluder_polygon_owner;
+
+	void _update_shadow_atlas();
+
+	struct {
+		CanvasOcclusionShaderGLES3 shader;
+		RID shader_version;
+	} shadow_render;
+
+	struct LightUniform {
+		float matrix[8]; //light to texture coordinate matrix
+		float shadow_matrix[8]; //light to shadow coordinate matrix
+		float color[4];
+
+		uint8_t shadow_color[4];
+		uint32_t flags; //index to light texture
+		float shadow_pixel_size;
+		float height;
+
+		float position[2];
+		float shadow_z_far_inv;
+		float shadow_y_ofs;
+
+		float atlas_rect[4];
+	};
+
 public:
 	enum {
 		BASE_UNIFORM_LOCATION = 0,
@@ -125,6 +183,23 @@ public:
 		uint32_t pad2;
 	};
 
+	struct PolygonBuffers {
+		GLuint vertex_buffer = 0;
+		GLuint vertex_array = 0;
+		GLuint index_buffer = 0;
+		int count = 0;
+		bool color_disabled = false;
+		Color color;
+	};
+
+	struct {
+		HashMap<PolygonID, PolygonBuffers> polygons;
+		PolygonID last_id = 0;
+	} polygon_buffers;
+
+	RendererCanvasRender::PolygonID request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) override;
+	void free_polygon(PolygonID p_polygon) override;
+
 	struct InstanceData {
 		float world[6];
 		float color_texture_pixel_size[2];
@@ -156,42 +231,86 @@ public:
 		GLuint canvas_quad_vertices;
 		GLuint canvas_quad_array;
 
+		GLuint indexed_quad_buffer;
+		GLuint indexed_quad_array;
+
 		GLuint particle_quad_vertices;
 		GLuint particle_quad_array;
 
 		GLuint ninepatch_vertices;
 		GLuint ninepatch_elements;
+
+		RID canvas_shader_default_version;
+
+		uint32_t max_lights_per_render = 256;
+		uint32_t max_lights_per_item = 16;
+		uint32_t max_instances_per_batch = 512;
+		uint32_t max_instances_per_ubo = 16384;
+		uint32_t max_instance_buffer_size = 16384 * 128;
 	} data;
 
+	struct Batch {
+		// Position in the UBO measured in bytes
+		uint32_t start = 0;
+		uint32_t instance_count = 0;
+
+		RID tex = RID();
+		RS::CanvasItemTextureFilter filter = RS::CANVAS_ITEM_TEXTURE_FILTER_MAX;
+		RS::CanvasItemTextureRepeat repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_MAX;
+
+		GLES3::CanvasShaderData::BlendMode blend_mode = GLES3::CanvasShaderData::BLEND_MODE_MIX;
+		Color blend_color = Color(1.0, 1.0, 1.0, 1.0);
+
+		Item *clip = nullptr;
+
+		RID material = RID();
+		GLES3::CanvasMaterialData *material_data = nullptr;
+		CanvasShaderGLES3::ShaderVariant shader_variant = CanvasShaderGLES3::MODE_QUAD;
+
+		const Item::Command *command = nullptr;
+		Item::Command::Type command_type = Item::Command::TYPE_ANIMATION_SLICE; // Can default to any type that doesn't form a batch.
+		uint32_t primitive_points = 0;
+
+		bool lights_disabled = false;
+	};
+
+	// DataBuffer contains our per-frame data. I.e. the resources that are updated each frame.
+	// We track them and ensure that they don't get reused until at least 2 frames have passed
+	// to avoid the GPU stalling to wait for a resource to become available.
+	struct DataBuffer {
+		GLuint ubo = 0;
+		GLuint light_ubo = 0;
+		GLuint state_ubo = 0;
+		uint64_t last_frame_used = -3;
+		GLsync fence = GLsync();
+	};
+
 	struct State {
-		GLuint canvas_state_buffer;
-		LocalVector<GLuint> canvas_instance_data_buffers;
-		LocalVector<GLsync> fences;
+		LocalVector<DataBuffer> canvas_instance_data_buffers;
+		LocalVector<Batch> canvas_instance_batches;
 		uint32_t current_buffer = 0;
+		uint32_t current_buffer_index = 0;
+		uint32_t current_batch_index = 0;
 
 		InstanceData *instance_data_array = nullptr;
-		bool canvas_texscreen_used;
-		RID canvas_shader_current_version;
-		RID canvas_shader_default_version;
+
+		LightUniform *light_uniforms = nullptr;
+
+		GLuint shadow_texture = 0;
+		GLuint shadow_depth_buffer = 0;
+		GLuint shadow_fb = 0;
+		int shadow_texture_size = 2048;
+
+		bool using_directional_lights = false;
 
 		RID current_tex = RID();
-		Size2 current_pixel_size = Size2();
-		RID current_normal = RID();
-		RID current_specular = RID();
-		GLES3::Texture *current_tex_ptr;
-		RID current_shader_version = RID();
-		RS::PrimitiveType current_primitive = RS::PRIMITIVE_MAX;
-		uint32_t current_primitive_points = 0;
-		Item::Command::Type current_command = Item::Command::TYPE_RECT;
+		RS::CanvasItemTextureFilter current_filter_mode = RS::CANVAS_ITEM_TEXTURE_FILTER_MAX;
+		RS::CanvasItemTextureRepeat current_repeat_mode = RS::CANVAS_ITEM_TEXTURE_REPEAT_MAX;
 
 		bool transparent_render_target = false;
 
 		double time = 0.0;
 
-		uint32_t max_lights_per_render;
-		uint32_t max_lights_per_item;
-		uint32_t max_instances_per_batch;
-
 		RS::CanvasItemTextureFilter default_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
 		RS::CanvasItemTextureRepeat default_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
 	} state;
@@ -201,6 +320,8 @@ public:
 	RID default_canvas_texture;
 	RID default_canvas_group_material;
 	RID default_canvas_group_shader;
+	RID default_clip_children_material;
+	RID default_clip_children_shader;
 
 	typedef void Texture;
 
@@ -210,9 +331,6 @@ public:
 	void draw_lens_distortion_rect(const Rect2 &p_rect, float p_k1, float p_k2, const Vector2 &p_eye_center, float p_oversample);
 
 	void reset_canvas();
-	void canvas_light_shadow_buffer_update(RID p_buffer, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders, Projection *p_xform_cache);
-
-	virtual void canvas_debug_viewport_shadows(Light *p_lights_with_shadow) override;
 
 	RID light_create() override;
 	void light_set_texture(RID p_rid, RID p_texture) override;
@@ -229,31 +347,18 @@ public:
 	bool free(RID p_rid) override;
 	void update() override;
 
-	void _bind_canvas_texture(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, uint32_t &r_index);
-
-	struct PolygonBuffers {
-		GLuint vertex_buffer;
-		GLuint vertex_array;
-		GLuint index_buffer;
-		int count;
-		bool color_disabled = false;
-		Color color;
-	};
-
-	struct {
-		HashMap<PolygonID, PolygonBuffers> polygons;
-		PolygonID last_id;
-	} polygon_buffers;
-
-	RendererCanvasRender::PolygonID request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) override;
-	void free_polygon(PolygonID p_polygon) override;
+	void _bind_canvas_texture(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat);
+	void _prepare_canvas_texture(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, uint32_t &r_index, Size2 &r_texpixel_size);
 
 	void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used) override;
-	void _render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, bool p_to_backbuffer = false);
-	void _render_item(RID p_render_target, const Item *p_item, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, uint32_t &r_index, GLES3::CanvasShaderData::BlendMode p_blend_mode, GLES3::CanvasShaderData::BlendMode &r_last_blend_mode, Color &r_last_blend_color);
-	void _render_batch(uint32_t &p_max_index);
-	void _bind_instance_data_buffer(uint32_t p_max_index);
+	void _render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, uint32_t &r_last_index, bool p_to_backbuffer = false);
+	void _record_item_commands(const Item *p_item, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, GLES3::CanvasShaderData::BlendMode p_blend_mode, Light *p_lights, uint32_t &r_index, bool &r_break_batch);
+	void _render_batch(Light *p_lights, uint32_t p_index);
+	void _bind_material(GLES3::CanvasMaterialData *p_material_data, CanvasShaderGLES3::ShaderVariant p_variant, uint64_t p_specialization);
+	void _new_batch(bool &r_batch_broken, uint32_t &r_index);
+	void _add_to_batch(uint32_t &r_index, bool &r_batch_broken);
 	void _allocate_instance_data_buffer();
+	void _align_instance_data_buffer(uint32_t &r_index);
 
 	void set_time(double p_time);