Adapted to real vange-rs FFI

cmake/FindRustVangers.cmake

@@ -0,0 +1,28 @@
+FIND_LIBRARY(RUST_VANGERS_LIBRARY
+  NAMES
+    vangers_ffi
+  PATHS
+    ${RUST_VANGERS_ROOT}/lib
+    /usr/lib
+	/usr/local/lib
+	/opt/local/lib
+	/sw/lib
+	/local/lib
+	/mingw/lib
+	/local/bin
+	/mingw/bin
+	/usr/local/lib
+)
+IF(RUST_VANGERS_LIBRARY)
+   SET(RUST_VANGERS_FOUND TRUE)
+ENDIF(RUST_VANGERS_LIBRARY)
+
+IF(RUST_VANGERS_FOUND)
+  IF(NOT RUST_VANGERS_FIND_QUIETLY)
+    MESSAGE(STATUS "Found vange-rs ffi library: ${RUST_VANGERS_LIBRARY}")
+  ENDIF(NOT RUST_VANGERS_FIND_QUIETLY)
+ELSE(RUST_VANGERS_FOUND)
+  IF(RUST_VANGERS_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find vange-rs ffi library")
+  ENDIF(RUST_VANGERS_FIND_REQUIRED)
+ENDIF(RUST_VANGERS_FOUND)

lib/renderer/CMakeLists.txt

@@ -1,7 +1,7 @@
 FIND_PACKAGE(OpenGL REQUIRED)
 # For sdl_ext only
 FIND_PACKAGE(SDL2 REQUIRED)
-
+FIND_PACKAGE(RustVangers REQUIRED)
 
 SET(renderer_SRCS
 	src/renderer/lib/HandmadeMath.h
@@ -43,5 +43,9 @@ SET(renderer_SRCS
 ADD_LIBRARY(renderer STATIC ${renderer_SRCS})
 TARGET_LINK_LIBRARIES(
 	renderer
-	${OPENGL_LIBRARIES} ${GLUT_LIBRARY} ${SDL2_LIBRARY}
+	${OPENGL_LIBRARIES}
+	${GLUT_LIBRARY}
+	${SDL2_LIBRARY}
+	${RUST_VANGERS_LIBRARY}
+	dl
 )

lib/renderer/src/renderer/scene/rust/RustRenderer.cpp

@@ -1,30 +1,49 @@
+#include <iostream>
+
 #include "RustRenderer.h"
 #include "vange_rs.h"
 
 using namespace renderer;
 using namespace renderer::scene;
 using namespace renderer::scene::rust;
 
+RustRenderer::RustRenderer()
+	: _map_created(false)
+{
+	std::cout << "RustRenderer::RustRenderer" << std::endl;
+
+	_context = rv_init();
+}
+
+RustRenderer::~RustRenderer()
+{
+	rv_exit(_context);
+}
+
 void RustRenderer::camera_create(const CameraDescription& camera_description)
 {
-	vange_rs_camera_description v_desc {
+	std::cout << "RustRenderer::camera_create" << std::endl;
+	rv_camera_description v_desc {
 		.fov = camera_description.fov,
 		.aspect = camera_description.aspect,
 		.near= camera_description.near,
 		.far = camera_description.far,
 	};
 
-	vange_rs_camera_create(v_desc);
+	rv_camera_init(_context, v_desc);
 }
 
 void RustRenderer::camera_destroy()
 {
-	vange_rs_camera_destroy();
+	std::cout << "RustRenderer::camera_destroy" << std::endl;
+	// TODO:
+//	vange_rs_camera_destroy();
 }
 
 void RustRenderer::camera_set_transform(const Transform& transform)
 {
-	vange_rs_transform v_transform {
+	std::cout << "RustRenderer::camera_set_transform" << std::endl;
+	rv_transform v_transform {
 		.position = vange_rs_vector3 {
 			.x = transform.position.x,
 			.y = transform.position.y,
@@ -37,52 +56,65 @@ void RustRenderer::camera_set_transform(const Transform& transform)
 			.w = transform.rotation.w,
 		}
 	};
-	vange_rs_camera_set_transform(v_transform);
+	rv_camera_set_transform(_context, v_transform);
 }
 
 void RustRenderer::map_create(const MapDescription& map_description)
 {
-	vange_rs_map_description v_desc {
+	std::cout << "RustRenderer::map_create" << std::endl;
+	rv_map_description v_desc {
 		.width = map_description.width,
 		.height = map_description.height,
 		.lineT = map_description.lineT,
 		.material_begin_offsets = map_description.material_begin_offsets,
 		.material_end_offsets = map_description.material_end_offsets,
 		.material_count = map_description.material_count,
 	};
-	vange_rs_map_create(v_desc);
+	rv_map_init(_context, v_desc);
+	_map_created = true;
 }
 
 void RustRenderer::map_destroy()
 {
-	vange_rs_map_destroy();
+	std::cout << "RustRenderer::map_destroy" << std::endl;
+	if(_map_created) {
+		rv_map_exit(_context);
+	} else {
+		std::cerr << "map is already destroyed" <<std::endl;
+	}
+	_map_created = false;
 }
 
 void RustRenderer::map_request_update(const Rect& region)
 {
-	vange_rs_rect v_rect {
+	std::cout << "RustRenderer::map_request_update" << std::endl;
+	rv_rect v_rect {
 		.x = region.x,
 		.y = region.y,
 		.width = region.width,
 		.height = region.height,
 	};
 
-	vange_rs_map_request_update(v_rect);
+	rv_map_request_update(_context, v_rect);
 }
 
 void RustRenderer::map_update_palette(uint32_t* palette, int32_t palette_size)
 {
-	vange_rs_map_update_palette(palette, palette_size);
+	std::cout << "RustRenderer::map_update_palette" << std::endl;
+	// TODO:
+//	vange_rs_map_update_palette(palette, palette_size);
 }
 
 void RustRenderer::render(const Rect& viewport)
 {
-	vange_rs_rect v_rect {
+	std::cout << "RustRenderer::render" << std::endl;
+	rv_rect v_rect {
 		.x = viewport.x,
 		.y = viewport.y,
 		.width = viewport.width,
 		.height = viewport.height,
 	};
-	vange_rs_render(v_rect);
+	// TODO:
+//	vange_rs_render(v_rect);
 }
 

lib/renderer/src/renderer/scene/rust/RustRenderer.h

@@ -3,10 +3,14 @@
 
 #include "../AbstractRenderer.h"
 
+typedef void* rv_context;
+
 namespace renderer::scene::rust {
 	class RustRenderer: public AbstractRenderer
 	{
 	public:
+		RustRenderer();
+		~RustRenderer();
 		void camera_create(const CameraDescription& camera_description) override;
 		void camera_destroy() override;
 		void camera_set_transform(const Transform& transform) override;
@@ -15,6 +19,9 @@ namespace renderer::scene::rust {
 		void map_request_update(const Rect& region) override;
 		void map_update_palette(uint32_t* palette, int32_t palette_size) override;
 		void render(const Rect& viewport) override;
+	private:
+		rv_context _context;
+		bool _map_created;
 	};
 
 }

lib/renderer/src/renderer/scene/rust/vange_rs.h

@@ -8,7 +8,7 @@
 **/
 
 // TODO: agree on how we deal with structs
-struct vange_rs_camera_description {
+struct rv_camera_description {
 	float fov;
 	float aspect;
 	float near;
@@ -28,12 +28,12 @@ struct vange_rs_quaternion {
 	float w;
 };
 
-struct vange_rs_transform {
+struct rv_transform {
 	vange_rs_vector3 position;
 	vange_rs_quaternion rotation;
 };
 
-struct vange_rs_map_description {
+struct rv_map_description {
 	int32_t width; // H_SIZE
 	int32_t height; // V_SIZE
 
@@ -49,34 +49,43 @@ struct vange_rs_map_description {
 };
 
 // TODO: or it could be left, bottom, right, top
-struct vange_rs_rect {
+struct rv_rect {
 	int32_t x;
 	int32_t y;
 	int32_t width;
 	int32_t height;
 };
 
+typedef void* rv_context;
 
-// TODO: pointer?
-void vange_rs_camera_create(vange_rs_camera_description desc);
 
-void vange_rs_camera_destroy();
 
-// TODO: pointer?
-void vange_rs_camera_set_transform(vange_rs_transform transform);
+#ifdef __cplusplus
+extern "C" {
+#endif
+	rv_context rv_init();
+	void rv_exit(rv_context context);
 
-// TODO: pointer?
-void vange_rs_map_create(vange_rs_map_description map_description);
+	void rv_camera_init(rv_context context, rv_camera_description desc);
+	// TODO:
+	//void vange_rs_camera_destroy();
 
-void vange_rs_map_destroy();
+	void rv_camera_set_transform(rv_context context, rv_transform transform);
 
-void vange_rs_map_query(int32_t* width, int32_t* height);
+	void rv_map_init(rv_context context, rv_map_description map_description);
 
-// TODO: pointer?
-void vange_rs_map_request_update(vange_rs_rect region);
+	void rv_map_exit(rv_context context);
+
+	void rv_map_request_update(rv_context context, rv_rect region);
+
+	// TODO:
+	//void vange_rs_map_update_palette(uint32_t* palette, int32_t palette_size);
+
+	//void vange_rs_render(rv_rect viewport);
+
+#ifdef __cplusplus
+}
+#endif
 
-void vange_rs_map_update_palette(uint32_t* palette, int32_t palette_size);
 
-// TODO: pointer?
-void vange_rs_render(vange_rs_rect viewport);
 #endif // VANGE_RS_H

src/CMakeLists.txt

@@ -82,8 +82,9 @@ IF(WIN32)
 		#-Wl,-subsystem,windows
 	)
 ENDIF(WIN32)
-
+FIND_PACKAGE(RustVangers REQUIRED)
 TARGET_LINK_LIBRARIES(vangers
+	${RUST_VANGERS_LIBRARY}
 	${SDL2_LIBRARY}
 	${OGG_LIBRARY}
 	${VORBIS_LIBRARY}
@@ -98,4 +99,5 @@ TARGET_LINK_LIBRARIES(vangers
 	xtool
 	xgraph
 	xsound
+	dl
 )

src/road.cpp

@@ -103,6 +103,7 @@ XStream fmemory("memstats.dmp", XS_OUT);
 #endif
 
 #include <renderer/scene/sokol/SokolRenderer.h>
+#include <renderer/scene/rust/RustRenderer.h>
 
 /* ----------------------------- EXTERN SECTION ---------------------------- */
 extern XStream fout;
@@ -378,7 +379,7 @@ void showModal(char* fname, float reelW, float reelH, float screenW, float scree
 
 
 int xtInitApplication(void) {
-	renderer::scene::RenderingContext::create(std::make_unique<renderer::scene::SokolRenderer>());
+	renderer::scene::RenderingContext::create(std::make_unique<renderer::scene::rust::RustRenderer>());
 
     XGraphWndID = "VANGERS";
     char *tmp;