diff options
Diffstat (limited to 'h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics')
25 files changed, 5663 insertions, 0 deletions
diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/BlendMode.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/BlendMode.h new file mode 100755 index 0000000..e46f563 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/BlendMode.h @@ -0,0 +1,47 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_BLENDMODE_H +#define SFML_BLENDMODE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> + + +//////////////////////////////////////////////////////////// +/// \brief Available blending modes for drawing +/// +//////////////////////////////////////////////////////////// +typedef enum +{ + sfBlendAlpha, ///< Pixel = Src * a + Dest * (1 - a) + sfBlendAdd, ///< Pixel = Src + Dest + sfBlendMultiply, ///< Pixel = Src * Dest + sfBlendNone ///< No blending +} sfBlendMode; + + +#endif // SFML_BLENDMODE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/CircleShape.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/CircleShape.h new file mode 100755 index 0000000..a37277b --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/CircleShape.h @@ -0,0 +1,431 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_CIRCLESHAPE_H +#define SFML_CIRCLESHAPE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new circle shape +/// +/// \return A new sfCircleShape object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfCircleShape* sfCircleShape_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing circle shape +/// +/// \param shape Shape to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfCircleShape* sfCircleShape_copy(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing circle Shape +/// +/// \param Shape Shape to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_destroy(sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a circle shape +/// +/// This function completely overwrites the previous position. +/// See sfCircleShape_move to apply an offset based on the previous position instead. +/// The default position of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setPosition(sfCircleShape* shape, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a circle shape +/// +/// This function completely overwrites the previous rotation. +/// See sfCircleShape_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a circle Shape object is 0. +/// +/// \param shape Shape object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setRotation(sfCircleShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a circle shape +/// +/// This function completely overwrites the previous scale. +/// See sfCircleShape_scale to add a factor based on the previous scale instead. +/// The default scale of a circle Shape object is (1, 1). +/// +/// \param shape Shape object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setScale(sfCircleShape* shape, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a circle shape +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setOrigin(sfCircleShape* shape, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a circle shape +/// +/// \param shape Shape object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfCircleShape_getPosition(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a circle shape +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param shape Shape object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfCircleShape_getRotation(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a circle shape +/// +/// \param shape Shape object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfCircleShape_getScale(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a circle shape +/// +/// \param shape Shape object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfCircleShape_getOrigin(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Move a circle shape by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfCircleShape_setPosition which overwrites it. +/// +/// \param shape Shape object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_move(sfCircleShape* shape, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a circle shape +/// +/// This function adds to the current rotation of the object, +/// unlike sfCircleShape_setRotation which overwrites it. +/// +/// \param shape Shape object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_rotate(sfCircleShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a circle shape +/// +/// This function multiplies the current scale of the object, +/// unlike sfCircleShape_setScale which overwrites it. +/// +/// \param shape Shape object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_scale(sfCircleShape* shape, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a circle shape +/// +/// \param shape Shape object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfCircleShape_getTransform(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a circle shape +/// +/// \param shape Shape object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfCircleShape_getInverseTransform(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Change the source texture of a circle shape +/// +/// The \a texture argument refers to a texture that must +/// exist as long as the shape uses it. Indeed, the shape +/// doesn't store its own copy of the texture, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the source texture is destroyed and the shape tries to +/// use it, the behaviour is undefined. +/// \a texture can be NULL to disable texturing. +/// If \a resetRect is true, the TextureRect property of +/// the shape is automatically adjusted to the size of the new +/// texture. If it is false, the texture rect is left unchanged. +/// +/// \param shape Shape object +/// \param texture New texture +/// \param resetRect Should the texture rect be reset to the size of the new texture? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setTexture(sfCircleShape* shape, const sfTexture* texture, sfBool resetRect); + +//////////////////////////////////////////////////////////// +/// \brief Set the sub-rectangle of the texture that a circle shape will display +/// +/// The texture rect is useful when you don't want to display +/// the whole texture, but rather a part of it. +/// By default, the texture rect covers the entire texture. +/// +/// \param shape Shape object +/// \param rect Rectangle defining the region of the texture to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setTextureRect(sfCircleShape* shape, sfIntRect rect); + +//////////////////////////////////////////////////////////// +/// \brief Set the fill color of a circle shape +/// +/// This color is modulated (multiplied) with the shape's +/// texture if any. It can be used to colorize the shape, +/// or change its global opacity. +/// You can use sfTransparent to make the inside of +/// the shape transparent, and have the outline alone. +/// By default, the shape's fill color is opaque white. +/// +/// \param shape Shape object +/// \param color New color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setFillColor(sfCircleShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the outline color of a circle shape +/// +/// You can use sfTransparent to disable the outline. +/// By default, the shape's outline color is opaque white. +/// +/// \param shape Shape object +/// \param color New outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setOutlineColor(sfCircleShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the thickness of a circle shape's outline +/// +/// This number cannot be negative. Using zero disables +/// the outline. +/// By default, the outline thickness is 0. +/// +/// \param shape Shape object +/// \param thickness New outline thickness +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setOutlineThickness(sfCircleShape* shape, float thickness); + +//////////////////////////////////////////////////////////// +/// \brief Get the source texture of a circle shape +/// +/// If the shape has no source texture, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the texture when you retrieve it with this function. +/// +/// \param shape Shape object +/// +/// \return Pointer to the shape's texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfCircleShape_getTexture(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the sub-rectangle of the texture displayed by a circle shape +/// +/// \param shape Shape object +/// +/// \return Texture rectangle of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfCircleShape_getTextureRect(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the fill color of a circle shape +/// +/// \param shape Shape object +/// +/// \return Fill color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfCircleShape_getFillColor(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline color of a circle shape +/// +/// \param shape Shape object +/// +/// \return Outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfCircleShape_getOutlineColor(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline thickness of a circle shape +/// +/// \param shape Shape object +/// +/// \return Outline thickness of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfCircleShape_getOutlineThickness(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the total number of points of a circle shape +/// +/// \param shape Shape object +/// +/// \return Number of points of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfCircleShape_getPointCount(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get a point of a circle shape +/// +/// The result is undefined if \a index is out of the valid range. +/// +/// \param shape Shape object +/// \param index Index of the point to get, in range [0 .. getPointCount() - 1] +/// +/// \return Index-th point of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfCircleShape_getPoint(const sfCircleShape* shape, unsigned int index); + +//////////////////////////////////////////////////////////// +/// \brief Set the radius of a circle +/// +/// \param shape Shape object +/// \param radius New radius of the circle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setRadius(sfCircleShape* shape, float radius); + +//////////////////////////////////////////////////////////// +/// \brief Get the radius of a circle +/// +/// \param shape Shape object +/// +/// \return Radius of the circle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfCircleShape_getRadius(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Set the number of points of a circle +/// +/// \param shape Shape object +/// \param count New number of points of the circle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfCircleShape_setPointCount(sfCircleShape* shape, unsigned int count); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a circle shape +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getLocalBounds(const sfCircleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a circle shape +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// sprite in the global 2D world's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfCircleShape_getGlobalBounds(const sfCircleShape* shape); + + +#endif // SFML_CIRCLESHAPE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Color.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Color.h new file mode 100755 index 0000000..f1bc1d6 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Color.h @@ -0,0 +1,106 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_COLOR_H +#define SFML_COLOR_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> + + +//////////////////////////////////////////////////////////// +/// \brief Utility class for manpulating RGBA colors +/// +//////////////////////////////////////////////////////////// +typedef struct +{ + sfUint8 r; + sfUint8 g; + sfUint8 b; + sfUint8 a; +} sfColor; + + +CSFML_GRAPHICS_API sfColor sfBlack; ///< Black predefined color +CSFML_GRAPHICS_API sfColor sfWhite; ///< White predefined color +CSFML_GRAPHICS_API sfColor sfRed; ///< Red predefined color +CSFML_GRAPHICS_API sfColor sfGreen; ///< Green predefined color +CSFML_GRAPHICS_API sfColor sfBlue; ///< Blue predefined color +CSFML_GRAPHICS_API sfColor sfYellow; ///< Yellow predefined color +CSFML_GRAPHICS_API sfColor sfMagenta; ///< Magenta predefined color +CSFML_GRAPHICS_API sfColor sfCyan; ///< Cyan predefined color +CSFML_GRAPHICS_API sfColor sfTransparent; ///< Transparent (black) predefined color + + +//////////////////////////////////////////////////////////// +/// \brief Construct a color from its 3 RGB components +/// +/// \param red Red component (0 .. 255) +/// \param green Green component (0 .. 255) +/// \param blue Blue component (0 .. 255) +/// +/// \return sfColor constructed from the components +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue); + +//////////////////////////////////////////////////////////// +/// \brief Construct a color from its 4 RGBA components +/// +/// \param red Red component (0 .. 255) +/// \param green Green component (0 .. 255) +/// \param blue Blue component (0 .. 255) +/// \param alpha Alpha component (0 .. 255) +/// +/// \return sfColor constructed from the components +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha); + +//////////////////////////////////////////////////////////// +/// \brief Add two colors +/// +/// \param color1 First color +/// \param color2 Second color +/// +/// \return Component-wise saturated addition of the two colors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfColor_add(sfColor color1, sfColor color2); + +//////////////////////////////////////////////////////////// +/// \brief Modulate two colors +/// +/// \param color1 First color +/// \param color2 Second color +/// +/// \return Component-wise multiplication of the two colors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfColor_modulate(sfColor color1, sfColor color2); + + +#endif // SFML_COLOR_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/ConvexShape.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/ConvexShape.h new file mode 100755 index 0000000..bdac8c3 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/ConvexShape.h @@ -0,0 +1,430 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_CONVEXSHAPE_H +#define SFML_CONVEXSHAPE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new convex shape +/// +/// \return A new sfConvexShape object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfConvexShape* sfConvexShape_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing convex shape +/// +/// \param shape Shape to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfConvexShape* sfConvexShape_copy(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing convex Shape +/// +/// \param Shape Shape to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_destroy(sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a convex shape +/// +/// This function completely overwrites the previous position. +/// See sfConvexShape_move to apply an offset based on the previous position instead. +/// The default position of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setPosition(sfConvexShape* shape, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a convex shape +/// +/// This function completely overwrites the previous rotation. +/// See sfConvexShape_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a circle Shape object is 0. +/// +/// \param shape Shape object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setRotation(sfConvexShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a convex shape +/// +/// This function completely overwrites the previous scale. +/// See sfConvexShape_scale to add a factor based on the previous scale instead. +/// The default scale of a circle Shape object is (1, 1). +/// +/// \param shape Shape object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setScale(sfConvexShape* shape, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a convex shape +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setOrigin(sfConvexShape* shape, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a convex shape +/// +/// \param shape Shape object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfConvexShape_getPosition(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a convex shape +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param shape Shape object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfConvexShape_getRotation(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a convex shape +/// +/// \param shape Shape object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfConvexShape_getScale(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a convex shape +/// +/// \param shape Shape object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfConvexShape_getOrigin(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Move a convex shape by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfConvexShape_setPosition which overwrites it. +/// +/// \param shape Shape object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_move(sfConvexShape* shape, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a convex shape +/// +/// This function adds to the current rotation of the object, +/// unlike sfConvexShape_setRotation which overwrites it. +/// +/// \param shape Shape object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_rotate(sfConvexShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a convex shape +/// +/// This function multiplies the current scale of the object, +/// unlike sfConvexShape_setScale which overwrites it. +/// +/// \param shape Shape object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_scale(sfConvexShape* shape, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a convex shape +/// +/// \param shape shape object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfConvexShape_getTransform(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a convex shape +/// +/// \param shape shape object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfConvexShape_getInverseTransform(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Change the source texture of a convex shape +/// +/// The \a texture argument refers to a texture that must +/// exist as long as the shape uses it. Indeed, the shape +/// doesn't store its own copy of the texture, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the source texture is destroyed and the shape tries to +/// use it, the behaviour is undefined. +/// \a texture can be NULL to disable texturing. +/// If \a resetRect is true, the TextureRect property of +/// the shape is automatically adjusted to the size of the new +/// texture. If it is false, the texture rect is left unchanged. +/// +/// \param shape Shape object +/// \param texture New texture +/// \param resetRect Should the texture rect be reset to the size of the new texture? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setTexture(sfConvexShape* shape, const sfTexture* texture, sfBool resetRect); + +//////////////////////////////////////////////////////////// +/// \brief Set the sub-rectangle of the texture that a convex shape will display +/// +/// The texture rect is useful when you don't want to display +/// the whole texture, but rather a part of it. +/// By default, the texture rect covers the entire texture. +/// +/// \param shape Shape object +/// \param rect Rectangle defining the region of the texture to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setTextureRect(sfConvexShape* shape, sfIntRect rect); + +//////////////////////////////////////////////////////////// +/// \brief Set the fill color of a convex shape +/// +/// This color is modulated (multiplied) with the shape's +/// texture if any. It can be used to colorize the shape, +/// or change its global opacity. +/// You can use sfTransparent to make the inside of +/// the shape transparent, and have the outline alone. +/// By default, the shape's fill color is opaque white. +/// +/// \param shape Shape object +/// \param color New color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setFillColor(sfConvexShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the outline color of a convex shape +/// +/// You can use sfTransparent to disable the outline. +/// By default, the shape's outline color is opaque white. +/// +/// \param shape Shape object +/// \param color New outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setOutlineColor(sfConvexShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the thickness of a convex shape's outline +/// +/// This number cannot be negative. Using zero disables +/// the outline. +/// By default, the outline thickness is 0. +/// +/// \param shape Shape object +/// \param thickness New outline thickness +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setOutlineThickness(sfConvexShape* shape, float thickness); + +//////////////////////////////////////////////////////////// +/// \brief Get the source texture of a convex shape +/// +/// If the shape has no source texture, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the texture when you retrieve it with this function. +/// +/// \param shape Shape object +/// +/// \return Pointer to the shape's texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfConvexShape_getTexture(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the sub-rectangle of the texture displayed by a convex shape +/// +/// \param shape Shape object +/// +/// \return Texture rectangle of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfConvexShape_getTextureRect(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the fill color of a convex shape +/// +/// \param shape Shape object +/// +/// \return Fill color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfConvexShape_getFillColor(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline color of a convex shape +/// +/// \param shape Shape object +/// +/// \return Outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfConvexShape_getOutlineColor(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline thickness of a convex shape +/// +/// \param shape Shape object +/// +/// \return Outline thickness of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfConvexShape_getOutlineThickness(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the total number of points of a convex shape +/// +/// \param shape Shape object +/// +/// \return Number of points of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfConvexShape_getPointCount(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get a point of a convex shape +/// +/// The result is undefined if \a index is out of the valid range. +/// +/// \param shape Shape object +/// \param index Index of the point to get, in range [0 .. getPointCount() - 1] +/// +/// \return Index-th point of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfConvexShape_getPoint(const sfConvexShape* shape, unsigned int index); + +//////////////////////////////////////////////////////////// +/// \brief Set the number of points of a convex shap +/// +/// \a count must be greater than 2 to define a valid shape. +/// +/// \param shape Shape object +/// \param count New number of points of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setPointCount(sfConvexShape* shape, unsigned int count); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a point in a convex shape +/// +/// Don't forget that the polygon must remain convex, and +/// the points need to stay ordered! +/// setPointCount must be called first in order to set the total +/// number of points. The result is undefined if \a index is out +/// of the valid range. +/// +/// \param shape Shape object +/// \param index Index of the point to change, in range [0 .. GetPointCount() - 1] +/// \param point New point +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfConvexShape_setPoint(sfConvexShape* shape, unsigned int index, sfVector2f point); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a convex shape +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getLocalBounds(const sfConvexShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a convex shape +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// sprite in the global 2D world's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfConvexShape_getGlobalBounds(const sfConvexShape* shape); + + +#endif // SFML_CONVEXSHAPE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Export.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Export.h new file mode 100755 index 0000000..326e646 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Export.h @@ -0,0 +1,48 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_GRAPHICS_EXPORT_H +#define SFML_GRAPHICS_EXPORT_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Config.h> + + +//////////////////////////////////////////////////////////// +// Define portable import / export macros +//////////////////////////////////////////////////////////// +#if defined(CSFML_GRAPHICS_EXPORTS) + + #define CSFML_GRAPHICS_API CSFML_API_EXPORT + +#else + + #define CSFML_GRAPHICS_API CSFML_API_IMPORT + +#endif + + +#endif // SFML_GRAPHICS_EXPORT_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Font.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Font.h new file mode 100755 index 0000000..f8f3f25 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Font.h @@ -0,0 +1,136 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_FONT_H +#define SFML_FONT_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Glyph.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/InputStream.h> +#include <stddef.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new font from a file +/// +/// \param filename Path of the font file to load +/// +/// \return A new sfFont object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFont* sfFont_createFromFile(const char* filename); + +//////////////////////////////////////////////////////////// +/// \brief Create a new image font a file in memory +/// +/// \param data Pointer to the file data in memory +/// \param sizeInBytes Size of the data to load, in bytes +/// +/// \return A new sfFont object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFont* sfFont_createFromMemory(const void* data, size_t sizeInBytes); + +//////////////////////////////////////////////////////////// +/// \brief Create a new image font a custom stream +/// +/// \param stream Source stream to read from +/// +/// \return A new sfFont object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFont* sfFont_createFromStream(sfInputStream* stream); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing font +/// +/// \param font Font to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFont* sfFont_copy(const sfFont* font); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing font +/// +/// \param font Font to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfFont_destroy(sfFont* font); + +//////////////////////////////////////////////////////////// +/// \brief Get a glyph in a font +/// +/// \param font Source font +/// \param codePoint Unicode code point of the character to get +/// \param characterSize Character size, in pixels +/// \param bold Retrieve the bold version or the regular one? +/// +/// \return The corresponding glyph +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfGlyph sfFont_getGlyph(sfFont* font, sfUint32 codePoint, unsigned int characterSize, sfBool bold); + +//////////////////////////////////////////////////////////// +/// \brief Get the kerning value corresponding to a given pair of characters in a font +/// +/// \param font Source font +/// \param first Unicode code point of the first character +/// \param second Unicode code point of the second character +/// \param characterSize Character size, in pixels +/// +/// \return Kerning offset, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API int sfFont_getKerning(sfFont* font, sfUint32 first, sfUint32 second, unsigned int characterSize); + +//////////////////////////////////////////////////////////// +/// \brief Get the line spacing value +/// +/// \param font Source font +/// \param characterSize Character size, in pixels +/// +/// \return Line spacing, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API int sfFont_getLineSpacing(sfFont* font, unsigned int characterSize); + +//////////////////////////////////////////////////////////// +/// \brief Get the texture containing the glyphs of a given size in a font +/// +/// \param font Source font +/// \param characterSize Character size, in pixels +/// +/// \return Read-only pointer to the texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfFont_getTexture(sfFont* font, unsigned int characterSize); + + +#endif // SFML_IMAGE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Glyph.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Glyph.h new file mode 100755 index 0000000..a9b0ef7 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Glyph.h @@ -0,0 +1,46 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_GLYPH_H +#define SFML_GLYPH_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Rect.h> + + +//////////////////////////////////////////////////////////// +/// \brief sfGlyph describes a glyph (a visual character) +/// +//////////////////////////////////////////////////////////// +typedef struct +{ + int advance; ///< Offset to move horizontically to the next character + sfIntRect bounds; ///< Bounding rectangle of the glyph, in coordinates relative to the baseline + sfIntRect textureRect; ///< Texture coordinates of the glyph inside the font's image +} sfGlyph; + + +#endif // SFML_GLYPH_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Image.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Image.h new file mode 100755 index 0000000..4fbe801 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Image.h @@ -0,0 +1,274 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_IMAGE_H +#define SFML_IMAGE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/InputStream.h> +#include <SFML/System/Vector2.h> +#include <stddef.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create an image +/// +/// This image is filled with black pixels. +/// +/// \param width Width of the image +/// \param height Height of the image +/// +/// \return A new sfImage object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_create(unsigned int width, unsigned int height); + +//////////////////////////////////////////////////////////// +/// \brief Create an image and fill it with a unique color +/// +/// \param width Width of the image +/// \param height Height of the image +/// \param color Fill color +/// +/// \return A new sfImage object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_createFromColor(unsigned int width, unsigned int height, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Create an image from an array of pixels +/// +/// The \a pixel array is assumed to contain 32-bits RGBA pixels, +/// and have the given \a width and \a height. If not, this is +/// an undefined behaviour. +/// If \a pixels is null, an empty image is created. +/// +/// \param width Width of the image +/// \param height Height of the image +/// \param pixels Array of pixels to copy to the image +/// +/// \return A new sfImage object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_createFromPixels(unsigned int width, unsigned int height, const sfUint8* pixels); + +//////////////////////////////////////////////////////////// +/// \brief Create an image from a file on disk +/// +/// The supported image formats are bmp, png, tga, jpg, gif, +/// psd, hdr and pic. Some format options are not supported, +/// like progressive jpeg. +/// If this function fails, the image is left unchanged. +/// +/// \param filename Path of the image file to load +/// +/// \return A new sfImage object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_createFromFile(const char* filename); + +//////////////////////////////////////////////////////////// +/// \brief Create an image from a file in memory +/// +/// The supported image formats are bmp, png, tga, jpg, gif, +/// psd, hdr and pic. Some format options are not supported, +/// like progressive jpeg. +/// If this function fails, the image is left unchanged. +/// +/// \param data Pointer to the file data in memory +/// \param size Size of the data to load, in bytes +/// +/// \return A new sfImage object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_createFromMemory(const void* data, size_t size); + +//////////////////////////////////////////////////////////// +/// \brief Create an image from a custom stream +/// +/// The supported image formats are bmp, png, tga, jpg, gif, +/// psd, hdr and pic. Some format options are not supported, +/// like progressive jpeg. +/// If this function fails, the image is left unchanged. +/// +/// \param stream Source stream to read from +/// +/// \return A new sfImage object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_createFromStream(sfInputStream* stream); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing image +/// +/// \param image Image to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfImage_copy(const sfImage* image); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing image +/// +/// \param image Image to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_destroy(sfImage* image); + +//////////////////////////////////////////////////////////// +/// \brief Save an image to a file on disk +/// +/// The format of the image is automatically deduced from +/// the extension. The supported image formats are bmp, png, +/// tga and jpg. The destination file is overwritten +/// if it already exists. This function fails if the image is empty. +/// +/// \param image Image object +/// \param filename Path of the file to save +/// +/// \return sfTrue if saving was successful +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfImage_saveToFile(const sfImage* image, const char* filename); + +//////////////////////////////////////////////////////////// +/// \brief Return the size of an image +/// +/// \param image Image object +/// +/// \return Size in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2u sfImage_getSize(const sfImage* image); + +//////////////////////////////////////////////////////////// +/// \brief Create a transparency mask from a specified color-key +/// +/// This function sets the alpha value of every pixel matching +/// the given color to \a alpha (0 by default), so that they +/// become transparent. +/// +/// \param image Image object +/// \param color Color to make transparent +/// \param alpha Alpha value to assign to transparent pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_createMaskFromColor(sfImage* image, sfColor color, sfUint8 alpha); + +//////////////////////////////////////////////////////////// +/// \brief Copy pixels from an image onto another +/// +/// This function does a slow pixel copy and should not be +/// used intensively. It can be used to prepare a complex +/// static image from several others, but if you need this +/// kind of feature in real-time you'd better use sfRenderTexture. +/// +/// If \a sourceRect is empty, the whole image is copied. +/// If \a applyAlpha is set to true, the transparency of +/// source pixels is applied. If it is false, the pixels are +/// copied unchanged with their alpha value. +/// +/// \param image Image object +/// \param source Source image to copy +/// \param destX X coordinate of the destination position +/// \param destY Y coordinate of the destination position +/// \param sourceRect Sub-rectangle of the source image to copy +/// \param applyAlpha Should the copy take in account the source transparency? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_copyImage(sfImage* image, const sfImage* source, unsigned int destX, unsigned int destY, sfIntRect sourceRect, sfBool applyAlpha); + +//////////////////////////////////////////////////////////// +/// \brief Change the color of a pixel in an image +/// +/// This function doesn't check the validity of the pixel +/// coordinates, using out-of-range values will result in +/// an undefined behaviour. +/// +/// \param image Image object +/// \param x X coordinate of pixel to change +/// \param y Y coordinate of pixel to change +/// \param color New color of the pixel +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_setPixel(sfImage* image, unsigned int x, unsigned int y, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Get the color of a pixel in an image +/// +/// This function doesn't check the validity of the pixel +/// coordinates, using out-of-range values will result in +/// an undefined behaviour. +/// +/// \param image Image object +/// \param x X coordinate of pixel to get +/// \param y Y coordinate of pixel to get +/// +/// \return Color of the pixel at coordinates (x, y) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfImage_getPixel(const sfImage* image, unsigned int x, unsigned int y); + +//////////////////////////////////////////////////////////// +/// \brief Get a read-only pointer to the array of pixels of an image +/// +/// The returned value points to an array of RGBA pixels made of +/// 8 bits integers components. The size of the array is +/// getWidth() * getHeight() * 4. +/// Warning: the returned pointer may become invalid if you +/// modify the image, so you should never store it for too long. +/// If the image is empty, a null pointer is returned. +/// +/// \param image Image object +/// +/// \return Read-only pointer to the array of pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfUint8* sfImage_getPixelsPtr(const sfImage* image); + +//////////////////////////////////////////////////////////// +/// \brief Flip an image horizontally (left <-> right) +/// +/// \param image Image object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_flipHorizontally(sfImage* image); + +//////////////////////////////////////////////////////////// +/// \brief Flip an image vertically (top <-> bottom) +/// +/// \param image Image object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfImage_flipVertically(sfImage* image); + + +#endif // SFML_IMAGE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/PrimitiveType.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/PrimitiveType.h new file mode 100755 index 0000000..2f25ff4 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/PrimitiveType.h @@ -0,0 +1,54 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_PRIMITIVETYPE_H +#define SFML_PRIMITIVETYPE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> + + +//////////////////////////////////////////////////////////// +/// \brief Types of primitives that a sf::VertexArray can render +/// +/// Points and lines have no area, therefore their thickness +/// will always be 1 pixel, regardless the current transform +/// and view. +/// +//////////////////////////////////////////////////////////// +typedef enum +{ + sfPoints, ///< List of individual points + sfLines, ///< List of individual lines + sfLinesStrip, ///< List of connected lines, a point uses the previous point to form a line + sfTriangles, ///< List of individual triangles + sfTrianglesStrip, ///< List of connected triangles, a point uses the two previous points to form a triangle + sfTrianglesFan, ///< List of connected triangles, a point uses the common center and the previous point to form a triangle + sfQuads ///< List of individual quads +} sfPrimitiveType; + + +#endif // SFML_BLENDMODE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Rect.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Rect.h new file mode 100755 index 0000000..eeef038 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Rect.h @@ -0,0 +1,81 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_RECT_H +#define SFML_RECT_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> + + +//////////////////////////////////////////////////////////// +/// sfFloatRect and sfIntRect are utility classes for +/// manipulating rectangles. +//////////////////////////////////////////////////////////// +typedef struct +{ + float left; + float top; + float width; + float height; +} sfFloatRect; + +typedef struct +{ + int left; + int top; + int width; + int height; +} sfIntRect; + +//////////////////////////////////////////////////////////// +/// \brief Check if a point is inside a rectangle's area +/// +/// \param rect Rectangle to test +/// \param x X coordinate of the point to test +/// \param y Y coordinate of the point to test +/// +/// \return sfTrue if the point is inside +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfFloatRect_contains(const sfFloatRect* rect, float x, float y); +CSFML_GRAPHICS_API sfBool sfIntRect_contains(const sfIntRect* rect, int x, int y); + +//////////////////////////////////////////////////////////// +/// \brief Check intersection between two rectangles +/// +/// \param rect1 First rectangle to test +/// \param rect2 Second rectangle to test +/// \param intersection Rectangle to be filled with overlapping rect (can be NULL) +/// +/// \return sfTrue if rectangles overlap +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfFloatRect_intersects(const sfFloatRect* rect1, const sfFloatRect* rect2, sfFloatRect* intersection); +CSFML_GRAPHICS_API sfBool sfIntRect_intersects(const sfIntRect* rect1, const sfIntRect* rect2, sfIntRect* intersection); + + +#endif // SFML_RECT_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RectangleShape.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RectangleShape.h new file mode 100755 index 0000000..936399b --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RectangleShape.h @@ -0,0 +1,422 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_RECTANGLESHAPE_H +#define SFML_RECTANGLESHAPE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new rectangle shape +/// +/// \return A new sfRectangleShape object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRectangleShape* sfRectangleShape_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing rectangle shape +/// +/// \param shape Shape to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRectangleShape* sfRectangleShape_copy(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing rectangle shape +/// +/// \param Shape Shape to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_destroy(sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a rectangle shape +/// +/// This function completely overwrites the previous position. +/// See sfRectangleShape_move to apply an offset based on the previous position instead. +/// The default position of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setPosition(sfRectangleShape* shape, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a rectangle shape +/// +/// This function completely overwrites the previous rotation. +/// See sfRectangleShape_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a circle Shape object is 0. +/// +/// \param shape Shape object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setRotation(sfRectangleShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a rectangle shape +/// +/// This function completely overwrites the previous scale. +/// See sfRectangleShape_scale to add a factor based on the previous scale instead. +/// The default scale of a circle Shape object is (1, 1). +/// +/// \param shape Shape object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setScale(sfRectangleShape* shape, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a rectangle shape +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setOrigin(sfRectangleShape* shape, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getPosition(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a rectangle shape +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param shape Shape object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfRectangleShape_getRotation(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getScale(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getOrigin(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Move a rectangle shape by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfRectangleShape_setPosition which overwrites it. +/// +/// \param shape Shape object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_move(sfRectangleShape* shape, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a rectangle shape +/// +/// This function adds to the current rotation of the object, +/// unlike sfRectangleShape_setRotation which overwrites it. +/// +/// \param shape Shape object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_rotate(sfRectangleShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a rectangle shape +/// +/// This function multiplies the current scale of the object, +/// unlike sfRectangleShape_setScale which overwrites it. +/// +/// \param shape Shape object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_scale(sfRectangleShape* shape, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a rectangle shape +/// +/// \param shape shape object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfRectangleShape_getTransform(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a rectangle shape +/// +/// \param shape shape object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfRectangleShape_getInverseTransform(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Change the source texture of a rectangle shape +/// +/// The \a texture argument refers to a texture that must +/// exist as long as the shape uses it. Indeed, the shape +/// doesn't store its own copy of the texture, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the source texture is destroyed and the shape tries to +/// use it, the behaviour is undefined. +/// \a texture can be NULL to disable texturing. +/// If \a resetRect is true, the TextureRect property of +/// the shape is automatically adjusted to the size of the new +/// texture. If it is false, the texture rect is left unchanged. +/// +/// \param shape Shape object +/// \param texture New texture +/// \param resetRect Should the texture rect be reset to the size of the new texture? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setTexture(sfRectangleShape* shape, const sfTexture* texture, sfBool resetRect); + +//////////////////////////////////////////////////////////// +/// \brief Set the sub-rectangle of the texture that a rectangle shape will display +/// +/// The texture rect is useful when you don't want to display +/// the whole texture, but rather a part of it. +/// By default, the texture rect covers the entire texture. +/// +/// \param shape Shape object +/// \param rect Rectangle defining the region of the texture to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setTextureRect(sfRectangleShape* shape, sfIntRect rect); + +//////////////////////////////////////////////////////////// +/// \brief Set the fill color of a rectangle shape +/// +/// This color is modulated (multiplied) with the shape's +/// texture if any. It can be used to colorize the shape, +/// or change its global opacity. +/// You can use sfTransparent to make the inside of +/// the shape transparent, and have the outline alone. +/// By default, the shape's fill color is opaque white. +/// +/// \param shape Shape object +/// \param color New color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setFillColor(sfRectangleShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the outline color of a rectangle shape +/// +/// You can use sfTransparent to disable the outline. +/// By default, the shape's outline color is opaque white. +/// +/// \param shape Shape object +/// \param color New outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setOutlineColor(sfRectangleShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the thickness of a rectangle shape's outline +/// +/// This number cannot be negative. Using zero disables +/// the outline. +/// By default, the outline thickness is 0. +/// +/// \param shape Shape object +/// \param thickness New outline thickness +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setOutlineThickness(sfRectangleShape* shape, float thickness); + +//////////////////////////////////////////////////////////// +/// \brief Get the source texture of a rectangle shape +/// +/// If the shape has no source texture, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the texture when you retrieve it with this function. +/// +/// \param shape Shape object +/// +/// \return Pointer to the shape's texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfRectangleShape_getTexture(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the sub-rectangle of the texture displayed by a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Texture rectangle of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfRectangleShape_getTextureRect(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the fill color of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Fill color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfRectangleShape_getFillColor(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline color of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfRectangleShape_getOutlineColor(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline thickness of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Outline thickness of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfRectangleShape_getOutlineThickness(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the total number of points of a rectangle shape +/// +/// \param shape Shape object +/// +/// \return Number of points of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfRectangleShape_getPointCount(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get a point of a rectangle shape +/// +/// The result is undefined if \a index is out of the valid range. +/// +/// \param shape Shape object +/// \param index Index of the point to get, in range [0 .. getPointCount() - 1] +/// +/// \return Index-th point of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getPoint(const sfRectangleShape* shape, unsigned int index); + +//////////////////////////////////////////////////////////// +/// \brief Set the size of a rectangle shape +/// +/// \param shape Shape object +/// \param size New size of the rectangle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRectangleShape_setSize(sfRectangleShape* shape, sfVector2f size); + +//////////////////////////////////////////////////////////// +/// \brief Get the size of a rectangle shape +/// +/// \param shape Shape object +// +/// \return height Size of the rectangle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRectangleShape_getSize(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a rectangle shape +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getLocalBounds(const sfRectangleShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a rectangle shape +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// sprite in the global 2D world's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfRectangleShape_getGlobalBounds(const sfRectangleShape* shape); + + +#endif // SFML_RECTANGLESHAPE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderStates.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderStates.h new file mode 100755 index 0000000..86c2258 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderStates.h @@ -0,0 +1,50 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_RENDERSTATES_H +#define SFML_RENDERSTATES_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/BlendMode.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> + + +//////////////////////////////////////////////////////////// +/// \brief Define the states used for drawing to a RenderTarget +/// +//////////////////////////////////////////////////////////// +typedef struct +{ + sfBlendMode blendMode; ///< Blending mode + sfTransform transform; ///< Transform + const sfTexture* texture; ///< Texture + const sfShader* shader; ///< Shader +} sfRenderStates; + + +#endif // SFML_RENDERSTATES_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderTexture.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderTexture.h new file mode 100755 index 0000000..959f4d5 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderTexture.h @@ -0,0 +1,318 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_RENDERTEXTURE_H +#define SFML_RENDERTEXTURE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Graphics/PrimitiveType.h> +#include <SFML/Graphics/RenderStates.h> +#include <SFML/Graphics/Vertex.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Construct a new render texture +/// +/// \param width Width of the render texture +/// \param height Height of the render texture +/// \param depthBuffer Do you want a depth-buffer attached? (useful only if you're doing 3D OpenGL on the rendertexture) +/// +/// \return A new sfRenderTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRenderTexture* sfRenderTexture_create(unsigned int width, unsigned int height, sfBool depthBuffer); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing render texture +/// +/// \param renderTexture Render texture to destroy +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_destroy(sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Get the size of the rendering region of a render texture +/// +/// \param renderTexture Render texture object +/// +/// \return Size in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2u sfRenderTexture_getSize(const sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Activate or deactivate a render texture as the current target for rendering +/// +/// \param renderTexture Render texture object +/// \param active sfTrue to activate, sfFalse to deactivate +/// +/// \return True if operation was successful, false otherwise +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active); + +//////////////////////////////////////////////////////////// +/// \brief Update the contents of the target texture +/// +/// \param renderTexture Render texture object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_display(sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Clear the rendertexture with the given color +/// +/// \param renderTexture Render texture object +/// \param color Fill color +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_clear(sfRenderTexture* renderTexture, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Change the current active view of a render texture +/// +/// \param renderTexture Render texture object +/// \param view Pointer to the new view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_setView(sfRenderTexture* renderTexture, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Get the current active view of a render texture +/// +/// \param renderTexture Render texture object +/// +/// \return Current active view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfView* sfRenderTexture_getView(const sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Get the default view of a render texture +/// +/// \param renderTexture Render texture object +/// +/// \return Default view of the rendertexture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfView* sfRenderTexture_getDefaultView(const sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Get the viewport of a view applied to this target +/// +/// \param renderTexture Render texture object +/// \param view Target view +/// +/// \return Viewport rectangle, expressed in pixels in the current target +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfRenderTexture_getViewport(const sfRenderTexture* renderTexture, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Convert a point from texture coordinates to world coordinates +/// +/// This function finds the 2D position that matches the +/// given pixel of the render-texture. In other words, it does +/// the inverse of what the graphics card does, to find the +/// initial position of a rendered pixel. +/// +/// Initially, both coordinate systems (world units and target pixels) +/// match perfectly. But if you define a custom view or resize your +/// render-texture, this assertion is not true anymore, ie. a point +/// located at (10, 50) in your render-texture may map to the point +/// (150, 75) in your 2D world -- if the view is translated by (140, 25). +/// +/// This version uses a custom view for calculations, see the other +/// overload of the function if you want to use the current view of the +/// render-texture. +/// +/// \param renderTexture Render texture object +/// \param point Pixel to convert +/// \param view The view to use for converting the point +/// +/// \return The converted point, in "world" units +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRenderTexture_mapPixelToCoords(const sfRenderTexture* renderTexture, sfVector2i point, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Convert a point from world coordinates to texture coordinates +/// +/// This function finds the pixel of the render-texture that matches +/// the given 2D point. In other words, it goes through the same process +/// as the graphics card, to compute the final position of a rendered point. +/// +/// Initially, both coordinate systems (world units and target pixels) +/// match perfectly. But if you define a custom view or resize your +/// render-texture, this assertion is not true anymore, ie. a point +/// located at (150, 75) in your 2D world may map to the pixel +/// (10, 50) of your render-texture -- if the view is translated by (140, 25). +/// +/// This version uses a custom view for calculations, see the other +/// overload of the function if you want to use the current view of the +/// render-texture. +/// +/// \param renderTexture Render texture object +/// \param point Point to convert +/// \param view The view to use for converting the point +/// +/// \return The converted point, in target coordinates (pixels) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2i sfRenderTexture_mapCoordsToPixel(const sfRenderTexture* renderTexture, sfVector2f point, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Draw a drawable object to the render-target +/// +/// \param renderTexture Render texture object +/// \param object Object to draw +/// \param states Render states to use for drawing (NULL to use the default states) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const sfSprite* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const sfText* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const sfShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const sfCircleShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const sfConvexShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const sfRectangleShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const sfVertexArray* object, const sfRenderStates* states); + +//////////////////////////////////////////////////////////// +/// \brief Draw primitives defined by an array of vertices to a render texture +/// +/// \param renderTexture Render texture object +/// \param vertices Pointer to the vertices +/// \param vertexCount Number of vertices in the array +/// \param type Type of primitives to draw +/// \param states Render states to use for drawing (NULL to use the default states) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture, + const sfVertex* vertices, unsigned int vertexCount, + sfPrimitiveType type, const sfRenderStates* states); + +//////////////////////////////////////////////////////////// +/// \brief Save the current OpenGL render states and matrices +/// +/// This function can be used when you mix SFML drawing +/// and direct OpenGL rendering. Combined with popGLStates, +/// it ensures that: +/// \li SFML's internal states are not messed up by your OpenGL code +/// \li your OpenGL states are not modified by a call to a SFML function +/// +/// Note that this function is quite expensive: it saves all the +/// possible OpenGL states and matrices, even the ones you +/// don't care about. Therefore it should be used wisely. +/// It is provided for convenience, but the best results will +/// be achieved if you handle OpenGL states yourself (because +/// you know which states have really changed, and need to be +/// saved and restored). Take a look at the resetGLStates +/// function if you do so. +/// +/// \param renderTexture Render texture object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_pushGLStates(sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Restore the previously saved OpenGL render states and matrices +/// +/// See the description of pushGLStates to get a detailed +/// description of these functions. +/// +/// \param renderTexture Render texture object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_popGLStates(sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Reset the internal OpenGL states so that the target is ready for drawing +/// +/// This function can be used when you mix SFML drawing +/// and direct OpenGL rendering, if you choose not to use +/// pushGLStates/popGLStates. It makes sure that all OpenGL +/// states needed by SFML are set, so that subsequent sfRenderTexture_draw*() +/// calls will work as expected. +/// +/// \param renderTexture Render texture object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_resetGLStates(sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Get the target texture of a render texture +/// +/// \param renderTexture Render texture object +/// +/// \return Pointer to the target texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfRenderTexture_getTexture(const sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Enable or disable the smooth filter on a render texture +/// +/// \param renderTexture Render texture object +/// \param smooth sfTrue to enable smoothing, sfFalse to disable it +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether the smooth filter is enabled or not for a render texture +/// +/// \param renderTexture Render texture object +/// +/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderTexture_isSmooth(const sfRenderTexture* renderTexture); + +//////////////////////////////////////////////////////////// +/// \brief Enable or disable texture repeating +/// +/// \param renderTexture Render texture object +/// \param repeated sfTrue to enable repeating, sfFalse to disable it +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderTexture_setRepeated(sfRenderTexture* renderTexture, sfBool repeated); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether the texture is repeated or not +/// +/// \param renderTexture Render texture object +/// +/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderTexture_isRepeated(const sfRenderTexture* renderTexture); + +#endif // SFML_RENDERTEXTURE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderWindow.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderWindow.h new file mode 100755 index 0000000..584ca02 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/RenderWindow.h @@ -0,0 +1,513 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_RENDERWINDOW_H +#define SFML_RENDERWINDOW_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Graphics/PrimitiveType.h> +#include <SFML/Graphics/RenderStates.h> +#include <SFML/Graphics/Vertex.h> +#include <SFML/Window/Event.h> +#include <SFML/Window/VideoMode.h> +#include <SFML/Window/WindowHandle.h> +#include <SFML/Window/Window.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Construct a new render window +/// +/// \param mode Video mode to use +/// \param title Title of the window +/// \param style Window style +/// \param settings Creation settings (pass NULL to use default values) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const char* title, sfUint32 style, const sfContextSettings* settings); + +//////////////////////////////////////////////////////////// +/// \brief Construct a new render window (with a UTF-32 title) +/// +/// \param mode Video mode to use +/// \param title Title of the window (UTF-32) +/// \param style Window style +/// \param settings Creation settings (pass NULL to use default values) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const sfUint32* title, sfUint32 style, const sfContextSettings* settings); + +//////////////////////////////////////////////////////////// +/// \brief Construct a render window from an existing control +/// +/// \param handle Platform-specific handle of the control +/// \param settings Creation settings (pass NULL to use default values) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfRenderWindow* sfRenderWindow_createFromHandle(sfWindowHandle handle, const sfContextSettings* settings); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing render window +/// +/// \param renderWindow Render window to destroy +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_destroy(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Close a render window (but doesn't destroy the internal data) +/// +/// \param renderWindow Render window to close +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_close(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether or not a render window is opened +/// +/// \param renderWindow Render window object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderWindow_isOpen(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Get the creation settings of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Settings used to create the window +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfContextSettings sfRenderWindow_getSettings(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Get the event on top of event queue of a render window, if any, and pop it +/// +/// \param renderWindow Render window object +/// \param event Event to fill, if any +/// +/// \return sfTrue if an event was returned, sfFalse if event queue was empty +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderWindow_pollEvent(sfRenderWindow* renderWindow, sfEvent* event); + +//////////////////////////////////////////////////////////// +/// \brief Wait for an event and return it +/// +/// \param renderWindow Render window object +/// \param event Event to fill +/// +/// \return sfFalse if an error occured +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderWindow_waitEvent(sfRenderWindow* renderWindow, sfEvent* event); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Position in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2i sfRenderWindow_getPosition(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Change the position of a render window on screen +/// +/// Only works for top-level windows +/// +/// \param renderWindow Render window object +/// \param position New position, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setPosition(sfRenderWindow* renderWindow, sfVector2i position); + +//////////////////////////////////////////////////////////// +/// \brief Get the size of the rendering region of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Size in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2u sfRenderWindow_getSize(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Change the size of the rendering region of a render window +/// +/// \param renderWindow Render window object +/// \param size New size, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setSize(sfRenderWindow* renderWindow, sfVector2u size); + +//////////////////////////////////////////////////////////// +/// \brief Change the title of a render window +/// +/// \param renderWindow Render window object +/// \param title New title +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setTitle(sfRenderWindow* renderWindow, const char* title); + +//////////////////////////////////////////////////////////// +/// \brief Change the title of a render window (with a UTF-32 string) +/// +/// \param renderWindow Render window object +/// \param title New title +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setUnicodeTitle(sfRenderWindow* renderWindow, const sfUint32* title); + +//////////////////////////////////////////////////////////// +/// \brief Change a render window's icon +/// +/// \param renderWindow Render window object +/// \param width Icon's width, in pixels +/// \param height Icon's height, in pixels +/// \param pixels Pointer to the pixels in memory, format must be RGBA 32 bits +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setIcon(sfRenderWindow* renderWindow, unsigned int width, unsigned int height, const sfUint8* pixels); + +//////////////////////////////////////////////////////////// +/// \brief Show or hide a render window +/// +/// \param renderWindow Render window object +/// \param visible sfTrue to show the window, sfFalse to hide it +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setVisible(sfRenderWindow* renderWindow, sfBool visible); + +//////////////////////////////////////////////////////////// +/// \brief Show or hide the mouse cursor on a render window +/// +/// \param renderWindow Render window object +/// \param show sfTrue to show, sfFalse to hide +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* renderWindow, sfBool show); + +//////////////////////////////////////////////////////////// +/// \brief Enable / disable vertical synchronization on a render window +/// +/// \param renderWindow Render window object +/// \param enabled sfTrue to enable v-sync, sfFalse to deactivate +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* renderWindow, sfBool enabled); + +//////////////////////////////////////////////////////////// +/// \brief Enable or disable automatic key-repeat for keydown events +/// +/// Automatic key-repeat is enabled by default +/// +/// \param renderWindow Render window object +/// \param enabled sfTrue to enable, sfFalse to disable +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* renderWindow, sfBool enabled); + +//////////////////////////////////////////////////////////// +/// \brief Activate or deactivate a render window as the current target for rendering +/// +/// \param renderWindow Render window object +/// \param active sfTrue to activate, sfFalse to deactivate +/// +/// \return True if operation was successful, false otherwise +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfRenderWindow_setActive(sfRenderWindow* renderWindow, sfBool active); + +//////////////////////////////////////////////////////////// +/// \brief Display a render window on screen +/// +/// \param renderWindow Render window object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_display(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Limit the framerate to a maximum fixed frequency for a render window +/// +/// \param renderWindow Render window object +/// \param limit Framerate limit, in frames per seconds (use 0 to disable limit) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setFramerateLimit(sfRenderWindow* renderWindow, unsigned int limit); + +//////////////////////////////////////////////////////////// +/// \brief Change the joystick threshold, ie. the value below which no move event will be generated +/// +/// \param renderWindow Render window object +/// \param threshold New threshold, in range [0, 100] +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setJoystickThreshold(sfRenderWindow* renderWindow, float threshold); + +//////////////////////////////////////////////////////////// +/// \brief Retrieve the OS-specific handle of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Window handle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfWindowHandle sfRenderWindow_getSystemHandle(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Clear a render window with the given color +/// +/// \param renderWindow Render window object +/// \param color Fill color +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_clear(sfRenderWindow* renderWindow, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Change the current active view of a render window +/// +/// \param renderWindow Render window object +/// \param view Pointer to the new view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_setView(sfRenderWindow* renderWindow, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Get the current active view of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Current active view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfView* sfRenderWindow_getView(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Get the default view of a render window +/// +/// \param renderWindow Render window object +/// +/// \return Default view of the render window +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfView* sfRenderWindow_getDefaultView(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Get the viewport of a view applied to this target +/// +/// \param renderWindow Render window object +/// \param view Target view +/// +/// \return Viewport rectangle, expressed in pixels in the current target +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfRenderWindow_getViewport(const sfRenderWindow* renderWindow, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Convert a point from window coordinates to world coordinates +/// +/// This function finds the 2D position that matches the +/// given pixel of the render-window. In other words, it does +/// the inverse of what the graphics card does, to find the +/// initial position of a rendered pixel. +/// +/// Initially, both coordinate systems (world units and target pixels) +/// match perfectly. But if you define a custom view or resize your +/// render-window, this assertion is not true anymore, ie. a point +/// located at (10, 50) in your render-window may map to the point +/// (150, 75) in your 2D world -- if the view is translated by (140, 25). +/// +/// This function is typically used to find which point (or object) is +/// located below the mouse cursor. +/// +/// This version uses a custom view for calculations, see the other +/// overload of the function if you want to use the current view of the +/// render-window. +/// +/// \param renderWindow Render window object +/// \param point Pixel to convert +/// \param view The view to use for converting the point +/// +/// \return The converted point, in "world" units +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfRenderWindow_mapPixelToCoords(const sfRenderWindow* renderWindow, sfVector2i point, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Convert a point from world coordinates to window coordinates +/// +/// This function finds the pixel of the render-window that matches +/// the given 2D point. In other words, it goes through the same process +/// as the graphics card, to compute the final position of a rendered point. +/// +/// Initially, both coordinate systems (world units and target pixels) +/// match perfectly. But if you define a custom view or resize your +/// render-window, this assertion is not true anymore, ie. a point +/// located at (150, 75) in your 2D world may map to the pixel +/// (10, 50) of your render-window -- if the view is translated by (140, 25). +/// +/// This version uses a custom view for calculations, see the other +/// overload of the function if you want to use the current view of the +/// render-window. +/// +/// \param renderWindow Render window object +/// \param point Point to convert +/// \param view The view to use for converting the point +/// +/// \return The converted point, in target coordinates (pixels) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2i sfRenderWindow_mapCoordsToPixel(const sfRenderWindow* renderWindow, sfVector2f point, const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Draw a drawable object to the render-target +/// +/// \param renderWindow render window object +/// \param object Object to draw +/// \param states Render states to use for drawing (NULL to use the default states) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const sfSprite* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawText(sfRenderWindow* renderWindow, const sfText* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawShape(sfRenderWindow* renderWindow, const sfShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const sfCircleShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const sfConvexShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const sfRectangleShape* object, const sfRenderStates* states); +CSFML_GRAPHICS_API void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const sfVertexArray* object, const sfRenderStates* states); + +//////////////////////////////////////////////////////////// +/// \brief Draw primitives defined by an array of vertices to a render window +/// +/// \param renderWindow render window object +/// \param vertices Pointer to the vertices +/// \param vertexCount Number of vertices in the array +/// \param type Type of primitives to draw +/// \param states Render states to use for drawing (NULL to use the default states) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow, + const sfVertex* vertices, unsigned int vertexCount, + sfPrimitiveType type, const sfRenderStates* states); + +//////////////////////////////////////////////////////////// +/// \brief Save the current OpenGL render states and matrices +/// +/// This function can be used when you mix SFML drawing +/// and direct OpenGL rendering. Combined with popGLStates, +/// it ensures that: +/// \li SFML's internal states are not messed up by your OpenGL code +/// \li your OpenGL states are not modified by a call to a SFML function +/// +/// Note that this function is quite expensive: it saves all the +/// possible OpenGL states and matrices, even the ones you +/// don't care about. Therefore it should be used wisely. +/// It is provided for convenience, but the best results will +/// be achieved if you handle OpenGL states yourself (because +/// you know which states have really changed, and need to be +/// saved and restored). Take a look at the resetGLStates +/// function if you do so. +/// +/// \param renderWindow render window object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_pushGLStates(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Restore the previously saved OpenGL render states and matrices +/// +/// See the description of pushGLStates to get a detailed +/// description of these functions. +/// +/// \param renderWindow render window object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_popGLStates(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Reset the internal OpenGL states so that the target is ready for drawing +/// +/// This function can be used when you mix SFML drawing +/// and direct OpenGL rendering, if you choose not to use +/// pushGLStates/popGLStates. It makes sure that all OpenGL +/// states needed by SFML are set, so that subsequent sfRenderWindow_draw*() +/// calls will work as expected. +/// +/// \param renderWindow render window object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfRenderWindow_resetGLStates(sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Copy the current contents of a render window to an image +/// +/// This is a slow operation, whose main purpose is to make +/// screenshots of the application. If you want to update an +/// image with the contents of the window and then use it for +/// drawing, you should rather use a sfTexture and its +/// update(sfWindow*) function. +/// You can also draw things directly to a texture with the +/// sfRenderWindow class. +/// +/// \param renderWindow Render window object +/// +/// \return New image containing the captured contents +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfRenderWindow_capture(const sfRenderWindow* renderWindow); + +//////////////////////////////////////////////////////////// +/// \brief Get the current position of the mouse relatively to a render-window +/// +/// This function returns the current position of the mouse +/// cursor relative to the given render-window, or desktop if NULL is passed. +/// +/// \param relativeTo Reference window +/// +/// \return Position of the mouse cursor, relative to the given render-window +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2i sfMouse_getPositionRenderWindow(const sfRenderWindow* relativeTo); + +//////////////////////////////////////////////////////////// +/// \brief Set the current position of the mouse relatively to a render-window +/// +/// This function sets the current position of the mouse +/// cursor relative to the given render-window, or desktop if NULL is passed. +/// +/// \param position New position of the mouse +/// \param relativeTo Reference window +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfMouse_setPositionRenderWindow(sfVector2i position, const sfRenderWindow* relativeTo); + + +#endif // SFML_RENDERWINDOW_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shader.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shader.h new file mode 100755 index 0000000..a2c86f0 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shader.h @@ -0,0 +1,388 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_SHADER_H +#define SFML_SHADER_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/InputStream.h> +#include <SFML/System/Vector2.h> +#include <SFML/System/Vector3.h> + + +//////////////////////////////////////////////////////////// +/// \brief Load both the vertex and fragment shaders from files +/// +/// This function can load both the vertex and the fragment +/// shaders, or only one of them: pass NULL if you don't want to load +/// either the vertex shader or the fragment shader. +/// The sources must be text files containing valid shaders +/// in GLSL language. GLSL is a C-like language dedicated to +/// OpenGL shaders; you'll probably need to read a good documentation +/// for it before writing your own shaders. +/// +/// \param vertexShaderFilename Path of the vertex shader file to load, or NULL to skip this shader +/// \param fragmentShaderFilename Path of the fragment shader file to load, or NULL to skip this shader +/// +/// \return A new sfShader object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfShader* sfShader_createFromFile(const char* vertexShaderFilename, const char* fragmentShaderFilename); + +//////////////////////////////////////////////////////////// +/// \brief Load both the vertex and fragment shaders from source codes in memory +/// +/// This function can load both the vertex and the fragment +/// shaders, or only one of them: pass NULL if you don't want to load +/// either the vertex shader or the fragment shader. +/// The sources must be valid shaders in GLSL language. GLSL is +/// a C-like language dedicated to OpenGL shaders; you'll +/// probably need to read a good documentation for it before +/// writing your own shaders. +/// +/// \param vertexShader String containing the source code of the vertex shader, or NULL to skip this shader +/// \param fragmentShader String containing the source code of the fragment shader, or NULL to skip this shader +/// +/// \return A new sfShader object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfShader* sfShader_createFromMemory(const char* vertexShader, const char* fragmentShader); + +//////////////////////////////////////////////////////////// +/// \brief Load both the vertex and fragment shaders from custom streams +/// +/// This function can load both the vertex and the fragment +/// shaders, or only one of them: pass NULL if you don't want to load +/// either the vertex shader or the fragment shader. +/// The source codes must be valid shaders in GLSL language. +/// GLSL is a C-like language dedicated to OpenGL shaders; +/// you'll probably need to read a good documentation for +/// it before writing your own shaders. +/// +/// \param vertexShaderStream Source stream to read the vertex shader from, or NULL to skip this shader +/// \param fragmentShaderStream Source stream to read the fragment shader from, or NULL to skip this shader +/// +/// \return A new sfShader object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* fragmentShaderStream); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing shader +/// +/// \param shader Shader to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_destroy(sfShader* shader); + +//////////////////////////////////////////////////////////// +/// \brief Change a float parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a float +/// (float GLSL type). +/// +/// Example: +/// \code +/// uniform float myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setFloatParameter(shader, "myparam", 5.2f); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param x Value to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setFloatParameter(sfShader* shader, const char* name, float x); + +//////////////////////////////////////////////////////////// +/// \brief Change a 2-components vector parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 2x1 vector +/// (vec2 GLSL type). +/// +/// Example: +/// \code +/// uniform vec2 myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setFloat2Parameter(shader, "myparam", 5.2f, 6.0f); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param x First component of the value to assign +/// \param y Second component of the value to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y); + +//////////////////////////////////////////////////////////// +/// \brief Change a 3-components vector parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 3x1 vector +/// (vec3 GLSL type). +/// +/// Example: +/// \code +/// uniform vec3 myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setFloat3Parameter(shader, "myparam", 5.2f, 6.0f, -8.1f); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param x First component of the value to assign +/// \param y Second component of the value to assign +/// \param z Third component of the value to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z); + +//////////////////////////////////////////////////////////// +/// \brief Change a 4-components vector parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 4x1 vector +/// (vec4 GLSL type). +/// +/// Example: +/// \code +/// uniform vec4 myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setFloat4Parameter(shader, "myparam", 5.2f, 6.0f, -8.1f, 0.4f); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param x First component of the value to assign +/// \param y Second component of the value to assign +/// \param z Third component of the value to assign +/// \param w Fourth component of the value to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w); + +//////////////////////////////////////////////////////////// +/// \brief Change a 2-components vector parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 2x1 vector +/// (vec2 GLSL type). +/// +/// Example: +/// \code +/// uniform vec2 myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfVector2f vec = {5.2f, 6.0f}; +/// sfShader_setVector2Parameter(shader, "myparam", vec); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param vector Vector to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector); + +//////////////////////////////////////////////////////////// +/// \brief Change a 3-components vector parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 3x1 vector +/// (vec3 GLSL type). +/// +/// Example: +/// \code +/// uniform vec3 myparam; // this is the variable in the shader +/// \endcode +/// \code +/// sfVector3f vec = {5.2f, 6.0f, -8.1f}; +/// sfShader_setVector3Parameter(shader, "myparam", vec); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param vector Vector to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector); + +//////////////////////////////////////////////////////////// +/// \brief Change a color parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 4x1 vector +/// (vec4 GLSL type). +/// +/// It is important to note that the components of the color are +/// normalized before being passed to the shader. Therefore, +/// they are converted from range [0 .. 255] to range [0 .. 1]. +/// For example, a sf::Color(255, 125, 0, 255) will be transformed +/// to a vec4(1.0, 0.5, 0.0, 1.0) in the shader. +/// +/// Example: +/// \code +/// uniform vec4 color; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setColorParameter(shader, "color", sfColor_fromRGB(255, 128, 0)); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param color Color to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Change a matrix parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 4x4 matrix +/// (mat4 GLSL type). +/// +/// Example: +/// \code +/// uniform mat4 matrix; // this is the variable in the shader +/// \endcode +/// \code +/// @todo +/// sfShader_setTransformParameter(shader, "matrix", transform); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the parameter in the shader +/// \param transform Transform to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform); + +//////////////////////////////////////////////////////////// +/// \brief Change a texture parameter of a shader +/// +/// \a name is the name of the variable to change in the shader. +/// The corresponding parameter in the shader must be a 2D texture +/// (sampler2D GLSL type). +/// +/// Example: +/// \code +/// uniform sampler2D the_texture; // this is the variable in the shader +/// \endcode +/// \code +/// sf::Texture texture; +/// ... +/// sfShader_setTextureParameter(shader, "the_texture", texture); +/// \endcode +/// It is important to note that \a texture must remain alive as long +/// as the shader uses it, no copy is made internally. +/// +/// To use the texture of the object being draw, which cannot be +/// known in advance, you can use the special function +/// sfShader_setCurrentTextureParameter: +/// \code +/// sfShader_setCurrentTextureParameter(shader, "the_texture"). +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the texture in the shader +/// \param texture Texture to assign +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Change a texture parameter of a shader +/// +/// This function maps a shader texture variable to the +/// texture of the object being drawn, which cannot be +/// known in advance. +/// The corresponding parameter in the shader must be a 2D texture +/// (sampler2D GLSL type). +/// +/// Example: +/// \code +/// uniform sampler2D current; // this is the variable in the shader +/// \endcode +/// \code +/// sfShader_setCurrentTextureParameter(shader, "current"); +/// \endcode +/// +/// \param shader Shader object +/// \param name Name of the texture in the shader +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name); + +//////////////////////////////////////////////////////////// +/// \brief Bind a shader for rendering (activate it) +/// +/// This function is not part of the graphics API, it mustn't be +/// used when drawing SFML entities. It must be used only if you +/// mix sfShader with OpenGL code. +/// +/// \code +/// sfShader *s1, *s2; +/// ... +/// sfShader_bind(s1); +/// // draw OpenGL stuff that use s1... +/// sfShader_bind(s2); +/// // draw OpenGL stuff that use s2... +/// sfShader_bind(0); +/// // draw OpenGL stuff that use no shader... +/// \endcode +/// +/// \param shader Shader to bind, can be null to use no shader +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShader_bind(const sfShader* shader); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether or not the system supports shaders +/// +/// This function should always be called before using +/// the shader features. If it returns false, then +/// any attempt to use sfShader will fail. +/// +/// \return sfTrue if the system can use shaders, sfFalse otherwise +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfShader_isAvailable(void); + + +#endif // SFML_SHADER_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shape.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shape.h new file mode 100755 index 0000000..dc6254a --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Shape.h @@ -0,0 +1,412 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_SHAPE_H +#define SFML_SHAPE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +typedef unsigned int (*sfShapeGetPointCountCallback)(void*); ///< Type of the callback used to get the number of points in a shape +typedef sfVector2f (*sfShapeGetPointCallback)(unsigned int, void*); ///< Type of the callback used to get a point of a shape + +//////////////////////////////////////////////////////////// +/// \brief Create a new shape +/// +/// \param getPointCount Callback that provides the point count of the shape +/// \param getPoint Callback that provides the points of the shape +/// \param userData Data to pass to the callback functions +/// +/// \return A new sfShape object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfShape* sfShape_create(sfShapeGetPointCountCallback getPointCount, + sfShapeGetPointCallback getPoint, + void* userData); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing shape +/// +/// \param Shape Shape to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_destroy(sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a shape +/// +/// This function completely overwrites the previous position. +/// See sfShape_move to apply an offset based on the previous position instead. +/// The default position of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setPosition(sfShape* shape, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a shape +/// +/// This function completely overwrites the previous rotation. +/// See sfShape_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a circle Shape object is 0. +/// +/// \param shape Shape object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setRotation(sfShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a shape +/// +/// This function completely overwrites the previous scale. +/// See sfShape_scale to add a factor based on the previous scale instead. +/// The default scale of a circle Shape object is (1, 1). +/// +/// \param shape Shape object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setScale(sfShape* shape, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a shape +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a circle Shape object is (0, 0). +/// +/// \param shape Shape object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setOrigin(sfShape* shape, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a shape +/// +/// \param shape Shape object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfShape_getPosition(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a shape +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param shape Shape object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfShape_getRotation(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a shape +/// +/// \param shape Shape object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfShape_getScale(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a shape +/// +/// \param shape Shape object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfShape_getOrigin(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Move a shape by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfShape_setPosition which overwrites it. +/// +/// \param shape Shape object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_move(sfShape* shape, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a shape +/// +/// This function adds to the current rotation of the object, +/// unlike sfShape_setRotation which overwrites it. +/// +/// \param shape Shape object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_rotate(sfShape* shape, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a shape +/// +/// This function multiplies the current scale of the object, +/// unlike sfShape_setScale which overwrites it. +/// +/// \param shape Shape object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_scale(sfShape* shape, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a shape +/// +/// \param shape shape object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfShape_getTransform(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a shape +/// +/// \param shape shape object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfShape_getInverseTransform(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Change the source texture of a shape +/// +/// The \a texture argument refers to a texture that must +/// exist as long as the shape uses it. Indeed, the shape +/// doesn't store its own copy of the texture, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the source texture is destroyed and the shape tries to +/// use it, the behaviour is undefined. +/// \a texture can be NULL to disable texturing. +/// If \a resetRect is true, the TextureRect property of +/// the shape is automatically adjusted to the size of the new +/// texture. If it is false, the texture rect is left unchanged. +/// +/// \param shape Shape object +/// \param texture New texture +/// \param resetRect Should the texture rect be reset to the size of the new texture? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setTexture(sfShape* shape, const sfTexture* texture, sfBool resetRect); + +//////////////////////////////////////////////////////////// +/// \brief Set the sub-rectangle of the texture that a shape will display +/// +/// The texture rect is useful when you don't want to display +/// the whole texture, but rather a part of it. +/// By default, the texture rect covers the entire texture. +/// +/// \param shape Shape object +/// \param rect Rectangle defining the region of the texture to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setTextureRect(sfShape* shape, sfIntRect rect); + +//////////////////////////////////////////////////////////// +/// \brief Set the fill color of a shape +/// +/// This color is modulated (multiplied) with the shape's +/// texture if any. It can be used to colorize the shape, +/// or change its global opacity. +/// You can use sfTransparent to make the inside of +/// the shape transparent, and have the outline alone. +/// By default, the shape's fill color is opaque white. +/// +/// \param shape Shape object +/// \param color New color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setFillColor(sfShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the outline color of a shape +/// +/// You can use sfTransparent to disable the outline. +/// By default, the shape's outline color is opaque white. +/// +/// \param shape Shape object +/// \param color New outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setOutlineColor(sfShape* shape, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Set the thickness of a shape's outline +/// +/// This number cannot be negative. Using zero disables +/// the outline. +/// By default, the outline thickness is 0. +/// +/// \param shape Shape object +/// \param thickness New outline thickness +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_setOutlineThickness(sfShape* shape, float thickness); + +//////////////////////////////////////////////////////////// +/// \brief Get the source texture of a shape +/// +/// If the shape has no source texture, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the texture when you retrieve it with this function. +/// +/// \param shape Shape object +/// +/// \return Pointer to the shape's texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfShape_getTexture(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the sub-rectangle of the texture displayed by a shape +/// +/// \param shape Shape object +/// +/// \return Texture rectangle of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfShape_getTextureRect(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the fill color of a shape +/// +/// \param shape Shape object +/// +/// \return Fill color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfShape_getFillColor(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline color of a shape +/// +/// \param shape Shape object +/// +/// \return Outline color of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfShape_getOutlineColor(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the outline thickness of a shape +/// +/// \param shape Shape object +/// +/// \return Outline thickness of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfShape_getOutlineThickness(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the total number of points of a shape +/// +/// \param shape Shape object +/// +/// \return Number of points of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfShape_getPointCount(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get a point of a shape +/// +/// The result is undefined if \a index is out of the valid range. +/// +/// \param shape Shape object +/// \param index Index of the point to get, in range [0 .. getPointCount() - 1] +/// +/// \return Index-th point of the shape +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfShape_getPoint(const sfShape* shape, unsigned int index); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a shape +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfShape_getLocalBounds(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a shape +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// sprite in the global 2D world's coordinate system. +/// +/// \param shape Shape object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfShape_getGlobalBounds(const sfShape* shape); + +//////////////////////////////////////////////////////////// +/// \brief Recompute the internal geometry of a shape +/// +/// This function must be called by specialized shape objects +/// everytime their points change (ie. the result of either +/// the getPointCount or getPoint callbacks is different). +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfShape_update(sfShape* shape); + + +#endif // SFML_SHAPE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Sprite.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Sprite.h new file mode 100755 index 0000000..40ebf37 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Sprite.h @@ -0,0 +1,333 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_SPRITE_H +#define SFML_SPRITE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/BlendMode.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new sprite +/// +/// \return A new sfSprite object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfSprite* sfSprite_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing sprite +/// +/// \param sprite Sprite to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfSprite* sfSprite_copy(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing sprite +/// +/// \param sprite Sprite to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_destroy(sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a sprite +/// +/// This function completely overwrites the previous position. +/// See sfSprite_move to apply an offset based on the previous position instead. +/// The default position of a sprite Sprite object is (0, 0). +/// +/// \param sprite Sprite object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setPosition(sfSprite* sprite, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a sprite +/// +/// This function completely overwrites the previous rotation. +/// See sfSprite_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a sprite Sprite object is 0. +/// +/// \param sprite Sprite object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setRotation(sfSprite* sprite, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a sprite +/// +/// This function completely overwrites the previous scale. +/// See sfSprite_scale to add a factor based on the previous scale instead. +/// The default scale of a sprite Sprite object is (1, 1). +/// +/// \param sprite Sprite object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setScale(sfSprite* sprite, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a sprite +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a sprite Sprite object is (0, 0). +/// +/// \param sprite Sprite object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setOrigin(sfSprite* sprite, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfSprite_getPosition(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a sprite +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param sprite Sprite object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfSprite_getRotation(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfSprite_getScale(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfSprite_getOrigin(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Move a sprite by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfSprite_setPosition which overwrites it. +/// +/// \param sprite Sprite object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_move(sfSprite* sprite, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a sprite +/// +/// This function adds to the current rotation of the object, +/// unlike sfSprite_setRotation which overwrites it. +/// +/// \param sprite Sprite object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_rotate(sfSprite* sprite, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a sprite +/// +/// This function multiplies the current scale of the object, +/// unlike sfSprite_setScale which overwrites it. +/// +/// \param sprite Sprite object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_scale(sfSprite* sprite, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfSprite_getTransform(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfSprite_getInverseTransform(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Change the source texture of a sprite +/// +/// The \a texture argument refers to a texture that must +/// exist as long as the sprite uses it. Indeed, the sprite +/// doesn't store its own copy of the texture, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the source texture is destroyed and the sprite tries to +/// use it, the behaviour is undefined. +/// If \a resetRect is true, the TextureRect property of +/// the sprite is automatically adjusted to the size of the new +/// texture. If it is false, the texture rect is left unchanged. +/// +/// \param sprite Sprite object +/// \param texture New texture +/// \param resetRect Should the texture rect be reset to the size of the new texture? +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setTexture(sfSprite* sprite, const sfTexture* texture, sfBool resetRect); + +//////////////////////////////////////////////////////////// +/// \brief Set the sub-rectangle of the texture that a sprite will display +/// +/// The texture rect is useful when you don't want to display +/// the whole texture, but rather a part of it. +/// By default, the texture rect covers the entire texture. +/// +/// \param sprite Sprite object +/// \param rectangle Rectangle defining the region of the texture to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setTextureRect(sfSprite* sprite, sfIntRect rectangle); + +//////////////////////////////////////////////////////////// +/// \brief Set the global color of a sprite +/// +/// This color is modulated (multiplied) with the sprite's +/// texture. It can be used to colorize the sprite, or change +/// its global opacity. +/// By default, the sprite's color is opaque white. +/// +/// \param sprite Sprite object +/// \param color New color of the sprite +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfSprite_setColor(sfSprite* sprite, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Get the source texture of a sprite +/// +/// If the sprite has no source texture, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the texture when you retrieve it with this function. +/// +/// \param sprite Sprite object +/// +/// \return Pointer to the sprite's texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTexture* sfSprite_getTexture(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the sub-rectangle of the texture displayed by a sprite +/// +/// \param sprite Sprite object +/// +/// \return Texture rectangle of the sprite +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfIntRect sfSprite_getTextureRect(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the global color of a sprite +/// +/// \param sprite Sprite object +/// +/// \return Global color of the sprite +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfSprite_getColor(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a sprite +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param sprite Sprite object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfSprite_getLocalBounds(const sfSprite* sprite); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a sprite +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// sprite in the global 2D world's coordinate system. +/// +/// \param sprite Sprite object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfSprite_getGlobalBounds(const sfSprite* sprite); + + +#endif // SFML_SPRITE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Text.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Text.h new file mode 100755 index 0000000..bb1fdd6 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Text.h @@ -0,0 +1,417 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_TEXT_H +#define SFML_TEXT_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/System/Vector2.h> +#include <stddef.h> + + +//////////////////////////////////////////////////////////// +/// sfText styles +//////////////////////////////////////////////////////////// +typedef enum +{ + sfTextRegular = 0, ///< Regular characters, no style + sfTextBold = 1 << 0, ///< Characters are bold + sfTextItalic = 1 << 1, ///< Characters are in italic + sfTextUnderlined = 1 << 2 ///< Characters are underlined +} sfTextStyle; + + +//////////////////////////////////////////////////////////// +/// \brief Create a new text +/// +/// \return A new sfText object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfText* sfText_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing text +/// +/// \param text Text to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfText* sfText_copy(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing text +/// +/// \param text Text to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_destroy(sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a text +/// +/// This function completely overwrites the previous position. +/// See sfText_move to apply an offset based on the previous position instead. +/// The default position of a text Text object is (0, 0). +/// +/// \param text Text object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setPosition(sfText* text, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a text +/// +/// This function completely overwrites the previous rotation. +/// See sfText_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a text Text object is 0. +/// +/// \param text Text object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setRotation(sfText* text, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a text +/// +/// This function completely overwrites the previous scale. +/// See sfText_scale to add a factor based on the previous scale instead. +/// The default scale of a text Text object is (1, 1). +/// +/// \param text Text object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setScale(sfText* text, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a text +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a text object is (0, 0). +/// +/// \param text Text object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setOrigin(sfText* text, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a text +/// +/// \param text Text object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfText_getPosition(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a text +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param text Text object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfText_getRotation(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a text +/// +/// \param text Text object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfText_getScale(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a text +/// +/// \param text Text object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfText_getOrigin(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Move a text by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfText_setPosition which overwrites it. +/// +/// \param text Text object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_move(sfText* text, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a text +/// +/// This function adds to the current rotation of the object, +/// unlike sfText_setRotation which overwrites it. +/// +/// \param text Text object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_rotate(sfText* text, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a text +/// +/// This function multiplies the current scale of the object, +/// unlike sfText_setScale which overwrites it. +/// +/// \param text Text object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_scale(sfText* text, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a text +/// +/// \param text Text object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfText_getTransform(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a text +/// +/// \param text Text object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfText_getInverseTransform(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Set the string of a text (from an ANSI string) +/// +/// A text's string is empty by default. +/// +/// \param text Text object +/// \param string New string +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setString(sfText* text, const char* string); + +//////////////////////////////////////////////////////////// +/// \brief Set the string of a text (from a unicode string) +/// +/// \param text Text object +/// \param string New string +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setUnicodeString(sfText* text, const sfUint32* string); + +//////////////////////////////////////////////////////////// +/// \brief Set the font of a text +/// +/// The \a font argument refers to a texture that must +/// exist as long as the text uses it. Indeed, the text +/// doesn't store its own copy of the font, but rather keeps +/// a pointer to the one that you passed to this function. +/// If the font is destroyed and the text tries to +/// use it, the behaviour is undefined. +/// +/// \param text Text object +/// \param font New font +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setFont(sfText* text, const sfFont* font); + +//////////////////////////////////////////////////////////// +/// \brief Set the character size of a text +/// +/// The default size is 30. +/// +/// \param text Text object +/// \param size New character size, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setCharacterSize(sfText* text, unsigned int size); + +//////////////////////////////////////////////////////////// +/// \brief Set the style of a text +/// +/// You can pass a combination of one or more styles, for +/// example sfTextBold | sfTextItalic. +/// The default style is sfTextRegular. +/// +/// \param text Text object +/// \param style New style +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setStyle(sfText* text, sfUint32 style); + +//////////////////////////////////////////////////////////// +/// \brief Set the global color of a text +/// +/// By default, the text's color is opaque white. +/// +/// \param text Text object +/// \param color New color of the text +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfText_setColor(sfText* text, sfColor color); + +//////////////////////////////////////////////////////////// +/// \brief Get the string of a text (returns an ANSI string) +/// +/// \param text Text object +/// +/// \return String as a locale-dependant ANSI string +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const char* sfText_getString(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the string of a text (returns a unicode string) +/// +/// \param text Text object +/// +/// \return String as UTF-32 +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfUint32* sfText_getUnicodeString(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the font used by a text +/// +/// If the text has no font attached, a NULL pointer is returned. +/// The returned pointer is const, which means that you can't +/// modify the font when you retrieve it with this function. +/// +/// \param text Text object +/// +/// \return Pointer to the font +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfFont* sfText_getFont(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the size of the characters of a text +/// +/// \param text Text object +/// +/// \return Size of the characters +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfText_getCharacterSize(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the style of a text +/// +/// \param text Text object +/// +/// \return Current string style (see sfTextStyle enum) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfUint32 sfText_getStyle(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the global color of a text +/// +/// \param text Text object +/// +/// \return Global color of the text +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfColor sfText_getColor(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Return the position of the \a index-th character in a text +/// +/// This function computes the visual position of a character +/// from its index in the string. The returned position is +/// in global coordinates (translation, rotation, scale and +/// origin are applied). +/// If \a index is out of range, the position of the end of +/// the string is returned. +/// +/// \param text Text object +/// \param index Index of the character +/// +/// \return Position of the character +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfText_findCharacterPos(const sfText* text, size_t index); + +//////////////////////////////////////////////////////////// +/// \brief Get the local bounding rectangle of a text +/// +/// The returned rectangle is in local coordinates, which means +/// that it ignores the transformations (translation, rotation, +/// scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// entity in the entity's coordinate system. +/// +/// \param text Text object +/// +/// \return Local bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfText_getLocalBounds(const sfText* text); + +//////////////////////////////////////////////////////////// +/// \brief Get the global bounding rectangle of a text +/// +/// The returned rectangle is in global coordinates, which means +/// that it takes in account the transformations (translation, +/// rotation, scale, ...) that are applied to the entity. +/// In other words, this function returns the bounds of the +/// text in the global 2D world's coordinate system. +/// +/// \param text Text object +/// +/// \return Global bounding rectangle of the entity +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfText_getGlobalBounds(const sfText* text); + + +#endif // SFML_TEXT_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Texture.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Texture.h new file mode 100755 index 0000000..0d4571d --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Texture.h @@ -0,0 +1,264 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_TEXTURE_H +#define SFML_TEXTURE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Window/Types.h> +#include <SFML/System/InputStream.h> +#include <SFML/System/Vector2.h> +#include <stddef.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new texture +/// +/// \param width Texture width +/// \param height Texture height +/// +/// \return A new sfTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_create(unsigned int width, unsigned int height); + +//////////////////////////////////////////////////////////// +/// \brief Create a new texture from a file +/// +/// \param filename Path of the image file to load +/// \param area Area of the source image to load (NULL to load the entire image) +/// +/// \return A new sfTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_createFromFile(const char* filename, const sfIntRect* area); + +//////////////////////////////////////////////////////////// +/// \brief Create a new texture from a file in memory +/// +/// \param data Pointer to the file data in memory +/// \param sizeInBytes Size of the data to load, in bytes +/// \param area Area of the source image to load (NULL to load the entire image) +/// +/// \return A new sfTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_createFromMemory(const void* data, size_t sizeInBytes, const sfIntRect* area); + +//////////////////////////////////////////////////////////// +/// \brief Create a new texture from a custom stream +/// +/// \param stream Source stream to read from +/// \param area Area of the source image to load (NULL to load the entire image) +/// +/// \return A new sfTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_createFromStream(sfInputStream* stream, const sfIntRect* area); + +//////////////////////////////////////////////////////////// +/// \brief Create a new texture from an image +/// +/// \param image Image to upload to the texture +/// \param area Area of the source image to load (NULL to load the entire image) +/// +/// \return A new sfTexture object, or NULL if it failed +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_createFromImage(const sfImage* image, const sfIntRect* area); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing texture +/// +/// \param texture Texture to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTexture* sfTexture_copy(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing texture +/// +/// \param texture Texture to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_destroy(sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Return the size of the texture +/// +/// \param texture Texture to read +/// +/// \return Size in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2u sfTexture_getSize(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Copy a texture's pixels to an image +/// +/// \param texture Texture to copy +/// +/// \return Image containing the texture's pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfImage* sfTexture_copyToImage(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Update a texture from an array of pixels +/// +/// \param texture Texture to update +/// \param pixels Array of pixels to copy to the texture +/// \param width Width of the pixel region contained in \a pixels +/// \param height Height of the pixel region contained in \a pixels +/// \param x X offset in the texture where to copy the source pixels +/// \param y Y offset in the texture where to copy the source pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_updateFromPixels(sfTexture* texture, const sfUint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y); + +//////////////////////////////////////////////////////////// +/// \brief Update a texture from an image +/// +/// \param texture Texture to update +/// \param image Image to copy to the texture +/// \param x X offset in the texture where to copy the source pixels +/// \param y Y offset in the texture where to copy the source pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_updateFromImage(sfTexture* texture, const sfImage* image, unsigned int x, unsigned int y); + +//////////////////////////////////////////////////////////// +/// \brief Update a texture from the contents of a window +/// +/// \param texture Texture to update +/// \param window Window to copy to the texture +/// \param x X offset in the texture where to copy the source pixels +/// \param y Y offset in the texture where to copy the source pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_updateFromWindow(sfTexture* texture, const sfWindow* window, unsigned int x, unsigned int y); + +//////////////////////////////////////////////////////////// +/// \brief Update a texture from the contents of a render-window +/// +/// \param texture Texture to update +/// \param renderWindow Render-window to copy to the texture +/// \param x X offset in the texture where to copy the source pixels +/// \param y Y offset in the texture where to copy the source pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_updateFromRenderWindow(sfTexture* texture, const sfRenderWindow* renderWindow, unsigned int x, unsigned int y); + +//////////////////////////////////////////////////////////// +/// \brief Enable or disable the smooth filter on a texture +/// +/// \param texture The texture object +/// \param smooth sfTrue to enable smoothing, sfFalse to disable it +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_setSmooth(sfTexture* texture, sfBool smooth); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether the smooth filter is enabled or not for a texture +/// +/// \param texture The texture object +/// +/// \return sfTrue if smoothing is enabled, sfFalse if it is disabled +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfTexture_isSmooth(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Enable or disable repeating for a texture +/// +/// Repeating is involved when using texture coordinates +/// outside the texture rectangle [0, 0, width, height]. +/// In this case, if repeat mode is enabled, the whole texture +/// will be repeated as many times as needed to reach the +/// coordinate (for example, if the X texture coordinate is +/// 3 * width, the texture will be repeated 3 times). +/// If repeat mode is disabled, the "extra space" will instead +/// be filled with border pixels. +/// Warning: on very old graphics cards, white pixels may appear +/// when the texture is repeated. With such cards, repeat mode +/// can be used reliably only if the texture has power-of-two +/// dimensions (such as 256x128). +/// Repeating is disabled by default. +/// +/// \param texture The texture object +/// \param repeated True to repeat the texture, false to disable repeating +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_setRepeated(sfTexture* texture, sfBool repeated); + +//////////////////////////////////////////////////////////// +/// \brief Tell whether a texture is repeated or not +/// +/// \param texture The texture object +/// +/// \return sfTrue if repeat mode is enabled, sfFalse if it is disabled +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfBool sfTexture_isRepeated(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Bind a texture for rendering +/// +/// This function is not part of the graphics API, it mustn't be +/// used when drawing SFML entities. It must be used only if you +/// mix sfTexture with OpenGL code. +/// +/// \code +/// sfTexture *t1, *t2; +/// ... +/// sfTexture_bind(t1); +/// // draw OpenGL stuff that use t1... +/// sfTexture_bind(t2); +/// // draw OpenGL stuff that use t2... +/// sfTexture_bind(NULL); +/// // draw OpenGL stuff that use no texture... +/// \endcode +/// +/// \param texture Pointer to the texture to bind, can be null to use no texture +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTexture_bind(const sfTexture* texture); + +//////////////////////////////////////////////////////////// +/// \brief Get the maximum texture size allowed +/// +/// \return Maximum size allowed for textures, in pixels +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfTexture_getMaximumSize(); + + +#endif // SFML_TEXTURE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transform.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transform.h new file mode 100755 index 0000000..0db94bb --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transform.h @@ -0,0 +1,210 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_TRANSFORM_H +#define SFML_TRANSFORM_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + + +//////////////////////////////////////////////////////////// +/// \brief Encapsulate a 3x3 transform matrix +/// +//////////////////////////////////////////////////////////// +typedef struct +{ + float matrix[9]; +} sfTransform; + + +//////////////////////////////////////////////////////////// +/// \brief Identity transform (does nothing) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API const sfTransform sfTransform_Identity; + +//////////////////////////////////////////////////////////// +/// \brief Create a new transform from a matrix +/// +/// \param a00 Element (0, 0) of the matrix +/// \param a01 Element (0, 1) of the matrix +/// \param a02 Element (0, 2) of the matrix +/// \param a10 Element (1, 0) of the matrix +/// \param a11 Element (1, 1) of the matrix +/// \param a12 Element (1, 2) of the matrix +/// \param a20 Element (2, 0) of the matrix +/// \param a21 Element (2, 1) of the matrix +/// \param a22 Element (2, 2) of the matrix +/// +/// \return A new sfTransform object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfTransform_fromMatrix(float a00, float a01, float a02, + float a10, float a11, float a12, + float a20, float a21, float a22); + +//////////////////////////////////////////////////////////// +/// \brief Return the 4x4 matrix of a transform +/// +/// This function fills an array of 16 floats with the transform +/// converted as a 4x4 matrix, which is directly compatible with +/// OpenGL functions. +/// +/// \code +/// sfTransform transform = ...; +/// float matrix[16]; +/// sfTransform_getMatrix(&transform, matrix) +/// glLoadMatrixf(matrix); +/// \endcode +/// +/// \param transform Transform object +/// \param matrix Pointer to the 16-element array to fill with the matrix +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_getMatrix(const sfTransform* transform, float* matrix); + +//////////////////////////////////////////////////////////// +/// \brief Return the inverse of a transform +/// +/// If the inverse cannot be computed, a new identity transform +/// is returned. +/// +/// \param transform Transform object +/// \return The inverse matrix +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfTransform_getInverse(const sfTransform* transform); + +//////////////////////////////////////////////////////////// +/// \brief Apply a transform to a 2D point +/// +/// \param transform Transform object +/// \param point Point to transform +/// +/// \return Transformed point +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfTransform_transformPoint(const sfTransform* transform, sfVector2f point); + +//////////////////////////////////////////////////////////// +/// \brief Apply a transform to a rectangle +/// +/// Since SFML doesn't provide support for oriented rectangles, +/// the result of this function is always an axis-aligned +/// rectangle. Which means that if the transform contains a +/// rotation, the bounding rectangle of the transformed rectangle +/// is returned. +/// +/// \param transform Transform object +/// \param rectangle Rectangle to transform +/// +/// \return Transformed rectangle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfTransform_transformRect(const sfTransform* transform, sfFloatRect rectangle); + +//////////////////////////////////////////////////////////// +/// \brief Combine two transforms +/// +/// The result is a transform that is equivalent to applying +/// \a transform followed by \a other. Mathematically, it is +/// equivalent to a matrix multiplication. +/// +/// \param transform Transform object +/// \param right Transform to combine to \a transform +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_combine(sfTransform* transform, const sfTransform* other); + +//////////////////////////////////////////////////////////// +/// \brief Combine a transform with a translation +/// +/// \param transform Transform object +/// \param x Offset to apply on X axis +/// \param y Offset to apply on Y axis +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_translate(sfTransform* transform, float x, float y); + +//////////////////////////////////////////////////////////// +/// \brief Combine the current transform with a rotation +/// +/// \param transform Transform object +/// \param angle Rotation angle, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_rotate(sfTransform* transform, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Combine the current transform with a rotation +/// +/// The center of rotation is provided for convenience as a second +/// argument, so that you can build rotations around arbitrary points +/// more easily (and efficiently) than the usual +/// [translate(-center), rotate(angle), translate(center)]. +/// +/// \param transform Transform object +/// \param angle Rotation angle, in degrees +/// \param centerX X coordinate of the center of rotation +/// \param centerY Y coordinate of the center of rotation +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_rotateWithCenter(sfTransform* transform, float angle, float centerX, float centerY); + +//////////////////////////////////////////////////////////// +/// \brief Combine the current transform with a scaling +/// +/// \param transform Transform object +/// \param scaleX Scaling factor on the X axis +/// \param scaleY Scaling factor on the Y axis +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_scale(sfTransform* transform, float scaleX, float scaleY); + +//////////////////////////////////////////////////////////// +/// \brief Combine the current transform with a scaling +/// +/// The center of scaling is provided for convenience as a second +/// argument, so that you can build scaling around arbitrary points +/// more easily (and efficiently) than the usual +/// [translate(-center), scale(factors), translate(center)] +/// +/// \param transform Transform object +/// \param scaleX Scaling factor on X axis +/// \param scaleY Scaling factor on Y axis +/// \param centerX X coordinate of the center of scaling +/// \param centerY Y coordinate of the center of scaling +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransform_scaleWithCenter(sfTransform* transform, float scaleX, float scaleY, float centerX, float centerY); + + +#endif // SFML_TRANSFORM_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transformable.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transformable.h new file mode 100755 index 0000000..1b1ac6d --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Transformable.h @@ -0,0 +1,217 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_TRANSFORMABLE_H +#define SFML_TRANSFORMABLE_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Graphics/Transform.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new transformable +/// +/// \return A new sfTransformable object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransformable* sfTransformable_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing transformable +/// +/// \param transformable Transformable to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransformable* sfTransformable_copy(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing transformable +/// +/// \param transformable Transformable to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_destroy(sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Set the position of a transformable +/// +/// This function completely overwrites the previous position. +/// See sfTransformable_move to apply an offset based on the previous position instead. +/// The default position of a transformable Transformable object is (0, 0). +/// +/// \param transformable Transformable object +/// \param position New position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_setPosition(sfTransformable* transformable, sfVector2f position); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a transformable +/// +/// This function completely overwrites the previous rotation. +/// See sfTransformable_rotate to add an angle based on the previous rotation instead. +/// The default rotation of a transformable Transformable object is 0. +/// +/// \param transformable Transformable object +/// \param angle New rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_setRotation(sfTransformable* transformable, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the scale factors of a transformable +/// +/// This function completely overwrites the previous scale. +/// See sfTransformable_scale to add a factor based on the previous scale instead. +/// The default scale of a transformable Transformable object is (1, 1). +/// +/// \param transformable Transformable object +/// \param scale New scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_setScale(sfTransformable* transformable, sfVector2f scale); + +//////////////////////////////////////////////////////////// +/// \brief Set the local origin of a transformable +/// +/// The origin of an object defines the center point for +/// all transformations (position, scale, rotation). +/// The coordinates of this point must be relative to the +/// top-left corner of the object, and ignore all +/// transformations (position, scale, rotation). +/// The default origin of a transformable Transformable object is (0, 0). +/// +/// \param transformable Transformable object +/// \param origin New origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_setOrigin(sfTransformable* transformable, sfVector2f origin); + +//////////////////////////////////////////////////////////// +/// \brief Get the position of a transformable +/// +/// \param transformable Transformable object +/// +/// \return Current position +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfTransformable_getPosition(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Get the orientation of a transformable +/// +/// The rotation is always in the range [0, 360]. +/// +/// \param transformable Transformable object +/// +/// \return Current rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfTransformable_getRotation(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Get the current scale of a transformable +/// +/// \param transformable Transformable object +/// +/// \return Current scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfTransformable_getScale(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Get the local origin of a transformable +/// +/// \param transformable Transformable object +/// +/// \return Current origin +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfTransformable_getOrigin(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Move a transformable by a given offset +/// +/// This function adds to the current position of the object, +/// unlike sfTransformable_setPosition which overwrites it. +/// +/// \param transformable Transformable object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_move(sfTransformable* transformable, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a transformable +/// +/// This function adds to the current rotation of the object, +/// unlike sfTransformable_setRotation which overwrites it. +/// +/// \param transformable Transformable object +/// \param angle Angle of rotation, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_rotate(sfTransformable* transformable, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Scale a transformable +/// +/// This function multiplies the current scale of the object, +/// unlike sfTransformable_setScale which overwrites it. +/// +/// \param transformable Transformable object +/// \param factors Scale factors +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfTransformable_scale(sfTransformable* transformable, sfVector2f factors); + +//////////////////////////////////////////////////////////// +/// \brief Get the combined transform of a transformable +/// +/// \param transformable Transformable object +/// +/// \return Transform combining the position/rotation/scale/origin of the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfTransformable_getTransform(const sfTransformable* transformable); + +//////////////////////////////////////////////////////////// +/// \brief Get the inverse of the combined transform of a transformable +/// +/// \param transformable Transformable object +/// +/// \return Inverse of the combined transformations applied to the object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfTransform sfTransformable_getInverseTransform(const sfTransformable* transformable); + + +#endif // SFML_TRANSFORMABLE_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Types.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Types.h new file mode 100755 index 0000000..8b63f7a --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Types.h @@ -0,0 +1,46 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_GRAPHICS_TYPES_H +#define SFML_GRAPHICS_TYPES_H + + +typedef struct sfCircleShape sfCircleShape; +typedef struct sfConvexShape sfConvexShape; +typedef struct sfFont sfFont; +typedef struct sfImage sfImage; +typedef struct sfShader sfShader; +typedef struct sfRectangleShape sfRectangleShape; +typedef struct sfRenderTexture sfRenderTexture; +typedef struct sfRenderWindow sfRenderWindow; +typedef struct sfShape sfShape; +typedef struct sfSprite sfSprite; +typedef struct sfText sfText; +typedef struct sfTexture sfTexture; +typedef struct sfTransformable sfTransformable; +typedef struct sfVertexArray sfVertexArray; +typedef struct sfView sfView; + + +#endif // SFML_GRAPHICS_TYPES_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Vertex.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Vertex.h new file mode 100755 index 0000000..b2c0996 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/Vertex.h @@ -0,0 +1,47 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_VERTEX_H +#define SFML_VERTEX_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Color.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// Define a point with color and texture coordinates +//////////////////////////////////////////////////////////// +typedef struct +{ + sfVector2f position; ///< Position of the vertex + sfColor color; ///< Color of the vertex + sfVector2f texCoords; ///< Coordinates of the texture's pixel to map to the vertex +} sfVertex; + + +#endif // SFML_VERTEX_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/VertexArray.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/VertexArray.h new file mode 100755 index 0000000..c050eed --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/VertexArray.h @@ -0,0 +1,167 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_VERTEXARRAY_H +#define SFML_VERTEXARRAY_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/PrimitiveType.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/Graphics/Vertex.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a new vertex array +/// +/// \return A new sfVertexArray object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVertexArray* sfVertexArray_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing vertex array +/// +/// \param vertexArray Vertex array to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVertexArray* sfVertexArray_copy(const sfVertexArray* vertexArray); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing vertex array +/// +/// \param vertexArray Vertex array to delete +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfVertexArray_destroy(sfVertexArray* vertexArray); + +//////////////////////////////////////////////////////////// +/// \brief Return the vertex count of a vertex array +/// +/// \param vertexArray Vertex array object +/// +/// \return Number of vertices in the array +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API unsigned int sfVertexArray_getVertexCount(const sfVertexArray* vertexArray); + +//////////////////////////////////////////////////////////// +/// \brief Get access to a vertex by its index +/// +/// This function doesn't check \a index, it must be in range +/// [0, vertex count - 1]. The behaviour is undefined +/// otherwise. +/// +/// \param vertexArray Vertex array object +/// \param index Index of the vertex to get +/// +/// \return Pointer to the index-th vertex +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVertex* sfVertexArray_getVertex(sfVertexArray* vertexArray, unsigned int index); + +//////////////////////////////////////////////////////////// +/// \brief Clear a vertex array +/// +/// This function removes all the vertices from the array. +/// It doesn't deallocate the corresponding memory, so that +/// adding new vertices after clearing doesn't involve +/// reallocating all the memory. +/// +/// \param vertexArray Vertex array object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfVertexArray_clear(sfVertexArray* vertexArray); + +//////////////////////////////////////////////////////////// +/// \brief Resize the vertex array +/// +/// If \a vertexCount is greater than the current size, the previous +/// vertices are kept and new (default-constructed) vertices are +/// added. +/// If \a vertexCount is less than the current size, existing vertices +/// are removed from the array. +/// +/// \param vertexArray Vertex array objet +/// \param vertexCount New size of the array (number of vertices) +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfVertexArray_resize(sfVertexArray* vertexArray, unsigned int vertexCount); + +//////////////////////////////////////////////////////////// +/// \brief Add a vertex to a vertex array array +/// +/// \param vertexArray Vertex array objet +/// \param vertex Vertex to add +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfVertexArray_append(sfVertexArray* vertexArray, sfVertex vertex); + +//////////////////////////////////////////////////////////// +/// \brief Set the type of primitives of a vertex array +/// +/// This function defines how the vertices must be interpreted +/// when it's time to draw them: +/// \li As points +/// \li As lines +/// \li As triangles +/// \li As quads +/// The default primitive type is sfPoints. +/// +/// \param vertexArray Vertex array objet +/// \param type Type of primitive +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArray, sfPrimitiveType type); + +//////////////////////////////////////////////////////////// +/// \brief Get the type of primitives drawn by a vertex array +/// +/// \param vertexArray Vertex array objet +/// +/// \return Primitive type +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray); + +//////////////////////////////////////////////////////////// +/// \brief Compute the bounding rectangle of a vertex array +/// +/// This function returns the axis-aligned rectangle that +/// contains all the vertices of the array. +/// +/// \param vertexArray Vertex array objet +/// +/// \return Bounding rectangle of the vertex array +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray); + + +#endif // SFML_VERTEXARRAY_H diff --git a/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/View.h b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/View.h new file mode 100755 index 0000000..70acef5 --- /dev/null +++ b/h1z1/libghack/CSFML-2.1-windows-32bits/CSFML-2.1/include/SFML/Graphics/View.h @@ -0,0 +1,206 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com) +// +// This software is provided 'as-is', without any express 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 SFML_VIEW_H +#define SFML_VIEW_H + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include <SFML/Graphics/Export.h> +#include <SFML/Graphics/Rect.h> +#include <SFML/Graphics/Types.h> +#include <SFML/System/Vector2.h> + + +//////////////////////////////////////////////////////////// +/// \brief Create a default view +/// +/// This function creates a default view of (0, 0, 1000, 1000) +/// +/// \return A new sfView object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfView* sfView_create(void); + +//////////////////////////////////////////////////////////// +/// \brief Construct a view from a rectangle +/// +/// \param rectangle Rectangle defining the zone to display +/// +/// \return A new sfView object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfView* sfView_createFromRect(sfFloatRect rectangle); + +//////////////////////////////////////////////////////////// +/// \brief Copy an existing view +/// +/// \param view View to copy +/// +/// \return Copied object +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfView* sfView_copy(const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Destroy an existing view +/// +/// \param view View to destroy +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_destroy(sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Set the center of a view +/// +/// \param view View object +/// \param center New center +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_setCenter(sfView* view, sfVector2f center); + +//////////////////////////////////////////////////////////// +/// \brief Set the size of a view +/// +/// \param view View object +/// \param size New size of the view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_setSize(sfView* view, sfVector2f size); + +//////////////////////////////////////////////////////////// +/// \brief Set the orientation of a view +/// +/// The default rotation of a view is 0 degree. +/// +/// \param view View object +/// \param angle New angle, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_setRotation(sfView* view, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Set the target viewport of a view +/// +/// The viewport is the rectangle into which the contents of the +/// view are displayed, expressed as a factor (between 0 and 1) +/// of the size of the render target to which the view is applied. +/// For example, a view which takes the left side of the target would +/// be defined by a rect of (0, 0, 0.5, 1). +/// By default, a view has a viewport which covers the entire target. +/// +/// \param view View object +/// \param viewport New viewport rectangle +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_setViewport(sfView* view, sfFloatRect viewport); + +//////////////////////////////////////////////////////////// +/// \brief Reset a view to the given rectangle +/// +/// Note that this function resets the rotation angle to 0. +/// +/// \param view View object +/// \param rectangle Rectangle defining the zone to display +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_reset(sfView* view, sfFloatRect rectangle); + +//////////////////////////////////////////////////////////// +/// \brief Get the center of a view +/// +/// \param view View object +/// +/// \return Center of the view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfView_getCenter(const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Get the size of a view +/// +/// \param view View object +/// +/// \return Size of the view +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfVector2f sfView_getSize(const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Get the current orientation of a view +/// +/// \param view View object +/// +/// \return Rotation angle of the view, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API float sfView_getRotation(const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Get the target viewport rectangle of a view +/// +/// \param view View object +/// +/// \return Viewport rectangle, expressed as a factor of the target size +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API sfFloatRect sfView_getViewport(const sfView* view); + +//////////////////////////////////////////////////////////// +/// \brief Move a view relatively to its current position +/// +/// \param view View object +/// \param offset Offset +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_move(sfView* view, sfVector2f offset); + +//////////////////////////////////////////////////////////// +/// \brief Rotate a view relatively to its current orientation +/// +/// \param view View object +/// \param angle Angle to rotate, in degrees +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_rotate(sfView* view, float angle); + +//////////////////////////////////////////////////////////// +/// \brief Resize a view rectangle relatively to its current size +/// +/// Resizing the view simulates a zoom, as the zone displayed on +/// screen grows or shrinks. +/// \a factor is a multiplier: +/// \li 1 keeps the size unchanged +/// \li > 1 makes the view bigger (objects appear smaller) +/// \li < 1 makes the view smaller (objects appear bigger) +/// +/// \param view View object +/// \param factor Zoom factor to apply +/// +//////////////////////////////////////////////////////////// +CSFML_GRAPHICS_API void sfView_zoom(sfView* view, float factor); + + +#endif // SFML_VIEW_H |