Updated CSFML and SFML.Net in the sfml2 branch

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1233 4e206d99-4929-0410-ac5d-dfc041789085

CSFML/build/VC2008/csfml-graphics-d.def

@@ -171,6 +171,7 @@ EXPORTS
 	sfRenderImage_GetWidth
 	sfRenderImage_GetHeight
 	sfRenderImage_SetActive
+	sfRenderImage_Flush
 	sfRenderImage_DrawPostFX
 	sfRenderImage_DrawSprite
 	sfRenderImage_DrawShape
@@ -200,6 +201,7 @@ EXPORTS
 	sfRenderWindow_EnableKeyRepeat
 	sfRenderWindow_SetIcon
 	sfRenderWindow_SetActive
+	sfRenderWindow_Flush
 	sfRenderWindow_Display
 	sfRenderWindow_GetInput
 	sfRenderWindow_SetFramerateLimit
@@ -209,7 +211,6 @@ EXPORTS
 	sfRenderWindow_DrawSprite
 	sfRenderWindow_DrawString
 	sfRenderWindow_DrawShape
-	sfRenderWindow_Capture
 	sfRenderWindow_Clear
 	sfRenderWindow_SetView
 	sfRenderWindow_GetView

CSFML/build/VC2008/csfml-graphics.def

@@ -171,6 +171,7 @@ EXPORTS
 	sfRenderImage_GetWidth
 	sfRenderImage_GetHeight
 	sfRenderImage_SetActive
+	sfRenderImage_Flush
 	sfRenderImage_DrawPostFX
 	sfRenderImage_DrawSprite
 	sfRenderImage_DrawShape
@@ -201,6 +202,7 @@ EXPORTS
 	sfRenderWindow_EnableKeyRepeat
 	sfRenderWindow_SetIcon
 	sfRenderWindow_SetActive
+	sfRenderWindow_Flush
 	sfRenderWindow_Display
 	sfRenderWindow_GetInput
 	sfRenderWindow_SetFramerateLimit
@@ -210,7 +212,6 @@ EXPORTS
 	sfRenderWindow_DrawSprite
 	sfRenderWindow_DrawString
 	sfRenderWindow_DrawShape
-	sfRenderWindow_Capture
 	sfRenderWindow_Clear
 	sfRenderWindow_SetView
 	sfRenderWindow_GetView

CSFML/include/SFML/Graphics/RenderImage.h

@@ -83,6 +83,24 @@ CSFML_API unsigned int sfRenderImage_GetHeight(sfRenderImage* renderImage);
 ////////////////////////////////////////////////////////////
 CSFML_API sfBool sfRenderImage_SetActive(sfRenderImage* renderImage, sfBool active);
 
+////////////////////////////////////////////////////////////
+/// Make sure that what has been drawn so far is rendered
+///
+/// Use this function if you use OpenGL rendering commands,
+/// and you want to make sure that things will appear on top
+/// of all the SFML objects that have been drawn so far.
+/// This is needed because SFML doesn't use immediate rendering,
+/// it first accumulates drawables into a queue and
+/// trigger the actual rendering afterwards.
+///
+/// You don't need to call this function if you're not
+/// dealing with OpenGL directly.
+///
+/// \param Renderimage : Renderwindow object
+///
+////////////////////////////////////////////////////////////
+CSFML_API void sfRenderImage_Flush(sfRenderImage* renderImage);
+
 ////////////////////////////////////////////////////////////
 /// Draw something on a renderimage
 ///

CSFML/include/SFML/Graphics/RenderWindow.h

@@ -213,6 +213,24 @@ CSFML_API void sfRenderWindow_SetIcon(sfRenderWindow* renderWindow, unsigned int
 ////////////////////////////////////////////////////////////
 CSFML_API sfBool sfRenderWindow_SetActive(sfRenderWindow* renderWindow, sfBool active);
 
+////////////////////////////////////////////////////////////
+/// Make sure that what has been drawn so far is rendered
+///
+/// Use this function if you use OpenGL rendering commands,
+/// and you want to make sure that things will appear on top
+/// of all the SFML objects that have been drawn so far.
+/// This is needed because SFML doesn't use immediate rendering,
+/// it first accumulates drawables into a queue and
+/// trigger the actual rendering afterwards.
+///
+/// You don't need to call this function if you're not
+/// dealing with OpenGL directly.
+///
+/// \param renderWindow : Renderwindow object
+///
+////////////////////////////////////////////////////////////
+CSFML_API void sfRenderWindow_Flush(sfRenderWindow* renderWindow);
+
 ////////////////////////////////////////////////////////////
 /// Display a window on screen
 ///
@@ -272,16 +290,6 @@ CSFML_API void sfRenderWindow_DrawSprite(sfRenderWindow* renderWindow, sfSprite*
 CSFML_API void sfRenderWindow_DrawShape (sfRenderWindow* renderWindow, sfShape*  shape);
 CSFML_API void sfRenderWindow_DrawString(sfRenderWindow* renderWindow, sfString* string);
 
-////////////////////////////////////////////////////////////
-/// Save the content of a renderwindow to an image
-///
-/// \param renderWindow : Renderwindow to capture
-///
-/// \return Image instance containing the contents of the screen
-///
-////////////////////////////////////////////////////////////
-CSFML_API sfImage* sfRenderWindow_Capture(sfRenderWindow* renderWindow);
-
 ////////////////////////////////////////////////////////////
 /// Clear the screen with the given color
 ///

CSFML/src/SFML/Graphics/RenderImage.cpp

@@ -87,6 +87,28 @@ sfBool sfRenderImage_SetActive(sfRenderImage* renderImage, sfBool active)
 }
 
 
+////////////////////////////////////////////////////////////
+/// Make sure that what has been drawn so far is rendered
+///
+/// Use this function if you use OpenGL rendering commands,
+/// and you want to make sure that things will appear on top
+/// of all the SFML objects that have been drawn so far.
+/// This is needed because SFML doesn't use immediate rendering,
+/// it first accumulates drawables into a queue and
+/// trigger the actual rendering afterwards.
+///
+/// You don't need to call this function if you're not
+/// dealing with OpenGL directly.
+///
+/// \param Renderimage : Renderwindow object
+///
+////////////////////////////////////////////////////////////
+void sfRenderImage_Flush(sfRenderImage* renderImage)
+{
+    CSFML_CALL(renderImage, Flush())
+}
+
+
 ////////////////////////////////////////////////////////////
 /// Draw something on a renderimage
 ////////////////////////////////////////////////////////////

CSFML/src/SFML/Graphics/RenderWindow.cpp

@@ -292,6 +292,26 @@ sfBool sfRenderWindow_SetActive(sfRenderWindow* renderWindow, sfBool active)
 }
 
 
+////////////////////////////////////////////////////////////
+/// Make sure that what has been drawn so far is rendered
+///
+/// Use this function if you use OpenGL rendering commands,
+/// and you want to make sure that things will appear on top
+/// of all the SFML objects that have been drawn so far.
+/// This is needed because SFML doesn't use immediate rendering,
+/// it first accumulates drawables into a queue and
+/// trigger the actual rendering afterwards.
+///
+/// You don't need to call this function if you're not
+/// dealing with OpenGL directly.
+///
+////////////////////////////////////////////////////////////
+void sfRenderWindow_Flush(sfRenderWindow* renderWindow)
+{
+    CSFML_CALL(renderWindow, Flush())
+}
+
+
 ////////////////////////////////////////////////////////////
 /// Display a window on screen
 ////////////////////////////////////////////////////////////
@@ -365,19 +385,6 @@ void sfRenderWindow_DrawString(sfRenderWindow* renderWindow, sfString* string)
 }
 
 
-////////////////////////////////////////////////////////////
-/// Save the content of a renderwindow to an image
-////////////////////////////////////////////////////////////
-sfImage* sfRenderWindow_Capture(sfRenderWindow* renderWindow)
-{
-    CSFML_CHECK_RETURN(renderWindow, NULL);
-
-    sfImage* image = new sfImage;
-    *image->This = renderWindow->This.Capture();
-
-    return image;
-}
-
 ////////////////////////////////////////////////////////////
 /// Clear the screen with the given color
 ////////////////////////////////////////////////////////////

dotnet/samples/opengl/OpenGL.cs

@@ -16,6 +16,9 @@ namespace sample_opengl
             // Create main window
             RenderWindow window = new RenderWindow(new VideoMode(800, 600), "SFML.Net OpenGL");
 
+            // Activate it as the target for OpenGL calls
+            window.SetActive();
+
             // Setup event handlers
             window.Closed     += new EventHandler(OnClosed);
             window.KeyPressed += new EventHandler<KeyEventArgs>(OnKeyPressed);
@@ -72,6 +75,13 @@ namespace sample_opengl
                 // Draw background
                 window.Draw(background);
 
+                // Flush the window, to make sure that our OpenGL cube
+                // will be rendered on top of the background sprite
+                window.Flush();
+
+                // Activate the window for OpenGL calls
+                window.SetActive();
+
                 // Clear depth buffer
                 Gl.glClear(Gl.GL_DEPTH_BUFFER_BIT);
 
@@ -159,6 +169,8 @@ namespace sample_opengl
         /// </summary>
         static void OnResized(object sender, SizeEventArgs e)
         {
+            RenderWindow window = (RenderWindow)sender;
+            window.SetActive();
             Gl.glViewport(0, 0, (int)e.Width, (int)e.Height);
         }
     }

dotnet/samples/window/Window.cs

@@ -15,6 +15,9 @@ namespace sample_window
             // Create the main window
             Window window = new Window(new VideoMode(640, 480, 32), "SFML.Net Window");
 
+            // Activate it as the target for OpenGL calls
+            window.SetActive();
+
             // Setup event handlers
             window.Closed     += new EventHandler(OnClosed);
             window.KeyPressed += new EventHandler<KeyEventArgs>(OnKeyPressed);
@@ -42,8 +45,6 @@ namespace sample_window
                 window.DispatchEvents();
 
                 // Set the active window before using OpenGL commands
-                // It's useless here because the active window is always the same,
-                // but don't forget it if you use multiple windows
                 window.SetActive();
 
                 // Clear color and depth buffer
@@ -128,6 +129,8 @@ namespace sample_window
         /// </summary>
         static void OnResized(object sender, SizeEventArgs e)
         {
+            Window window = (Window)sender;
+            window.SetActive();
             Gl.glViewport(0, 0, (int)e.Width, (int)e.Height);
         }
     }

dotnet/src/Graphics/RenderImage.cs

@@ -191,6 +191,26 @@ namespace SFML
                 sfRenderImage_DrawPostFX(This, postFx != null ? postFx.This : IntPtr.Zero);
             }
 
+            ////////////////////////////////////////////////////////////
+            /// <summary>
+            /// Make sure that what has been drawn so far is rendered.
+            ///
+            /// Use this function if you use OpenGL rendering commands,
+            /// and you want to make sure that things will appear on top
+            /// of all the SFML objects that have been drawn so far.
+            /// This is needed because SFML doesn't use immediate rendering,
+            /// it first accumulates drawables into a queue and
+            /// trigger the actual rendering afterwards.
+            ///
+            /// You don't need to call this function if you're not
+            /// dealing with OpenGL directly.
+            /// </summary>
+            ////////////////////////////////////////////////////////////
+            public void Flush()
+            {
+                sfRenderImage_Flush(This);
+            }
+
             ////////////////////////////////////////////////////////////
             /// <summary>
             /// Target image of the render image
@@ -257,6 +277,9 @@ namespace SFML
             [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
             static extern bool sfRenderImage_SetActive(IntPtr This, bool Active);
 
+            [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
+            static extern bool sfRenderImage_Flush(IntPtr This);
+
             [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
             static extern void sfRenderImage_SetView(IntPtr This, IntPtr View);
 

dotnet/src/Graphics/RenderTarget.cs

@@ -59,7 +59,6 @@ namespace SFML
             /// <param name="x">X coordinate of the point to convert, relative to the target</param>
             /// <param name="y">Y coordinate of the point to convert, relative to the target</param>
             /// <returns>Converted point</returns>
-            ///
             ////////////////////////////////////////////////////////////
             Vector2 ConvertCoords(uint x, uint y);
 
@@ -72,7 +71,6 @@ namespace SFML
             /// <param name="y">Y coordinate of the point to convert, relative to the target</param>
             /// <param name="view">Target view to convert the point to</param>
             /// <returns>Converted point</returns>
-            ///
             ////////////////////////////////////////////////////////////
             Vector2 ConvertCoords(uint x, uint y, View view);
 
@@ -106,6 +104,23 @@ namespace SFML
             /// <param name="postFx">PostFx to apply</param>
             ////////////////////////////////////////////////////////////
             void Draw(PostFx postFx);
+
+            ////////////////////////////////////////////////////////////
+            /// <summary>
+            /// Make sure that what has been drawn so far is rendered.
+            ///
+            /// Use this function if you use OpenGL rendering commands,
+            /// and you want to make sure that things will appear on top
+            /// of all the SFML objects that have been drawn so far.
+            /// This is needed because SFML doesn't use immediate rendering,
+            /// it first accumulates drawables into a queue and
+            /// trigger the actual rendering afterwards.
+            ///
+            /// You don't need to call this function if you're not
+            /// dealing with OpenGL directly.
+            /// </summary>
+            ////////////////////////////////////////////////////////////
+            void Flush();
         }
     }
 }

dotnet/src/Graphics/RenderWindow.cs

@@ -382,17 +382,6 @@ namespace SFML
                 sfRenderWindow_Clear(This, color);
             }
 
-            ////////////////////////////////////////////////////////////
-            /// <summary>
-            /// Save the content of the window to an image
-            /// </summary>
-            /// <returns>Image instance containing the contents of the screen</returns>
-            ////////////////////////////////////////////////////////////
-            public Image Capture()
-            {
-                return new Image(sfRenderWindow_Capture(This));
-            }
-
             ////////////////////////////////////////////////////////////
             /// <summary>
             /// Draw something into the window
@@ -415,6 +404,26 @@ namespace SFML
                 sfRenderWindow_DrawPostFX(This, postFx != null ? postFx.This : IntPtr.Zero);
             }
 
+            ////////////////////////////////////////////////////////////
+            /// <summary>
+            /// Make sure that what has been drawn so far is rendered.
+            ///
+            /// Use this function if you use OpenGL rendering commands,
+            /// and you want to make sure that things will appear on top
+            /// of all the SFML objects that have been drawn so far.
+            /// This is needed because SFML doesn't use immediate rendering,
+            /// it first accumulates drawables into a queue and
+            /// trigger the actual rendering afterwards.
+            ///
+            /// You don't need to call this function if you're not
+            /// dealing with OpenGL directly.
+            /// </summary>
+            ////////////////////////////////////////////////////////////
+            public void Flush()
+            {
+                sfRenderWindow_Flush(This);
+            }
+
             ////////////////////////////////////////////////////////////
             /// <summary>
             /// Internal function to get the next event
@@ -524,6 +533,9 @@ namespace SFML
             [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
             static extern bool sfRenderWindow_SetActive(IntPtr This, bool Active);
 
+            [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
+            static extern bool sfRenderWindow_Flush(IntPtr This);
+
             [DllImport("csfml-graphics"), SuppressUnmanagedCodeSecurity]
             static extern void sfRenderWindow_SetFramerateLimit(IntPtr This, uint Limit);
 

dotnet/src/Window/VideoMode.cs

@@ -57,7 +57,7 @@ namespace SFML
             ////////////////////////////////////////////////////////////
             /// <summary>
             /// Get the number of valid video modes
-            /// <summary>
+            /// </summary>
             ////////////////////////////////////////////////////////////
             public static uint ModesCount
             {
@@ -81,7 +81,7 @@ namespace SFML
             ////////////////////////////////////////////////////////////
             /// <summary>
             /// Get the current desktop video mode
-            /// <summary>
+            /// </summary>
             ////////////////////////////////////////////////////////////
             public static VideoMode DesktopMode
             {