/*
 * Project: VizKit
 * Version: 2.3
 
 * Date: 20090823
 * File: VisualGraphicTypes.h
 *
 */

/***************************************************************************
 
 Copyright (c) 2004-2009 Heiko Wichmann (http://www.imagomat.de/vizkit)
 
 
 This software is provided 'as-is', without any expressed or implied warranty. 
 In no event will the authors be held liable for any damages
 arising from the use of this software.
 
 Permission is granted to anyone to use this software for any purpose,
 including commercial applications, and to alter it and redistribute it
 freely, subject to the following restrictions:
 
 1. The origin of this software must not be misrepresented; 
 you must not claim that you wrote the original software. 
 If you use this software in a product, an acknowledgment 
 in the product documentation would be appreciated 
 but is not required.
 
 2. Altered source versions must be plainly marked as such, 
 and must not be misrepresented as being the original software.
 
 3. This notice may not be removed or altered from any source distribution.
 
 ***************************************************************************/

#ifndef VisualGraphicTypes_h
#define VisualGraphicTypes_h


#include "VisualTypes.h"
#include <vector>


/* The common graphics related types used by VisualGraphics and VisualActorGraphics. */

namespace VizKit {
	
	class VisualVertex; // Forward declaration (to avoid include of header file).
	
	/**
	 * A pixel color contains ARGB values (alpha, red, green, blue with 8 bits for each color channel).
	 */
	typedef uint32 PixelColor;
	
	/**
	 * A Point2D is a position in 2-dimensional planar space.
	 */
	typedef struct {
		double x; /**< Horizontal position. */
		double y; /**< Vertical position. */
	} Point2D;
	
	/**
	 * A pixel is a two-dimensional point relative to physical coordinate system.
	 */	
	typedef struct {
		uint32 x; /**< Horizontal position. */
		uint32 y; /**< Vertical position. */
	} Pixel;
	
	/**
	 * A colored pixel is a pixel with a color value.
	 */	
	typedef struct {
		PixelColor color; /**< Color value of the pixel. */
		uint32 x; /**< Horizontal position. */
		uint32 y; /**< Vertical position. */
	} ColoredPixel;
	
	/**
	 * A Point3D is a position in 3-dimensional space.
	 */
	typedef struct {
		double x; /**< Horizontal position. */
		double y; /**< Vertical position. */
		double z; /**< Depth position. */
	} Point3D;
	
	/**
	 * A Coord is a three-dimensional point relative to logical coordinate system.
	 */
	typedef Point3D Coord;
	
	/**
	 * A RelCoord is a relative three-dimensional point in coordinate system.
	 * x: 0.0 means: left, 1.0 means: right; y: 0.0 means: bottom, 1.0 means: top; z: 0.0 means: front, 1.0 means: back.
	 */
	typedef Point3D RelCoord;
	
	/**
	 * Predefined zero coord (x = 0.0 and y = 0.0).
	 */
	extern const Coord zeroCoord;
	
	/**
	 * A Vector points in a direction.
	 */
	typedef Point3D Vector;
	
	/**
	 * A TexCoord is a coord position of a texture.
	 */
	typedef struct {
		double s; /**< Horizontal position. */
		double t; /**< Vertical position. */
	} TexCoord;
	
	/**
	 * A RelTexCoord is a coord position of a texture.
	 * s: 0.0 means: left, 1.0 means: right; t: 0.0 means: bottom, 1.0 means: top.
	 */
	typedef TexCoord RelTexCoord;
	
	/**
	 * A two-dimensional size relative to logical coordinate system.
	 */
	typedef struct {
		double width; /**< Horizontal size. */
		double height; /**< Vertical size. */
	} CoordSize2D;
	
	/**
	 * A three-dimensional size relative to logical coordinate system.
	 */
	typedef struct {
		double width; /**< Horizontal size. */
		double height; /**< Vertical size. */
		double depth; /**< Size in z-dimension. */
	} CoordSize3D;
	
	/**
	 * A two-dimensional size relative to physical coordinate system.
	 */
	typedef struct {
		uint32 width; /**< Horizontal size. */
		uint32 height; /**< Vertical size. */
	} PixelRect;
	
	/**
	 * A rectangle.
	 */
	typedef struct {
		PixelRect pixelRect; /**< The size of the rectangle in pixels. */
		CoordSize2D coordSize; /**< The size of the rectangle in coord dimensions. */
	} Rect;
	
	/**
	 * A positioned rectangle, measured in pixels. Origin at top-left.
	 */
	typedef struct {
		PixelRect pixelRect; /**< The size of the rectangle in pixels. */
		Pixel topLeftPixel; /**< The top-left pixel of the positioned rect. */
	} TopLeftPositionedPixelRect;
	
	/**
	 * A positioned rectangle, measured in pixels. Origin at bottom-left.
	 */
	typedef struct {
		PixelRect pixelRect; /**< The size of the rectangle in pixels. */
		Pixel bottomLeftPixel; /**< The bottom-left pixel of the positioned rect. */
	} BottomLeftPositionedPixelRect;
	
	/**
	 * A positioned rectangle, measured in coords. Origin at bottom-left.
	 */
	typedef struct {
		CoordSize2D coordSize; /**< The size of the rectangle in coords. */
		Coord bottomLeftCoord; /**< The top-left coord of the positioned rect. */
	} PositionedCoordRect;
	
	/**
	 * Orientation.
	 */
	typedef enum {
		kPortrait = 0,
		kLandscape,
		kSquare
	} Orientation;
	
	/**
	 * A relational rectangle is determined by aspect ratio of width and height and orientation. No absolute are given.
	 */
	typedef struct {
		Orientation orientation; /**< The orientation of the rectangle. */
		double aspectRatio; /**< The aspect ratio (being > 1). */
	} RelationalRect;
	
	/**
	 * A box.
	 */
	typedef struct {
		CoordSize3D coordSize; /**< The size of the box in coord dimensions. */
	} Box;
	
	/**
	 * A positioned box. Origin at bottom-left-front.
	 */
	typedef struct {
		CoordSize3D coordSize; /**< The size of the rectangle in coord dimensions. */
		Coord bottomLeftFrontCoord; /**< The top-left-front coord of the positioned box. */
	} PositionedBox;
	
	/**
	 * ScalingBehaviourEnumValues enumerate the possible bit flag values of a ScalingBehaviour.
	 */
	enum ScalingBehaviourEnumValues {
		kNoScaling = 0x1, // 00000001
		kScalingAllowed = 0x2, // 00000010
		kPreserveAspectRatio = 0x6, // 00000110
		kNonproportional = 0xA, // 00001010
		kClippingAllowed = 0x10 // 00010000
	};
	
	/**
	 * ScalingBehaviour is the data type for specifying the scaling behaviour of a texture in combination with margins
	 */
	typedef uint32 ScalingBehaviour;
	
	/**
	 * Visibility specifies the visibility. Two states are possible: visible and invisible.
	 */
	typedef enum {
		kVisible = 0,
		kInvisible
	} Visibility;
	
	/**
	 * ProjectionMode specifies orthographic or perspective projection.
	 */
	typedef enum {
		kOrthographic = 0,
		kPerspective
	} ProjectionMode;
	
	/**
	 * Symbolic names for arbitrary positions in 3-dimensional space.
	 */
	typedef enum {
		kTopLeft = 0,
		kBottomLeft,
		kBottomRight,
		kTopRight		
	} SpacePosition;
	
	/**
	 * Stores the values of a composite color of red, green, blue and alpha.
	 */
	typedef struct {
		double red; /**< Red value. Backing store. Value does not change except if it is set explicitely exernally. 0.0f .. 1.0f. */
		double green; /**< Green value. Backing store. Value does not change except if it is set explicitely exernally. 0.0f .. 1.0f. */
		double blue; /**< Blue value. Backing store. Value does not change except if it is set explicitely exernally. 0.0f .. 1.0f. */
		double alpha; /**< Alpha value. Backing store. Value does not change except if it is set explicitely exernally. 0.0f .. 1.0f. */
		double r; /**< Red value. 0.0f .. 1.0f. */
		double g; /**< Green value. 0.0f .. 1.0f. */
		double b; /**< Blue value. 0.0f .. 1.0f. */
		double a; /**< Alpha value. 0.0f .. 1.0f. */
	} RGBAColor;
	
	/**
	 * Stores the color values used by a vertex.
	 */
	typedef RGBAColor VertexColor;
	
	/**
	 * Predefined black color.
	 */
	extern const VertexColor black;
	
	/**
	 * Predefined white color.
	 */
	extern const VertexColor white;
	
	/**
	 * Predefined red color.
	 */
	extern const VertexColor red;
	
	/**
	 * Predefined green color.
	 */
	extern const VertexColor green;
	
	/**
	 * Predefined blue color.
	 */
	extern const VertexColor blue;
	
	/**
	 * Predefined transparent color.
	 */
	extern const VertexColor transparent;
	
	/**
	 * Stores the coord position values used by a vertex.
	 */
	typedef struct {
		Coord coord; /**< Coord position of vertex. */
		RelCoord relCoord; /**< Relative coord position of vertex. x: 0.0 means: left, 1.0 means: right; y: 0.0 means: bottom, 1.0 means: top; z: 0.0 means: front, 1.0 means: back. */
	} VertexPosition;
	
	/** Chain of vertex positions. */
	typedef std::vector<VertexPosition*> VertexPositionChain;
	/** Pointer to chain of vertex positions. */
	typedef VertexPositionChain* VertexPositionChainRef;
	/** Constant chain of vertex positions. */
	typedef const VertexPositionChain ConstVertexPositionChain;
	/** Pointer to constant chain of vertex positions. */
	typedef const VertexPositionChainRef ConstVertexPositionChainRef;
	
	/** Iterator of chain of vertex positions. */
	typedef VertexPositionChain::iterator VertexPositionChainIterator;
	/** Iterator of constant chain of vertex positions. */
	typedef ConstVertexPositionChain::iterator ConstVertexPositionChainIterator;
	/** Constant iterator of chain of vertex positions. */
	typedef VertexPositionChain::const_iterator VertexPositionChainConstIterator;
	/** Constant iterator of constant chain of vertex positions. */
	typedef ConstVertexPositionChain::const_iterator ConstVertexPositionChainConstIterator;
	
	/**
	 * Stores the s and t coordinate values of texture positions. 
	 * Texture coordinates are referred to as s-, t-, r-, and q-coordinates to distinguish
	 * them from object coordinates (x, y, z, and w) and from elevator coordinates (u and v).
	 */
	/*
	 typedef struct {
	 double sPos;
	 double tPos;
	 double sRelativePos;
	 double tRelativePos;
	 } TexCoordPosition;
	 */
	typedef struct {
		TexCoord coord; /**< Position of texture coord. */
		RelTexCoord relCoord; /**< Relative position of texture coord. */
	} TexCoordPosition;
	
	/** Chain of vertices. */
	typedef std::vector<VisualVertex*> VertexChain;
	/** Pointer to chain of vertices. */
	typedef VertexChain* VertexChainRef;
	/** Constant chain of vertices. */
	typedef const VertexChain ConstVertexChain;
	/** Pointer to constant chain of vertices. */
	typedef const VertexChainRef ConstVertexChainRef;
	
	/** Iterator of chain of vertices. */
	typedef VertexChain::iterator VertexChainIterator;
	/** Iterator of constant chain of vertices. */
	typedef ConstVertexChain::iterator ConstVertexChainIterator;
	/** Constant iterator of chain of vertices. */
	typedef VertexChain::const_iterator VertexChainConstIterator;
	/** Constant iterator of constant chain of vertices. */
	typedef ConstVertexChain::const_iterator ConstVertexChainConstIterator;
	
	extern const int kGL_POINTS; /**< Primitive GL type GL_POINTS (mode). */
	extern const int kGL_LINES; /**< Primitive GL type GL_LINES (mode). */
	extern const int kGL_LINE_STRIP; /**< Primitive GL type GL_LINE_STRIP (mode). */
	extern const int kGL_LINE_LOOP; /**< Primitive GL type GL_LINE_LOOP (mode). */
	extern const int kGL_TRIANGLES; /**< Primitive GL type GL_TRIANGLES (mode). */
	extern const int kGL_TRIANGLE_STRIP; /**< Primitive GL type GL_TRIANGLE_STRIP (mode). */
	extern const int kGL_TRIANGLE_FAN; /**< Primitive GL type GL_TRIANGLE_FAN (mode). */
	extern const int kGL_QUADS; /**< Primitive GL type GL_QUADS (mode). */
	extern const int kGL_QUAD_STRIP; /**< Primitive GL type GL_QUAD_STRIP (mode). */
	extern const int kGL_POLYGON; /**< Primitive GL type GL_POLYGON (mode). */
	
	extern const int kGL_RGBA; /**< Primitive GL type GL_RGBA (format). */
	extern const int kGL_BGRA; /**< Primitive GL type GL_BGRA (format). */
	extern const int kGL_RGB; /**< Primitive GL type GL_RGB (format). */
	extern const int kGL_LUMINANCE; /**< Primitive GL type GL_LUMINANCE (format). */
	extern const int kGL_LUMINANCE_WITH_ALPHA; /**< Primitive GL type GL_LUMINANCE_ALPHA (format). */
	extern const int kGL_INTENSITY; /**< Primitive GL type GL_INTENSITY (format). */
	
	extern const int kGL_UNSIGNED_BYTE; /**< Primitive GL type GL_UNSIGNED_BYTE (data type). */
	extern const int kGL_FLOAT; /**< Primitive GL type GL_FLOAT (data type). */
	extern const int kGL_UNSIGNED_INT_8_8_8_8_REV; /**< Primitive GL type GL_UNSIGNED_INT_8_8_8_8_REV (data type). */
	extern const int kGL_UNSIGNED_INT_8_8_8_8; /**< Primitive GL type GL_UNSIGNED_INT_8_8_8_8 (data type). */
	
	extern const int kGL_FRONT_COLOR_BUFFER; /**< GL enum GL_FRONT (color buffer specification for reading or drawing pixels). */
	extern const int kGL_BACK_COLOR_BUFFER; /**< GL enum GL_BACK (color buffer specification for reading or drawing pixels). */
	
	/**
	 * The measure of box values.
	 */
	typedef enum {
		kPixel = 0, /**< Box attribute is measured in pixels. */
		kPercent /**< Box attribute is measured in percent (of enclosing/surrounding VisualStageBox). */
	} Unit;
	
	/**
	 * Types of horizontal alignment.
	 */
	typedef enum {
		kLeftAligned = 0, /**< Left alignment. */
		kCenterAligned, /**< Centered alignment. */
		kRightAligned /**< Right alignment. */
	} HorizontalAlignment;
	
	/**
	 * Types of vertical alignment.
	 */
	typedef enum {
		kTopAligned = 0, /**< Top alignment. */
		kMiddleAligned, /**< Middle alignment. */
		kBottomAligned /**< Bottom alignment. */
	} VerticalAlignment;
	
	/**
	 * Types of alignment in z-dimension.
	 */
	typedef enum {
		kFrontAligned = 0, /**< Front alignment. */
		kDepthCenterAligned, /**< Centered alignment. */
		kBackAligned /**< Back alignment. */
	} DepthAlignment;
	
	/**
	 * Whether the Nurbs is displayed in outlined mode or filled.
	 */
	typedef enum {
		kFill = 0, /**< Fill Nurbs. */
		kOutlinePolygon /**< Draw outline. */
	} NurbsDisplayMode;
	
	/**
	 * How to blend texture data with the framebuffer data.
	 */
	typedef enum {
		kBlend = 0, /**< Blend with framebuffer data (glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA). */
		kReplace /**< Replace framebuffer data. */
	} BlendMode;
	
}

#endif /* VisualGraphicTypes_h */