better management of drawing/display states for window

lib/Ray/sources/Camera/Camera2D.cpp

@@ -58,7 +58,7 @@ Matrix RAY::Camera::Camera2D::getMatrix(void) const
 	return GetCameraMatrix2D(this->_camera);
 }
 
-const ::Camera2D &RAY::Camera::Camera2D::getCamera(void) const
+RAY::Camera::Camera2D::operator ::Camera2D() const
 {
 	return this->_camera;
 }

lib/Ray/sources/Camera/Camera2D.hpp

@@ -53,7 +53,7 @@ namespace RAY::Camera {
 			Matrix getMatrix(void) const override;
 
 			//! @brief get camera struct
-			const ::Camera2D &getCamera(void) const;
+			operator ::Camera2D() const;
 
 		private:
 			::Camera2D _camera;

lib/Ray/sources/Camera/Camera3D.cpp

@@ -72,7 +72,7 @@ void RAY::Camera::Camera3D::setMode(Mode mode)
 	this->_mode = mode;
 }
 
-const ::Camera3D &RAY::Camera::Camera3D::getCamera(void) const
+RAY::Camera::Camera3D::operator ::Camera3D() const
 {
 	return this->_camera;
 }

lib/Ray/sources/Camera/Camera3D.hpp

@@ -63,7 +63,7 @@ namespace RAY::Camera {
 			void setMode(Mode mode);
 
 			//! @brief get camera struct
-			const ::Camera3D &getCamera(void) const;
+			operator ::Camera3D() const;
 
 		private:
 			::Camera3D _camera;

lib/Ray/sources/Window.cpp

@@ -21,7 +21,8 @@ RAY::Window::Window(int width, int height, std::string title, unsigned flags, bo
 	_dimensions(width, height),
 	_title(std::move(title)),
 	_isOpen(openNow),
-	_flags(flags)
+	_flags(flags),
+	_drawingState(IDLE), _displayState(NONE)
 {
 	if (openNow)
 		this->open();
@@ -93,34 +94,48 @@ void RAY::Window::clear(const RAY::Color &color)
 	ClearBackground(color);
 }
 
-void RAY::Window::beginDrawing(void)
+void RAY::Window::setDrawingState(enum RAY::Window::drawingState state)
 {
-	::BeginDrawing();
+	if (state == this->_drawingState)
+		return;
+	switch (state)
+	{
+	case DRAWING:
+		BeginDrawing();
+		break;
+	case IDLE:
+		EndDrawing();
+		break;
+	}
+	this->_drawingState = state;
 }
 
-void RAY::Window::endDrawing(void)
+void RAY::Window::useCamera(RAY::Camera::Camera2D &camera)
 {
-	::EndDrawing();
+	this->_displayState = RAY::Window::TWO_DIMENSIONNAL;
+	BeginMode2D(camera);
 }
 
-void RAY::Window::beginMode2D(Camera::Camera2D &camera)
+void RAY::Window::useCamera(RAY::Camera::Camera3D &camera)
 {
-	BeginMode2D(camera.getCamera());
+	this->_displayState = RAY::Window::THREE_DIMENSIONNAL;
+	BeginMode3D(camera);
 }
 
-void RAY::Window::beginMode3D(Camera::Camera3D &camera)
+void RAY::Window::unuseCamera(void)
 {
-	BeginMode3D(camera.getCamera());
+	switch (this->_displayState)
-}
+	{
-
+	case THREE_DIMENSIONNAL:
-void RAY::Window::endMode2D(void)
+		EndMode3D();
-{
+		break;
-	EndMode2D();
+	case TWO_DIMENSIONNAL:
-}
+		EndMode2D();
-
+		break;
-void RAY::Window::endMode3D(void)
+	default:
-{
+		break;
-	EndMode3D();
+	}
+	this->_displayState = NONE;
 }
 
 void RAY::Window::setTitle(const std::string &title)

lib/Ray/sources/Window.hpp

@@ -74,25 +74,35 @@ namespace RAY {
 			//! @param color The color to clear the screen (default: black)
 			void clear(const Color &color = BLACK);
 
-			//! @brief Setup canvas (framebuffer) to start drawing
+			//! @brief Different states of the draw-ability of the window
-			//! @brief Must be called before first draw of iteration
+			enum drawingState {
-			void beginDrawing(void);
+				//! @brief Must be called after last draw of iteration
+				IDLE,
+				//! @brief Must be called before first draw of iteration
+				DRAWING,
+			};
 
-			//! @brief End canvas drawing and swap buffers (double buffering)
+			//! @brief Different states of the view of the window
-			//! @info Must be called after last draw of iteration
+			enum displayState {
-			void endDrawing(void);
+				//! @brief When a custom 2D camera is used
+				TWO_DIMENSIONNAL,
+				//! @brief When a custom 3D camera is used
+				THREE_DIMENSIONNAL,
+				//! @brief When no camera is used
+				NONE,
+			};
+
+			//! @brief Set drawing state of the window
+			void setDrawingState(enum drawingState);
 
 			//! @brief Initialize 2D mode with custom camera (2D)
-			void beginMode2D(Camera::Camera2D &camera);
+			void useCamera(Camera::Camera2D &camera);
 
 			//! @brief Initialize 3D mode with custom camera (2D)
-			void beginMode3D(Camera::Camera3D &camera);
+			void useCamera(Camera::Camera3D &camera);
 
-			//! @brief Ends 2D mode with custom camera
+			//! @brief Ends current view mode and returns to default mode
-			void endMode2D(void);
+			void unuseCamera(void);
-
-			//! @brief Ends 3D mode and returns to default 2D orthographic mode
-			void endMode3D(void);
 
 			//! @brief Set the window title
 			void setTitle(const std::string &title);
@@ -111,9 +121,11 @@ namespace RAY {
 			//! @brief Draw a 3d mesh with material and transform
 			void draw(const Mesh &mesh, const Material &material, const Matrix &transform);
 
+
 		private:
 			//! @brief Creates window, and opens it if openNow is set to true
 			Window(int width, int height, std::string title, unsigned flags = 0, bool openNow = true);
+			
 			//! @brief Dimension of window
 			RAY::Vector2 _dimensions;
 
@@ -125,6 +137,12 @@ namespace RAY {
 
 			//! @brief flags for the window (ex: FLAG_WINDOW_RESIZABLE)
 			unsigned int _flags;
+
+			//! @brief Current window draw-state
+			enum drawingState _drawingState;
+
+			//! @brief Current window draw-state
+			enum displayState _displayState;
 	};
 }
 

sources/main.cpp

@@ -60,11 +60,11 @@ int main()
 
 		// Draw
 		//----------------------------------------------------------------------------------
-		window.beginDrawing();
+		window.setDrawingState(RAY::Window::DRAWING);
 
 		window.clear(RAYWHITE);
 
-		window.beginMode3D(camera);
+		window.useCamera(camera);
 
 		window.draw(grid);
 
@@ -97,9 +97,9 @@ int main()
 			}
 		}
 
-		window.endMode3D();
+		window.unuseCamera();
 
-		window.endDrawing();
+		window.setDrawingState(RAY::Window::IDLE);
 		//----------------------------------------------------------------------------------
 	}