ECS Refactor.

examples/render-opengl/src/main.rs

@@ -41,12 +41,18 @@ fn main() -> Result<(), Box<dyn Error>> {
 	tracing::info!("Parsing puppet");
 
 	let data = fs::read(cli.inp_path)?;
-	let model = parse_inp(data.as_slice())?;
+	let mut model = parse_inp(data.as_slice())?;
 	tracing::info!(
 		"Successfully parsed puppet: {}",
 		(model.puppet.meta.name.as_deref()).unwrap_or("<no puppet name specified in file>")
 	);
 
+	tracing::info!("Setting up puppet for transforms, params and rendering.");
+	model.puppet.init_transforms();
+	model.puppet.init_rendering();
+	model.puppet.init_params();
+	model.puppet.init_physics();
+
 	tracing::info!("Setting up windowing and OpenGL");
 	let app_frame = AppFrame::init(
 		WindowBuilder::new()
@@ -81,10 +87,9 @@ impl Inox2dOpenglExampleApp {
 
 impl App for Inox2dOpenglExampleApp {
 	fn resume_window(&mut self, gl: glow::Context) {
-		match OpenglRenderer::new(gl) {
+		match OpenglRenderer::new(gl, &self.model) {
 			Ok(mut renderer) => {
 				tracing::info!("Initializing Inox2D renderer");
-				renderer.prepare(&self.model).unwrap();
 				renderer.resize(self.width, self.height);
 				renderer.camera.scale = Vec2::splat(0.15);
 				tracing::info!("Inox2D renderer initialized");
@@ -119,12 +124,18 @@ impl App for Inox2dOpenglExampleApp {
 		renderer.clear();
 
 		let puppet = &mut self.model.puppet;
-		puppet.begin_set_params();
+		puppet.begin_frame();
 		let t = scene_ctrl.current_elapsed();
-		let _ = puppet.set_named_param("Head:: Yaw-Pitch", Vec2::new(t.cos(), t.sin()));
-		puppet.end_set_params(scene_ctrl.dt());
-
-		renderer.render(puppet);
+		let _ = puppet
+			.param_ctx
+			.as_mut()
+			.unwrap()
+			.set("Head:: Yaw-Pitch", Vec2::new(t.cos(), t.sin()));
+		// Actually, not providing 0 for the first frame will not create too big a problem.
+		// Just that physics simulation will run for the provided time, which may be big and causes a startup delay.
+		puppet.end_frame(scene_ctrl.dt());
+
+		inox2d::render::draw(renderer, puppet);
 	}
 
 	fn handle_window_event(&mut self, event: WindowEvent, elwt: &EventLoopWindowTarget<()>) {

inox2d-opengl/src/gl_buffer.rs

@@ -1,7 +1,5 @@
 use glow::HasContext;
 
-use inox2d::render::RenderCtx;
-
 use super::OpenglRendererError;
 
 unsafe fn upload_array_to_gl<T>(gl: &glow::Context, array: &[T], target: u32, usage: u32) {
@@ -11,71 +9,50 @@ unsafe fn upload_array_to_gl<T>(gl: &glow::Context, array: &[T], target: u32, us
 	gl.buffer_data_u8_slice(target, bytes, usage);
 }
 
-unsafe fn reupload_array_to_gl<T>(gl: &glow::Context, array: &[T], target: u32, start_idx: usize, end_idx: usize) {
-	let slice = &array[start_idx..end_idx];
-	let bytes: &[u8] = core::slice::from_raw_parts(slice.as_ptr() as *const u8, core::mem::size_of_val(slice));
-	gl.buffer_sub_data_u8_slice(target, start_idx as i32, bytes);
-}
-
-pub trait RenderCtxOpenglExt {
-	unsafe fn setup_gl_buffers(
-		&self,
-		gl: &glow::Context,
-		vao: glow::VertexArray,
-	) -> Result<glow::VertexArray, OpenglRendererError>;
-	unsafe fn upload_deforms_to_gl(&self, gl: &glow::Context);
+/// Create a vertex array. Initialize vertex, uv, deform and index buffers, upload content and attach them to the vertex array. Return the array.
+///
+/// # Errors
+///
+/// This function will return an error if it couldn't create a vertex array.
+///
+/// # Safety
+///
+/// No prerequisites.
+pub unsafe fn setup_gl_buffers(
+	gl: &glow::Context,
+	verts: &[f32],
+	uvs: &[f32],
+	deforms: &[f32],
+	indices: &[u16],
+) -> Result<glow::VertexArray, OpenglRendererError> {
+	let vao = gl.create_vertex_array().map_err(OpenglRendererError::Opengl)?;
+	gl.bind_vertex_array(Some(vao));
+
+	upload_array_to_gl(gl, verts, glow::ARRAY_BUFFER, glow::STATIC_DRAW);
+	gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, 0, 0);
+	gl.enable_vertex_attrib_array(0);
+
+	upload_array_to_gl(gl, uvs, glow::ARRAY_BUFFER, glow::STATIC_DRAW);
+	gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, 0, 0);
+	gl.enable_vertex_attrib_array(1);
+
+	upload_array_to_gl(gl, deforms, glow::ARRAY_BUFFER, glow::DYNAMIC_DRAW);
+	gl.vertex_attrib_pointer_f32(2, 2, glow::FLOAT, false, 0, 0);
+	gl.enable_vertex_attrib_array(2);
+
+	upload_array_to_gl(gl, indices, glow::ELEMENT_ARRAY_BUFFER, glow::STATIC_DRAW);
+
+	gl.bind_vertex_array(None);
+	Ok(vao)
 }
 
-impl RenderCtxOpenglExt for RenderCtx {
-	/// Uploads the vertex and index buffers to OpenGL.
-	///
-	/// # Errors
-	///
-	/// This function will return an error if it couldn't create a vertex array.
-	///
-	/// # Safety
-	///
-	/// Only call this function once when loading a new puppet.
-	unsafe fn setup_gl_buffers(
-		&self,
-		gl: &glow::Context,
-		vao: glow::VertexArray,
-	) -> Result<glow::VertexArray, OpenglRendererError> {
-		gl.bind_vertex_array(Some(vao));
-
-		upload_array_to_gl(gl, &self.vertex_buffers.verts, glow::ARRAY_BUFFER, glow::STATIC_DRAW);
-		gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, 0, 0);
-		gl.enable_vertex_attrib_array(0);
-
-		upload_array_to_gl(gl, &self.vertex_buffers.uvs, glow::ARRAY_BUFFER, glow::STATIC_DRAW);
-		gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, 0, 0);
-		gl.enable_vertex_attrib_array(1);
-
-		upload_array_to_gl(gl, &self.vertex_buffers.deforms, glow::ARRAY_BUFFER, glow::DYNAMIC_DRAW);
-		gl.vertex_attrib_pointer_f32(2, 2, glow::FLOAT, false, 0, 0);
-		gl.enable_vertex_attrib_array(2);
-
-		upload_array_to_gl(
-			gl,
-			&self.vertex_buffers.indices,
-			glow::ELEMENT_ARRAY_BUFFER,
-			glow::STATIC_DRAW,
-		);
-
-		Ok(vao)
-	}
-
-	/// # Safety
-	///
-	/// unsafe as initiating GL calls. can be safely called for multiple times,
-	/// but only needed once after deform update and before rendering.
-	unsafe fn upload_deforms_to_gl(&self, gl: &glow::Context) {
-		reupload_array_to_gl(
-			gl,
-			&self.vertex_buffers.deforms,
-			glow::ARRAY_BUFFER,
-			0,
-			self.vertex_buffers.deforms.len(),
-		);
-	}
+/// Upload full deform buffer content.
+///
+/// # Safety
+///
+/// The vertex array object created in `setup_gl_buffers()` must be bound and no new ARRAY_BUFFER is enabled.
+pub unsafe fn upload_deforms_to_gl(gl: &glow::Context, deforms: &[f32]) {
+	// if the above preconditions are met, deform is then the currently bound ARRAY_BUFFER.
+	let bytes: &[u8] = core::slice::from_raw_parts(deforms.as_ptr() as *const u8, core::mem::size_of_val(deforms));
+	gl.buffer_sub_data_u8_slice(glow::ARRAY_BUFFER, 0, bytes);
 }