* Enum definition for Placement enum 4.x-dev

Sun, 01 Aug 2021 10:00:12 +0300

author
cemkalyoncu
date
Sun, 01 Aug 2021 10:00:12 +0300
branch
4.x-dev
changeset 1726
4915f53e1995
parent 1725
ebbf2e5bfb34
child 1727
20deab12df40

* Enum definition for Placement enum

Source/Gorgon/Graphics.h file | annotate | diff | comparison | revisions
--- a/Source/Gorgon/Graphics.h	Wed Jul 21 10:39:37 2021 +0300
+++ b/Source/Gorgon/Graphics.h	Sun Aug 01 10:00:12 2021 +0300
@@ -17,63 +17,63 @@
 namespace Gorgon {
 
 
-	/// Contains generic 2D graphics related data structures and functions. These functions are tied to
-	/// underlying GL system through textures.
-	namespace Graphics {
+    /// Contains generic 2D graphics related data structures and functions. These functions are tied to
+    /// underlying GL system through textures.
+    namespace Graphics {
 
-		/// Initializes Graphics module, should be performed after an OpenGL context is
-		/// created. There is a mechanism to ensure initialization is performed once.
-		void Initialize();
+        /// Initializes Graphics module, should be performed after an OpenGL context is
+        /// created. There is a mechanism to ensure initialization is performed once.
+        void Initialize();
 
-		/// Details which directions a texture should tile. If its not tiled for that direction, it will
-		/// be stretched. If the target size is smaller, tiling causes partial draw instead of shrinking.
-		/// @todo Should be fitted to String::Enum
-		enum class Tiling {
-			None		= 0,
-			Horizontal	= 1,
-			Vertical	= 2,
-			Both		= 3,
-		};
+        /// Details which directions a texture should tile. If its not tiled for that direction, it will
+        /// be stretched. If the target size is smaller, tiling causes partial draw instead of shrinking.
+        /// @todo Should be fitted to String::Enum
+        enum class Tiling {
+            None		= 0,
+            Horizontal	= 1,
+            Vertical	= 2,
+            Both		= 3,
+        };
 
-		/// 2D orientation constants
-		enum class Orientation {
-			Horizontal = 1,
-			Vertical   = 2
-		};
+        /// 2D orientation constants
+        enum class Orientation {
+            Horizontal = 1,
+            Vertical   = 2
+        };
 
-		/// Creates a Tiling class from the given horizontal, vertical tiling info.
-		inline Tiling Tile(bool horizontal, bool vertical) {
-			return (horizontal ?
-				(vertical ? Tiling::Both     : Tiling::Horizontal) :
-				(vertical ? Tiling::Vertical : Tiling::None)
-			);
-		}
+        /// Creates a Tiling class from the given horizontal, vertical tiling info.
+        inline Tiling Tile(bool horizontal, bool vertical) {
+            return (horizontal ?
+                (vertical ? Tiling::Both     : Tiling::Horizontal) :
+                (vertical ? Tiling::Vertical : Tiling::None)
+            );
+        }
 
-		/// Defines how an object is aligned
-		enum class Alignment {
-			/// Placed at the start of the axis
-			Start		= 1,
+        /// Defines how an object is aligned
+        enum class Alignment {
+            /// Placed at the start of the axis
+            Start		= 1,
 
-			/// Centered along the axis
-			Center		= 4,
+            /// Centered along the axis
+            Center		= 4,
 
-			/// Placed at the end of the axis
-			End			= 2,
-		};
+            /// Placed at the end of the axis
+            End			= 2,
+        };
 
 
-		/// Defines how a text is aligned. Justification should be used as an independent
-		/// flag as a text could both be justified and centered (for partial lines).
-		enum class TextAlignment {
-			/// Text is aligned to left
-			Left		= 8,
+        /// Defines how a text is aligned. Justification should be used as an independent
+        /// flag as a text could both be justified and centered (for partial lines).
+        enum class TextAlignment {
+            /// Text is aligned to left
+            Left		= 8,
 
-			/// Text is aligned to center
-			Center		= 32,
+            /// Text is aligned to center
+            Center		= 32,
 
-			/// Text is aligned to right
-			Right		= 16,
-		};
+            /// Text is aligned to right
+            Right		= 16,
+        };
 
         DefineEnumStrings(TextAlignment, {
             {TextAlignment::Left,   "Left"},
@@ -81,769 +81,452 @@
             {TextAlignment::Right, "Right"},
         });
 
-		/// Defines how an object is placed in a 2D axis system
-		enum class Placement {
-			/// Placed at top left
-			TopLeft			=  9,
+        /// Defines how an object is placed in a 2D axis system
+        enum class Placement {
+            /// Placed at top left
+            TopLeft			=  9,
+
+            /// Placed at top center
+            TopCenter		= 33,
 
-			/// Placed at top center
-			TopCenter		= 33,
+            /// Placed at top right
+            TopRight		= 17,
+
 
-			/// Placed at top right
-			TopRight		= 17,
+            /// Placed at middle left
+            MiddleLeft		= 12,
+
+            /// Placed at the center
+            MiddleCenter	= 36,
+
+            /// Placed at middle right
+            MiddleRight		= 20,
 
 
-			/// Placed at middle left
-			MiddleLeft		= 12,
-
-			/// Placed at the center
-			MiddleCenter	= 36,
+            /// Placed at bottom
+            BottomLeft		= 10,
 
-			/// Placed at middle right
-			MiddleRight		= 20,
+            /// Placed at bottom center
+            BottomCenter	= 34,
 
-							  
-			/// Placed at bottom
-			BottomLeft		= 10,
+            /// Placed at bottom right
+            BottomRight		= 18,
+        };
 
-			/// Placed at bottom center
-			BottomCenter	= 34,
-
-			/// Placed at bottom right
-			BottomRight		= 18,
-		};
+        DefineEnumStrings(Placement, {
+            {Placement::TopLeft,        "Top left"},
+            {Placement::TopCenter,      "Top center"},
+            {Placement::TopRight,       "Top right"},
+            {Placement::MiddleLeft,     "Middle left"},
+            {Placement::MiddleCenter,   "Middle center"},
+            {Placement::MiddleRight,    "Middle right"},
+            {Placement::BottomLeft,     "Bottom left"},
+            {Placement::BottomCenter,   "Bottom center"},
+            {Placement::BottomRight,    "Bottom right"},
+        });
 
-		/// Returns horizontal alignment from a placement
-		inline Alignment GetHorizontal(Placement placement) {
-			return Alignment(((int)placement & 56)>>3);
-		}
+        /// Returns horizontal alignment from a placement
+        inline Alignment GetHorizontal(Placement placement) {
+            return Alignment(((int)placement & 56)>>3);
+        }
 
-		/// Returns vertical alignment from a placement
-		inline Alignment GetVertical(Placement placement) {
-			return Alignment((int)placement & 7);
-		}
+        /// Returns vertical alignment from a placement
+        inline Alignment GetVertical(Placement placement) {
+            return Alignment((int)placement & 7);
+        }
 
-		/// Returns the offset of the object according to the given placement rule when there is the given 
-		/// remainder between object size and the area its being drawn on. Typical usage:
-		/// `CalculateOffset(Placement::MiddleCenter, areasize - objectsize)`
-		inline Geometry::Point CalculateOffset(Placement place, Geometry::Size remainder) {
-			switch(GetHorizontal(place)) {
-			case Alignment::Start:
-				remainder.Width=0;
-				break;
-			case Alignment::Center:
-				remainder.Width/=2;
-				break;
-			case Alignment::End:
-				break;
+        /// Returns the offset of the object according to the given placement rule when there is the given
+        /// remainder between object size and the area its being drawn on. Typical usage:
+        /// `CalculateOffset(Placement::MiddleCenter, areasize - objectsize)`
+        inline Geometry::Point CalculateOffset(Placement place, Geometry::Size remainder) {
+            switch(GetHorizontal(place)) {
+            case Alignment::Start:
+                remainder.Width=0;
+                break;
+            case Alignment::Center:
+                remainder.Width/=2;
+                break;
+            case Alignment::End:
+                break;
 #ifndef NDEBUG
-			default:
-				throw std::runtime_error("Unknown mode");
-				break;
+            default:
+                throw std::runtime_error("Unknown mode");
+                break;
 #endif
-			}
+            }
 
-			switch(GetVertical(place)) {
-			case Alignment::Start:
-				remainder.Height=0;
-				break;
-			case Alignment::Center:
-				remainder.Height/=2;
-				break;
-			case Alignment::End:
-				break;
+            switch(GetVertical(place)) {
+            case Alignment::Start:
+                remainder.Height=0;
+                break;
+            case Alignment::Center:
+                remainder.Height/=2;
+                break;
+            case Alignment::End:
+                break;
 #ifndef NDEBUG
-			default:
-				throw std::runtime_error("Unknown mode");
-				break;
+            default:
+                throw std::runtime_error("Unknown mode");
+                break;
 #endif
-			}
+            }
 
-			return (Geometry::Point)remainder;
-		}
+            return (Geometry::Point)remainder;
+        }
 
 
-		/// This class allows control over a sizable object
-		class SizeController {
-		public:
-			/// Controls how a direction is tiled
-			enum Tiling {
-				/// The drawing is drawn only once with its original size. The placement of this single
-				/// drawing will be determined by the alignment.
-				Single				= 0,
+        /// This class allows control over a sizable object
+        class SizeController {
+        public:
+            /// Controls how a direction is tiled
+            enum Tiling {
+                /// The drawing is drawn only once with its original size. The placement of this single
+                /// drawing will be determined by the alignment.
+                Single				= 0,
 
-				/// The drawing is stretched along this axis to cover the given size. If the given drawing
-				/// object is truly scalable, this value acts same as Tile.
-				Stretch				= 2,
+                /// The drawing is stretched along this axis to cover the given size. If the given drawing
+                /// object is truly scalable, this value acts same as Tile.
+                Stretch				= 2,
 
-				/// The drawing is tiled along this axis to cover the given size. If the area is smaller,
-				/// drawing will be cut from the given size. If the area is larger, drawing will be repeated
-				/// as necessary. While repeating, it is possible for drawing not to cover the area exactly,
-				/// In this case, alignment determines which side will be incomplete. If center alignment
-				/// is selected, both sides will have same amount of incomplete drawing.
-				Tile				= 1,
+                /// The drawing is tiled along this axis to cover the given size. If the area is smaller,
+                /// drawing will be cut from the given size. If the area is larger, drawing will be repeated
+                /// as necessary. While repeating, it is possible for drawing not to cover the area exactly,
+                /// In this case, alignment determines which side will be incomplete. If center alignment
+                /// is selected, both sides will have same amount of incomplete drawing.
+                Tile				= 1,
 
-				/// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will 
-				/// never placed incomplete. Instead, it will be repeated to cover as much area as possible without
-				/// exceeding the given size. Any area that is left will be distributed to the edges according to 
-				/// the selected alignment.
-				Integral_Smaller	= 13,
+                /// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will
+                /// never placed incomplete. Instead, it will be repeated to cover as much area as possible without
+                /// exceeding the given size. Any area that is left will be distributed to the edges according to
+                /// the selected alignment.
+                Integral_Smaller	= 13,
 
-				/// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will 
-				/// never placed incomplete. Instead, it will be repeated to cover entire area. Excess drawing
-				/// will be aligned depending on the selected alignment.
-				Integral_Fill		= 21,
+                /// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will
+                /// never placed incomplete. Instead, it will be repeated to cover entire area. Excess drawing
+                /// will be aligned depending on the selected alignment.
+                Integral_Fill		= 21,
 
-				/// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will 
-				/// never placed incomplete. Instead, it will be repeated to cover entire area. If the last drawing
-				/// that will be partial is more than 50% of the size of the original drawing, it will be drawn. Excess
-				/// drawing or the area left empty is distributed according to the selected alignment.
-				Integral_Best		= 45,
-			};
+                /// The drawing is tiled along this axis to cover the given size. In this mode, the drawing will
+                /// never placed incomplete. Instead, it will be repeated to cover entire area. If the last drawing
+                /// that will be partial is more than 50% of the size of the original drawing, it will be drawn. Excess
+                /// drawing or the area left empty is distributed according to the selected alignment.
+                Integral_Best		= 45,
+            };
 
-			/// Creates a default size controller which tiles the object from top-left
-			SizeController() : Horizontal(Tile), Vertical(Tile), Place(Placement::TopLeft) { }
+            /// Creates a default size controller which tiles the object from top-left
+            SizeController() : Horizontal(Tile), Vertical(Tile), Place(Placement::TopLeft) { }
 
-			/// Creates a size controller that places a single object to the given placement. This is an implicit conversion
-			/// constructor.
-			SizeController(Placement p) : Horizontal(Single), Vertical(Single), Place(p) { }
+            /// Creates a size controller that places a single object to the given placement. This is an implicit conversion
+            /// constructor.
+            SizeController(Placement p) : Horizontal(Single), Vertical(Single), Place(p) { }
 
-			/// Creates a new size controller with the given tiling options and placement
-			SizeController(Tiling h, Tiling v, Placement p=Placement::TopLeft) : Horizontal(h), Vertical(v), Place(p) { }
+            /// Creates a new size controller with the given tiling options and placement
+            SizeController(Tiling h, Tiling v, Placement p=Placement::TopLeft) : Horizontal(h), Vertical(v), Place(p) { }
 
-			/// Creates a new size controller with the given tiling options and placement
-			SizeController(Graphics::Tiling tile, Placement p=Placement::TopLeft) :
-				Horizontal(int(tile)&int(Graphics::Tiling::Horizontal) ? Tile : Stretch),
-				Vertical  (int(tile)&int(Graphics::Tiling::Vertical)   ? Tile : Stretch),
-				Place(p)
-			{ }
+            /// Creates a new size controller with the given tiling options and placement
+            SizeController(Graphics::Tiling tile, Placement p=Placement::TopLeft) :
+                Horizontal(int(tile)&int(Graphics::Tiling::Horizontal) ? Tile : Stretch),
+                Vertical  (int(tile)&int(Graphics::Tiling::Vertical)   ? Tile : Stretch),
+                Place(p)
+            { }
 
-			/// Calculates the size of the object according to the tiling rules
-			Geometry::Size CalculateSize(Geometry::Size objectsize, const Geometry::Size &area) const {
-				switch(Horizontal) {
-				case Integral_Smaller:
-					objectsize.Width=(area.Width/objectsize.Width)*objectsize.Width;
-					break;
-				case Integral_Fill:
-					objectsize.Width=int(std::ceil(float(area.Width)/objectsize.Width))*objectsize.Width;
-					break;
-				case Integral_Best:
-					objectsize.Width=int(std::round(float(area.Width)/objectsize.Width))*objectsize.Width;
-					break;
-				case Stretch:
-				case Tile:
-					objectsize.Width=area.Width;
-					break;
-				case Single:
-					break;
+            /// Calculates the size of the object according to the tiling rules
+            Geometry::Size CalculateSize(Geometry::Size objectsize, const Geometry::Size &area) const {
+                switch(Horizontal) {
+                case Integral_Smaller:
+                    objectsize.Width=(area.Width/objectsize.Width)*objectsize.Width;
+                    break;
+                case Integral_Fill:
+                    objectsize.Width=int(std::ceil(float(area.Width)/objectsize.Width))*objectsize.Width;
+                    break;
+                case Integral_Best:
+                    objectsize.Width=int(std::round(float(area.Width)/objectsize.Width))*objectsize.Width;
+                    break;
+                case Stretch:
+                case Tile:
+                    objectsize.Width=area.Width;
+                    break;
+                case Single:
+                    break;
 #ifndef NDEBUG
-				default:
-					throw std::runtime_error("Unknown mode");
-					break;
+                default:
+                    throw std::runtime_error("Unknown mode");
+                    break;
 #endif
-				}
+                }
 
-				switch(Vertical) {
-				case Integral_Smaller:
-					objectsize.Width=(area.Width/objectsize.Width)*objectsize.Width;
-					break;
-				case Integral_Fill:
-					objectsize.Width=int(std::ceil(float(area.Width)/objectsize.Width))*objectsize.Width;
-					break;
-				case Integral_Best:
-					objectsize.Width=int(std::round(float(area.Width)/objectsize.Width))*objectsize.Width;
-					break;
-				case Stretch:
-				case Tile:
-					objectsize.Height=area.Height;
-					break;
-				case Single:
-					break;
+                switch(Vertical) {
+                case Integral_Smaller:
+                    objectsize.Width=(area.Width/objectsize.Width)*objectsize.Width;
+                    break;
+                case Integral_Fill:
+                    objectsize.Width=int(std::ceil(float(area.Width)/objectsize.Width))*objectsize.Width;
+                    break;
+                case Integral_Best:
+                    objectsize.Width=int(std::round(float(area.Width)/objectsize.Width))*objectsize.Width;
+                    break;
+                case Stretch:
+                case Tile:
+                    objectsize.Height=area.Height;
+                    break;
+                case Single:
+                    break;
 #ifndef NDEBUG
-				default:
-					throw std::runtime_error("Unknown mode");
-					break;
+                default:
+                    throw std::runtime_error("Unknown mode");
+                    break;
 #endif
-				}
+                }
 
-				return objectsize;
-			}
+                return objectsize;
+            }
 
-			/// Calculates the size of the object according to the tiling rules
-			Geometry::Sizef CalculateSize(Geometry::Sizef objectsize, const Geometry::Sizef &area) const {
-				switch(Horizontal) {
-					case Integral_Smaller:
-						objectsize.Width=floor(area.Width/objectsize.Width)*objectsize.Width;
-						break;
-					case Integral_Fill:
-						objectsize.Width=ceil(area.Width/objectsize.Width)*objectsize.Width;
-						break;
-					case Integral_Best:
-						objectsize.Width=round(area.Width/objectsize.Width)*objectsize.Width;
-						break;
-					case Stretch:
-					case Tile:
-						objectsize.Width=area.Width;
-						break;
-					case Single:
-						break;
+            /// Calculates the size of the object according to the tiling rules
+            Geometry::Sizef CalculateSize(Geometry::Sizef objectsize, const Geometry::Sizef &area) const {
+                switch(Horizontal) {
+                    case Integral_Smaller:
+                        objectsize.Width=floor(area.Width/objectsize.Width)*objectsize.Width;
+                        break;
+                    case Integral_Fill:
+                        objectsize.Width=ceil(area.Width/objectsize.Width)*objectsize.Width;
+                        break;
+                    case Integral_Best:
+                        objectsize.Width=round(area.Width/objectsize.Width)*objectsize.Width;
+                        break;
+                    case Stretch:
+                    case Tile:
+                        objectsize.Width=area.Width;
+                        break;
+                    case Single:
+                        break;
 #ifndef NDEBUG
-					default:
-						throw std::runtime_error("Unknown mode");
-						break;
+                    default:
+                        throw std::runtime_error("Unknown mode");
+                        break;
 #endif
-				}
+                }
 
-				switch(Vertical) {
-					case Integral_Smaller:
-						objectsize.Height=floor(area.Height/objectsize.Height)*objectsize.Height;
-						break;
-					case Integral_Fill:
-						objectsize.Height=ceil(area.Height/objectsize.Height)*objectsize.Height;
-						break;
-					case Integral_Best:
-						objectsize.Height=round(area.Height/objectsize.Height)*objectsize.Height;
-						break;
-					case Stretch:
-					case Tile:
-						objectsize.Height=area.Height;
-						break;
-					case Single:
-						break;
+                switch(Vertical) {
+                    case Integral_Smaller:
+                        objectsize.Height=floor(area.Height/objectsize.Height)*objectsize.Height;
+                        break;
+                    case Integral_Fill:
+                        objectsize.Height=ceil(area.Height/objectsize.Height)*objectsize.Height;
+                        break;
+                    case Integral_Best:
+                        objectsize.Height=round(area.Height/objectsize.Height)*objectsize.Height;
+                        break;
+                    case Stretch:
+                    case Tile:
+                        objectsize.Height=area.Height;
+                        break;
+                    case Single:
+                        break;
 #ifndef NDEBUG
-					default:
-						throw std::runtime_error("Unknown mode");
-						break;
+                    default:
+                        throw std::runtime_error("Unknown mode");
+                        break;
 #endif
-				}
+                }
 
-				return objectsize;
-			}
+                return objectsize;
+            }
 
 
-			/// Calculates the size of the object according to the tiling and placement rules
-			Geometry::Point CalculateOffset(const Geometry::Size &objectsize, const Geometry::Size &area) const {
-				return Graphics::CalculateOffset(Place, area-CalculateSize(objectsize, area));
-			}
+            /// Calculates the size of the object according to the tiling and placement rules
+            Geometry::Point CalculateOffset(const Geometry::Size &objectsize, const Geometry::Size &area) const {
+                return Graphics::CalculateOffset(Place, area-CalculateSize(objectsize, area));
+            }
 
 
-			/// Calculates the size of the object according to the tiling and placement rules
-			Geometry::Pointf CalculateOffset(const Geometry::Sizef &objectsize, const Geometry::Sizef &area) const {
-				return Graphics::CalculateOffset(Place, area-CalculateSize(objectsize, area));
-			}
+            /// Calculates the size of the object according to the tiling and placement rules
+            Geometry::Pointf CalculateOffset(const Geometry::Sizef &objectsize, const Geometry::Sizef &area) const {
+                return Graphics::CalculateOffset(Place, area-CalculateSize(objectsize, area));
+            }
 
-			/// Calculates the drawing area of the object according to the tiling and placement rules
-			Geometry::Rectangle CalculateArea(const Geometry::Size &objectsize, const Geometry::Size &area) const {
-				auto size=CalculateSize(objectsize, area);
-				return{Graphics::CalculateOffset(Place, area-size), size};
-			}
+            /// Calculates the drawing area of the object according to the tiling and placement rules
+            Geometry::Rectangle CalculateArea(const Geometry::Size &objectsize, const Geometry::Size &area) const {
+                auto size=CalculateSize(objectsize, area);
+                return{Graphics::CalculateOffset(Place, area-size), size};
+            }
 
-			/// Calculates the drawing area of the object according to the tiling and placement rules
-			Geometry::Rectanglef CalculateArea(const Geometry::Sizef &objectsize, const Geometry::Sizef &area) const {
-				auto size=CalculateSize(objectsize, area);
-				return{Graphics::CalculateOffset(Place, area-size), size};
-			}
+            /// Calculates the drawing area of the object according to the tiling and placement rules
+            Geometry::Rectanglef CalculateArea(const Geometry::Sizef &objectsize, const Geometry::Sizef &area) const {
+                auto size=CalculateSize(objectsize, area);
+                return{Graphics::CalculateOffset(Place, area-size), size};
+            }
 
-			/// Calculates the size of the object according to the tiling rules
-			Geometry::Size CalculateSize(Geometry::Size repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
-				switch(Horizontal) {
-				case Integral_Smaller:
-					repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
-					break;
-				case Integral_Fill:
-					repeatingsize.Width=int(std::ceil(float(area.Width-fixedsize.Width)/repeatingsize.Width))*repeatingsize.Width+fixedsize.Width;
-					break;
-				case Integral_Best:
-					repeatingsize.Width=int(std::round(float(area.Width-fixedsize.Width)/repeatingsize.Width))*repeatingsize.Width+fixedsize.Width;
-					break;
-				case Stretch:
-				case Tile:
-					repeatingsize.Width=area.Width;
-					break;
-				case Single:
-					break;
+            /// Calculates the size of the object according to the tiling rules
+            Geometry::Size CalculateSize(Geometry::Size repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
+                switch(Horizontal) {
+                case Integral_Smaller:
+                    repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
+                    break;
+                case Integral_Fill:
+                    repeatingsize.Width=int(std::ceil(float(area.Width-fixedsize.Width)/repeatingsize.Width))*repeatingsize.Width+fixedsize.Width;
+                    break;
+                case Integral_Best:
+                    repeatingsize.Width=int(std::round(float(area.Width-fixedsize.Width)/repeatingsize.Width))*repeatingsize.Width+fixedsize.Width;
+                    break;
+                case Stretch:
+                case Tile:
+                    repeatingsize.Width=area.Width;
+                    break;
+                case Single:
+                    break;
 #ifndef NDEBUG
-				default:
-					throw std::runtime_error("Unknown mode");
-					break;
+                default:
+                    throw std::runtime_error("Unknown mode");
+                    break;
 #endif
-				}
+                }
 
-				switch(Vertical) {
-				case Integral_Smaller:
-					repeatingsize.Height=((area.Height-fixedsize.Height)/repeatingsize.Height)*repeatingsize.Height+fixedsize.Height;
-					break;
-				case Integral_Fill:
-					repeatingsize.Height=int(std::ceil(float(area.Height-fixedsize.Height)/repeatingsize.Height))*repeatingsize.Height+fixedsize.Height;
-					break;
-				case Integral_Best:
-					repeatingsize.Height=int(std::round(float(area.Height-fixedsize.Height)/repeatingsize.Height))*repeatingsize.Height+fixedsize.Height;
-					break;
-				case Stretch:
-				case Tile:
-					repeatingsize.Height=area.Height;
-					break;
-				case Single:
-					break;
+                switch(Vertical) {
+                case Integral_Smaller:
+                    repeatingsize.Height=((area.Height-fixedsize.Height)/repeatingsize.Height)*repeatingsize.Height+fixedsize.Height;
+                    break;
+                case Integral_Fill:
+                    repeatingsize.Height=int(std::ceil(float(area.Height-fixedsize.Height)/repeatingsize.Height))*repeatingsize.Height+fixedsize.Height;
+                    break;
+                case Integral_Best:
+                    repeatingsize.Height=int(std::round(float(area.Height-fixedsize.Height)/repeatingsize.Height))*repeatingsize.Height+fixedsize.Height;
+                    break;
+                case Stretch:
+                case Tile:
+                    repeatingsize.Height=area.Height;
+                    break;
+                case Single:
+                    break;
 #ifndef NDEBUG
-				default:
-					throw std::runtime_error("Unknown mode");
-					break;
+                default:
+                    throw std::runtime_error("Unknown mode");
+                    break;
 #endif
-				}
+                }
 
-				return repeatingsize;
-			}
+                return repeatingsize;
+            }
 
-			/// Calculates the size of the object according to the tiling rules
-			Geometry::Sizef CalculateSize(Geometry::Sizef repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
-				switch(Horizontal) {
-					case Integral_Smaller:
-						repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Integral_Fill:
-						repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Integral_Best:
-						repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Stretch:
-					case Tile:
-						repeatingsize.Width=area.Width;
-						break;
-					case Single:
-						break;
+            /// Calculates the size of the object according to the tiling rules
+            Geometry::Sizef CalculateSize(Geometry::Sizef repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
+                switch(Horizontal) {
+                    case Integral_Smaller:
+                        repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Integral_Fill:
+                        repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Integral_Best:
+                        repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Stretch:
+                    case Tile:
+                        repeatingsize.Width=area.Width;
+                        break;
+                    case Single:
+                        break;
 #ifndef NDEBUG
-					default:
-						throw std::runtime_error("Unknown mode");
-						break;
+                    default:
+                        throw std::runtime_error("Unknown mode");
+                        break;
 #endif
-				}
+                }
 
-				switch(Vertical) {
-					case Integral_Smaller:
-						repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Integral_Fill:
-						repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Integral_Best:
-						repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
-						break;
-					case Stretch:
-					case Tile:
-						repeatingsize.Height=area.Height;
-						break;
-					case Single:
-						break;
+                switch(Vertical) {
+                    case Integral_Smaller:
+                        repeatingsize.Width=((area.Width-fixedsize.Width)/repeatingsize.Width)*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Integral_Fill:
+                        repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Integral_Best:
+                        repeatingsize.Width=area.Width-fixedsize.Width/repeatingsize.Width*repeatingsize.Width+fixedsize.Width;
+                        break;
+                    case Stretch:
+                    case Tile:
+                        repeatingsize.Height=area.Height;
+                        break;
+                    case Single:
+                        break;
 #ifndef NDEBUG
-					default:
-						throw std::runtime_error("Unknown mode");
-						break;
+                    default:
+                        throw std::runtime_error("Unknown mode");
+                        break;
 #endif
-				}
+                }
 
-				return repeatingsize;
-			}
+                return repeatingsize;
+            }
 
-			/// Calculates the size of the object according to the tiling and placement rules
-			Geometry::Point CalculateOffset(const Geometry::Size &repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
-				return Graphics::CalculateOffset(Place, area-CalculateSize(repeatingsize, fixedsize, area));
-			}
+            /// Calculates the size of the object according to the tiling and placement rules
+            Geometry::Point CalculateOffset(const Geometry::Size &repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
+                return Graphics::CalculateOffset(Place, area-CalculateSize(repeatingsize, fixedsize, area));
+            }
 
-			/// Calculates the size of the object according to the tiling and placement rules
-			Geometry::Pointf CalculateOffset(const Geometry::Sizef &repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
-				return Graphics::CalculateOffset(Place, area-CalculateSize(repeatingsize, fixedsize, area));
-			}
+            /// Calculates the size of the object according to the tiling and placement rules
+            Geometry::Pointf CalculateOffset(const Geometry::Sizef &repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
+                return Graphics::CalculateOffset(Place, area-CalculateSize(repeatingsize, fixedsize, area));
+            }
 
-			/// Calculates the drawing area of the object according to the tiling and placement rules
-			Geometry::Rectangle CalculateArea(const Geometry::Size &repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
-				auto size=CalculateSize(repeatingsize, fixedsize, area);
-				return{Graphics::CalculateOffset(Place, area-size), size};
-			}
+            /// Calculates the drawing area of the object according to the tiling and placement rules
+            Geometry::Rectangle CalculateArea(const Geometry::Size &repeatingsize, const Geometry::Size &fixedsize, const Geometry::Size &area) const {
+                auto size=CalculateSize(repeatingsize, fixedsize, area);
+                return{Graphics::CalculateOffset(Place, area-size), size};
+            }
 
-			/// Calculates the drawing area of the object according to the tiling and placement rules
-			Geometry::Rectangle CalculateArea(const Geometry::Sizef &repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
-				auto size=CalculateSize(repeatingsize, fixedsize, area);
-				return{Graphics::CalculateOffset(Place, area-size), size};
-			}
+            /// Calculates the drawing area of the object according to the tiling and placement rules
+            Geometry::Rectangle CalculateArea(const Geometry::Sizef &repeatingsize, const Geometry::Sizef &fixedsize, const Geometry::Sizef &area) const {
+                auto size=CalculateSize(repeatingsize, fixedsize, area);
+                return{Graphics::CalculateOffset(Place, area-size), size};
+            }
 
-			Graphics::Tiling GetTiling() const {
-				return Graphics::Tile(Horizontal!=Single && Horizontal!=Stretch, Vertical!=Single && Vertical!=Stretch);
-			}
+            Graphics::Tiling GetTiling() const {
+                return Graphics::Tile(Horizontal!=Single && Horizontal!=Stretch, Vertical!=Single && Vertical!=Stretch);
+            }
 
-			/// Horizontal tiling mode
-			Tiling				Horizontal;
+            /// Horizontal tiling mode
+            Tiling				Horizontal;
 
-			/// Vertical tiling mode
-			Tiling				Vertical;
+            /// Vertical tiling mode
+            Tiling				Vertical;
 
-			/// Placement method
-			Placement	Place;
-		};
+            /// Placement method
+            Placement	Place;
+        };
 
-		/// This interface represents a GL texture source.
-		class TextureSource {
-		public:
-			/// Should return GL::Texture to be drawn. This could be 0 to denote no texture is to be used.
-			virtual GL::Texture GetID() const = 0;
+        /// This interface represents a GL texture source.
+        class TextureSource {
+        public:
+            /// Should return GL::Texture to be drawn. This could be 0 to denote no texture is to be used.
+            virtual GL::Texture GetID() const = 0;
             
             virtual ColorMode GetMode() const = 0;
 
-			/// Should return the size of the image stored in texture. Not the whole texture size.
-			virtual Geometry::Size GetImageSize() const = 0;
-
-			/// Should return the coordinates of the texture to be used
-			virtual const Geometry::Pointf *GetCoordinates() const = 0;
-
-			/// Returns whether this texture uses only a part of the GL::Texture. This indicates that the tiling
-			/// operations should be performed without texture repeating method.
-			bool IsPartial() const {
-				return memcmp(GetCoordinates(), fullcoordinates, sizeof(fullcoordinates))!=0;
-			}
+            /// Should return the size of the image stored in texture. Not the whole texture size.
+            virtual Geometry::Size GetImageSize() const = 0;
 
-		protected:
-			/// Coordinates that selects the entire texture to be used
-			static const Geometry::Pointf fullcoordinates[4];
-		};
-
-		namespace internal {
-			
-
-			extern GL::Texture LastTexture;
-
-			void ActivateQuadVertices();
-			void DrawQuadVertices();
-
-		}
-	}
-}
-
-
+            /// Should return the coordinates of the texture to be used
+            virtual const Geometry::Pointf *GetCoordinates() const = 0;
 
-#ifdef fnonona
-#pragma once
-
-#include "GGE.h"
-#include "OS.h"
-
-#include <GL/gl.h>
-#include <assert.h>
-#include <stdexcept>
-#include <string>
-#include <array>
-
-#ifdef WIN32
-#	undef APIENTRY
-#	undef WINGDIAPI
-#endif
+            /// Returns whether this texture uses only a part of the GL::Texture. This indicates that the tiling
+            /// operations should be performed without texture repeating method.
+            bool IsPartial() const {
+                return memcmp(GetCoordinates(), fullcoordinates, sizeof(fullcoordinates))!=0;
+            }
 
-#include "../Utils/ManagedBuffer.h"
-#include "../Utils/Point2D.h"
-#include "../Utils/Bounds2D.h"
-#include "../Utils/Rectangle2D.h"
-#include "../Utils/Size2D.h"
-#include "../Utils/Logging.h"
-#include "External/glutil/MatrixStack.h"
+        protected:
+            /// Coordinates that selects the entire texture to be used
+            static const Geometry::Pointf fullcoordinates[4];
+        };
 
-#ifndef GL_BGR
-#	define GL_BGR	0x80E0
-#	define GL_BGRA	0x80E1
-#endif
-
-#ifndef PI
-#	define PI	3.1415926535898f
-#endif
+        namespace internal {
 
 
-////Namespace for Gorgon Game Engine
-namespace gge { namespace graphics {
-
-	extern gge::utils::Logger				log;
-
-	extern glutil::MatrixStack				ModelViewMatrixStack;
-	extern glutil::MatrixStack				ProjectionMatrixStack;
-
-	
-	class TextureAttachment {
-	public:
-		////Coordinates of texture rectangle
-		TexturePosition *TextureCoords;
-		////Whether this surface has its own texture coordinates
-		bool HasOwnTextureCoords;
-		const GLTexture *Texture;
-		
-		TextureAttachment() : HasOwnTextureCoords(false), TextureCoords(NULL), Texture(NULL) {}
-
-		////Deletes texture coordinate information
-		void DeleteTextureCoords() {
-			if(HasOwnTextureCoords) {
-				HasOwnTextureCoords=false;
-				delete[] TextureCoords;
-			}
-		}
-
-		////Changes current texture to the given one
-		void SetTexture(const GLTexture *texture) {
-			DeleteTextureCoords();
-
-			this->Texture=texture;
-			TextureCoords=const_cast<TexturePosition*>((const TexturePosition*)texture->ImageCoord);
-		}
-
-		////Returns current texture
-		const GLTexture *GetTexture() const {
-			return Texture;
-		}
-
-		////Creates texture coordinate information,
-		/// should be called before modifying texture
-		/// coordinates
-		void CreateTextureCoords() {
-			if(!HasOwnTextureCoords) {
-				HasOwnTextureCoords=true;
-				TextureCoords=new TexturePosition[4];
-			}
-		}
-		
-		~TextureAttachment() {
-			DeleteTextureCoords();
-		}
-	};
-
-	////This class can be used to store basic surface information.
-	/// It has also support for modifiable texture coordinates.
-	class BasicSurface {
-	public:
-		////Coordinates of vertices
-		VertexPosition VertexCoords[4];
-		////Coordinates of texture rectangle, prefer not to modify manually
-		TexturePosition *TextureCoords;
-		////Whether this surface has its own texture coordinates
-		bool HasOwnTextureCoords;
-
-		enum DrawMode {
-			Normal,
-			OffscreenAlphaOnly,
-			Offscreen,
-			SetAlpha
-		} Mode;
-
-		////Empty constructor
-		BasicSurface() : Mode(Normal) {
-			Texture=NULL;
-			Alpha=NULL;
-			HasOwnTextureCoords=false;
-			TextureCoords=NULL;
-			VertexCoords[0].z=0;
-			VertexCoords[1].z=0;
-			VertexCoords[2].z=0;
-			VertexCoords[3].z=0;
-		}
-
-		////Filling constructor that sets texture
-		BasicSurface(GLTexture *texture) {
-			this->Texture=texture;
-			TextureCoords=texture->ImageCoord;
-
-			HasOwnTextureCoords=false;
-		}
-
-		////Deletes texture coordinate information
-		void DeleteTextureCoords() {
-			if(HasOwnTextureCoords) {
-				HasOwnTextureCoords=false;
-				delete[] TextureCoords;
-			}
-		}
-
-		////Changes current texture to the given one
-		void SetTexture(const GLTexture *texture) {
-			DeleteTextureCoords();
-
-			this->Texture=texture;
-			TextureCoords=const_cast<TexturePosition*>((const TexturePosition*)texture->ImageCoord);
-			
-			if(Alpha) {
-				delete Alpha;
-				Alpha=NULL;
-			}
-		}
-
-		////Returns current texture
-		const GLTexture *GetTexture() const {
-			return Texture;
-		}
-
-		////Creates texture coordinate information,
-		/// should be called before modifying texture
-		/// coordinates
-		void CreateTextureCoords() {
-			if(!HasOwnTextureCoords) {
-				HasOwnTextureCoords=true;
-				TextureCoords=new TexturePosition[4];
-			}
-		}
-
-		////Clears any unneeded data
-		~BasicSurface() {
-			if(HasOwnTextureCoords && TextureCoords)
-				delete[] TextureCoords;
-		}
-		
-		TextureAttachment *Alpha;
-		
-	protected:
-		////The texture to be used
-		const GLTexture *Texture;
-	};
-
-	std::array<float,24>					GetVertexData(const BasicSurface& surface);
-
-
+            extern GL::Texture LastTexture;
 
-	class SizeController2D {
-	public:
-
-		enum TilingType {
-			//Should work as Continous if object is sizable
-			Single					= B8(00000000),
-			//Should work as Continous if object is sizable
-			Stretch					= B8(00000010),
-
-			/*
-			Integral	= B8(00000100),
-			Smaller		= B8(00001000),
-			Closest		= B8(00010000),
-			Best		= B8(00100000),
-			*/
-
-			//An object can either be sizable or tilable, 
-			// Careful! there is code to be updated if 
-			// integrals and tiles are changed to be different
-			Continous			= B8(00000001),
-			Integral_Smaller	= B8(00001101),
-			Integral_Fill		= B8(00010101),
-			Integral_Best		= B8(00100101),
-
-			Tile_Continous			= B8(00000001),
-			Tile_Integral_Smaller	= B8(00001101),
-			Tile_Integral_Fill		= B8(00010101),
-			Tile_Integral_Best		= B8(00100101),
-		} HorizontalTiling, VerticalTiling;
-
-
-		explicit SizeController2D(TilingType HorizontalTiling=Single, TilingType VerticalTiling=Single, Alignment::Type Align=Alignment::Middle_Center) : 
-			HorizontalTiling(HorizontalTiling), VerticalTiling(VerticalTiling), Align(Align)
-		{ }
-		Alignment::Type Align;
-
-		static const SizeController2D TileFit;
-		static const SizeController2D StretchFit;
-		static const SizeController2D SingleTopLeft;
-		static const SizeController2D SingleBottomRight;
-		static const SizeController2D SingleMiddleCenter;
-
-		int CalculateWidth(int W, int Increment) const {
-			if(HorizontalTiling==SizeController2D::Tile_Integral_Best) {
-				return (int)utils::Round((double)W/Increment)*Increment;
-			}
-			else if(HorizontalTiling==SizeController2D::Tile_Integral_Smaller) {
-				return (int)std::floor((double)W/Increment)*Increment;
-			}
-			else if(HorizontalTiling==SizeController2D::Tile_Integral_Fill) {
-				return (int)std::ceil((double)W/Increment)*Increment;
-			}
-			else
-				return W;
-		}
-
-		int CalculateWidth(int W, int Increment, int Overhead) const {
-			if(HorizontalTiling==SizeController2D::Integral_Best) {
-				return (int)utils::Round((double)(W-Overhead)/Increment)*Increment+Overhead;
-			}
-			else if(HorizontalTiling==SizeController2D::Integral_Smaller) {
-				return (int)std::floor((double)(W-Overhead)/Increment)*Increment+Overhead;
-			}
-			else if(HorizontalTiling==SizeController2D::Integral_Fill) {
-				return (int)std::ceil((double)(W-Overhead)/Increment)*Increment+Overhead;
-			}
-			else
-				return W;
-		}
+            void ActivateQuadVertices();
+            void DrawQuadVertices();
 
-		int CalculateHeight(int H, int Increment) const {
-			if(VerticalTiling==SizeController2D::Tile_Integral_Best) {
-				return (int)utils::Round((double)H/Increment)*Increment;
-			}
-			else if(VerticalTiling==SizeController2D::Tile_Integral_Smaller) {
-				return (int)std::floor((double)H/Increment)*Increment;
-			}
-			else if(VerticalTiling==SizeController2D::Tile_Integral_Fill) {
-				return (int)std::ceil((double)H/Increment)*Increment;
-			}
-			else
-				return H;
-		}
-
-		int CalculateHeight(int H, int Increment, int Overhead) const {
-			if(VerticalTiling==SizeController2D::Integral_Best) {
-				return (int)utils::Round((double)(H-Overhead)/Increment)*Increment+Overhead;
-			}
-			else if(VerticalTiling==SizeController2D::Integral_Smaller) {
-				return (int)std::floor((double)(H-Overhead)/Increment)*Increment+Overhead;
-			}
-			else if(VerticalTiling==SizeController2D::Integral_Fill) {
-				return (int)std::ceil((double)(H-Overhead)/Increment)*Increment+Overhead;
-			}
-			else
-				return H;
-		}
-	};
-
-	
-
-	////Initializes OpenGL graphics with the given parameters,
-	/// returns created device context
-	///@hWnd		: Handle for the target window
-	///@BitDepth	: Used if fullscreen, changed bitdepth of screen
-	os::DeviceHandle Initialize(os::WindowHandle hWnd, int BitDepth, int Width, int Height);
-
-	namespace system {
-
-		////Creates rectangle structure based on give parameters
-		//RECT makerect(int x, int y, int w, int h);
-		////Converts Alpha only image to Alpha and Luminance (grayscale) image.
-		/// Destination array should be allocated. This algorithm is optimized
-		/// for speed.
-		///@Source		: Source data array, no justification is needed,
-		///               should be 1 byte/pix
-		///@Destination	: Destination data array, data is copied without
-		///               any justification, should be allocated for 2 byte/pix
-		void A8ToA8L8(int Width, int Height, Byte *Source, Byte *Destination);
-		////This function sets the current texture to given data
-		void SetTexture(Byte *data, int cx, int cy, ColorMode::Type mode);
-		////This function creates a texture from the given data and
-		/// returns texture information in a structure
-		///@Image		: Image data
-		///@Mode		: Color mode
-		GLTexture GenerateTexture(Byte *Image,int Width,int Height,ColorMode::Type Mode);
-		void UpdateTexture(GLTexture TextureID, Byte *Image,ColorMode::Type Mode);
-		void DestroyTexture(GLTexture &texture);
-		////Returns equivalent OpenGL color mode constant
-		///@Mode		: GGE color mode constant
-		GLenum getGLColorMode(ColorMode::Type Mode);
-		////Cleans render buffer and prepares for rendering
-		void PreRender();
-		////Performs post render tasks
-		///@hDC			: Device context that is created by
-		/// initialize graphics function
-		void PostRender(os::DeviceHandle Device, os::WindowHandle win);
-
-		void ResizeGL(int Width, int Height);
-	}
-
-	extern utils::Size ScreenSize;
-} }
-
-#endif
+        }
+    }
+}

mercurial