From 85f1dd7a1e19681e7633a070db1eb3b42f7a73be Mon Sep 17 00:00:00 2001 From: Jonathan Moallem Date: Thu, 19 Nov 2020 14:55:38 +1100 Subject: [PATCH] Initial commit --- .gitignore | 1 + Makefile | 16 + README.md | 1 + include/AudioDevice.hpp | 85 ++ include/AudioStream.hpp | 161 ++++ include/BoundingBox.hpp | 85 ++ include/Camera2D.hpp | 97 +++ include/Camera3D.hpp | 147 ++++ include/Color.hpp | 213 +++++ include/DroppedFiles.hpp | 107 +++ include/Font.hpp | 129 +++ include/Gamepad.hpp | 99 +++ include/Image.hpp | 391 +++++++++ include/Material.hpp | 76 ++ include/Matrix.hpp | 260 ++++++ include/Mesh.hpp | 125 +++ include/Model.hpp | 107 +++ include/ModelAnimation.hpp | 85 ++ include/Mouse.hpp | 115 +++ include/Music.hpp | 124 +++ include/Physics.hpp | 152 ++++ include/Ray.hpp | 101 +++ include/RayHitInfo.hpp | 70 ++ include/Rectangle.hpp | 131 +++ include/RenderTexture.hpp | 88 ++ include/Shader.hpp | 150 ++++ include/Sound.hpp | 125 +++ include/Texture.hpp | 194 +++++ include/Vector2.hpp | 251 ++++++ include/Vector3.hpp | 329 ++++++++ include/Vector4.hpp | 182 ++++ include/VrSimulator.hpp | 85 ++ include/Wave.hpp | 133 +++ include/Window.hpp | 216 +++++ include/raylib-cpp-utils.hpp | 41 + include/raylib-cpp.hpp | 108 +++ include/raylib.h | 1504 +++++++++++++++++++++++++++++++++ include/raylib.hpp | 36 + include/raymath.h | 1519 ++++++++++++++++++++++++++++++++++ include/raymath.hpp | 38 + lib/libraylib.a | Bin 0 -> 1444032 bytes src/main.cpp | 35 + 42 files changed, 7912 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 README.md create mode 100644 include/AudioDevice.hpp create mode 100644 include/AudioStream.hpp create mode 100644 include/BoundingBox.hpp create mode 100644 include/Camera2D.hpp create mode 100644 include/Camera3D.hpp create mode 100644 include/Color.hpp create mode 100644 include/DroppedFiles.hpp create mode 100644 include/Font.hpp create mode 100644 include/Gamepad.hpp create mode 100644 include/Image.hpp create mode 100644 include/Material.hpp create mode 100644 include/Matrix.hpp create mode 100644 include/Mesh.hpp create mode 100644 include/Model.hpp create mode 100644 include/ModelAnimation.hpp create mode 100644 include/Mouse.hpp create mode 100644 include/Music.hpp create mode 100644 include/Physics.hpp create mode 100644 include/Ray.hpp create mode 100644 include/RayHitInfo.hpp create mode 100644 include/Rectangle.hpp create mode 100644 include/RenderTexture.hpp create mode 100644 include/Shader.hpp create mode 100644 include/Sound.hpp create mode 100644 include/Texture.hpp create mode 100644 include/Vector2.hpp create mode 100644 include/Vector3.hpp create mode 100644 include/Vector4.hpp create mode 100644 include/VrSimulator.hpp create mode 100644 include/Wave.hpp create mode 100644 include/Window.hpp create mode 100644 include/raylib-cpp-utils.hpp create mode 100644 include/raylib-cpp.hpp create mode 100644 include/raylib.h create mode 100644 include/raylib.hpp create mode 100644 include/raymath.h create mode 100644 include/raymath.hpp create mode 100644 lib/libraylib.a create mode 100644 src/main.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..84c048a --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..03c02e4 --- /dev/null +++ b/Makefile @@ -0,0 +1,16 @@ +#https://opensource.com/article/18/8/what-how-makefile + +buildfile = ./build/app + +macOSFrameworks = -framework CoreVideo -framework IOKit -framework Cocoa -framework GLUT -framework OpenGL + +all: compile run clean + +compile: + clang++ -std=c++17 $(macOSFrameworks) -I ./include/ ./lib/libraylib.a ./src/main.cpp -o $(buildfile) + +run: + $(buildfile) + +clean: + rm $(buildfile) \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..ed9611e --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# raylib-cpp-starter diff --git a/include/AudioDevice.hpp b/include/AudioDevice.hpp new file mode 100644 index 0000000..6e5c65d --- /dev/null +++ b/include/AudioDevice.hpp @@ -0,0 +1,85 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_AUDIODEVICE_HPP_ +#define RAYLIB_CPP_INCLUDE_AUDIODEVICE_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +/** + * Audio device management functions. + */ +class AudioDevice { + public: + /** + * Initialize audio device and context. + * + * @param lateInit Whether or not to post-pone initializing the context. + */ + AudioDevice(bool lateInit = false) { + if (!lateInit) { + Init(); + } + } + + ~AudioDevice() { + Close(); + } + + /** + * Initialize audio device and context. + */ + inline AudioDevice& Init() { + ::InitAudioDevice(); + return *this; + } + + /** + * Close the audio device and context. + */ + inline AudioDevice& Close() { + ::CloseAudioDevice(); + return *this; + } + + /** + * Check if audio device has been initialized successfully. + */ + inline bool IsReady() const { + return ::IsAudioDeviceReady(); + } + + /** + * Set master volume (listener). + */ + inline AudioDevice& SetVolume(float volume) { + ::SetMasterVolume(volume); + return *this; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_AUDIODEVICE_HPP_ diff --git a/include/AudioStream.hpp b/include/AudioStream.hpp new file mode 100644 index 0000000..449f937 --- /dev/null +++ b/include/AudioStream.hpp @@ -0,0 +1,161 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_ +#define RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +/** + * AudioStream management functions + */ +class AudioStream : public ::AudioStream { + public: + AudioStream(::AudioStream music) { + set(music); + } + + /** + * Init audio stream (to stream raw audio pcm data) + */ + AudioStream(unsigned int SampleRate, unsigned int SampleSize, unsigned int Channels) { + set(InitAudioStream(SampleRate, SampleSize, Channels)); + } + + ~AudioStream() { + Close(); + } + + GETTERSETTER(unsigned int, SampleRate, sampleRate) + GETTERSETTER(unsigned int, SampleSize, sampleSize) + GETTERSETTER(unsigned int, Channels, channels) + + AudioStream& operator=(const ::AudioStream& stream) { + set(stream); + return *this; + } + + AudioStream& operator=(const AudioStream& stream) { + set(stream); + return *this; + } + + /** + * Update audio stream buffers with data + */ + inline AudioStream& Update(const void *data, int samplesCount) { + ::UpdateAudioStream(*this, data, samplesCount); + return *this; + } + + /** + * Close audio stream and free memory + */ + inline AudioStream& Close() { + ::CloseAudioStream(*this); + return *this; + } + + /** + * Check if any audio stream buffers requires refill + */ + inline bool IsProcessed() const { + return ::IsAudioStreamProcessed(*this); + } + + /** + * Play audio stream + */ + inline AudioStream& Play() { + ::PlayAudioStream(*this); + return *this; + } + + /** + * Pause audio stream + */ + inline AudioStream& Pause() { + ::PauseAudioStream(*this); + return *this; + } + + /** + * Resume audio stream + */ + inline AudioStream& Resume() { + ::ResumeAudioStream(*this); + return *this; + } + + /** + * Check if audio stream is playing + */ + inline bool IsPlaying() const { + return ::IsAudioStreamPlaying(*this); + } + + /** + * Stop audio stream + */ + inline AudioStream& Stop() { + ::StopAudioStream(*this); + return *this; + } + + /** + * Set volume for audio stream (1.0 is max level) + */ + inline AudioStream& SetVolume(float volume) { + ::SetAudioStreamVolume(*this, volume); + return *this; + } + + /** + * Set pitch for audio stream (1.0 is base level) + */ + inline AudioStream& SetPitch(float pitch) { + ::SetAudioStreamPitch(*this, pitch); + return *this; + } + + /** + * Default size for new audio streams + */ + inline static void SetBufferSizeDefault(int size) { + ::SetAudioStreamBufferSizeDefault(size); + } + + protected: + inline void set(::AudioStream stream) { + sampleRate = stream.sampleRate; + sampleSize = stream.sampleSize; + channels = stream.channels; + buffer = stream.buffer; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_ diff --git a/include/BoundingBox.hpp b/include/BoundingBox.hpp new file mode 100644 index 0000000..fe3fc8b --- /dev/null +++ b/include/BoundingBox.hpp @@ -0,0 +1,85 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_BOUNDINGBOX_HPP_ +#define RAYLIB_CPP_INCLUDE_BOUNDINGBOX_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class BoundingBox : public ::BoundingBox { + public: + BoundingBox(::BoundingBox box) { + set(box); + } + + BoundingBox(::Mesh mesh) { + set(MeshBoundingBox(mesh)); + } + + BoundingBox(::Vector3 Min, ::Vector3 Max) { + min = Min; + max = Max; + } + + GETTERSETTER(::Vector3, Min, min) + GETTERSETTER(::Vector3, Max, max) + + BoundingBox& operator=(const ::BoundingBox& box) { + set(box); + return *this; + } + + BoundingBox& operator=(const BoundingBox& box) { + set(box); + return *this; + } + + inline BoundingBox& Draw(::Color color = WHITE) { + DrawBoundingBox(*this, color); + return *this; + } + + inline bool CheckCollision(::BoundingBox box2) const { + return CheckCollisionBoxes(*this, box2); + } + + inline bool CheckCollision(::Vector3 center, float radius) const { + return CheckCollisionBoxSphere(*this, center, radius); + } + + inline bool CheckCollision(::Ray ray) const { + return CheckCollisionRayBox(ray, *this); + } + + protected: + inline void set(::BoundingBox box) { + min = box.min; + max = box.max; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_BOUNDINGBOX_HPP_ diff --git a/include/Camera2D.hpp b/include/Camera2D.hpp new file mode 100644 index 0000000..45b52d1 --- /dev/null +++ b/include/Camera2D.hpp @@ -0,0 +1,97 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_CAMERA2D_HPP_ +#define RAYLIB_CPP_INCLUDE_CAMERA2D_HPP_ + +#include "./raylib.hpp" +#include "./Vector2.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Camera2D : public ::Camera2D { + public: + Camera2D(::Vector2 offsetValue, ::Vector2 targetValue, float rotationValue = 0, + float zoomValue = 1) { + offset = offsetValue; + target = targetValue; + rotation = rotationValue; + zoom = zoomValue; + } + + inline Camera2D& BeginMode2D() { + ::BeginMode2D(*this); + return *this; + } + + inline Camera2D& EndMode2D() { + ::EndMode2D(); + return *this; + } + + GETTERSETTER(::Vector2, Offset, offset) + GETTERSETTER(::Vector2, Target, target) + GETTERSETTER(float, Rotation, rotation) + GETTERSETTER(float, Zoom, zoom) + + Camera2D& operator=(const ::Camera2D& camera) { + set(camera); + return *this; + } + + Camera2D& operator=(const Camera2D& camera) { + set(camera); + return *this; + } + + inline Matrix GetMatrix() const { + return ::GetCameraMatrix2D(*this); + } + + inline Vector2 GetWorldToScreen2D(Vector2 position) const { + return ::GetWorldToScreen2D(position, *this); + } + + inline Vector2 GetScreenToWorld2D(Vector2 position) const { + return ::GetScreenToWorld2D(position, *this); + } + + protected: + inline void set(const ::Camera2D& camera) { + offset = camera.offset; + target = camera.target; + rotation = camera.rotation; + zoom = camera.zoom; + } + + inline void set(const Camera2D& camera) { + offset = camera.offset; + target = camera.target; + rotation = camera.rotation; + zoom = camera.zoom; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_CAMERA2D_HPP_ diff --git a/include/Camera3D.hpp b/include/Camera3D.hpp new file mode 100644 index 0000000..6793aa2 --- /dev/null +++ b/include/Camera3D.hpp @@ -0,0 +1,147 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_CAMERA3D_HPP_ +#define RAYLIB_CPP_INCLUDE_CAMERA3D_HPP_ + +#include "./raylib.hpp" +#include "./Vector3.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Camera3D : public ::Camera3D { + public: + Camera3D(::Vector3 positionValue, ::Vector3 targetValue, ::Vector3 upValue, + float fovyValue = 0, int typeValue = 0) { + position = positionValue; + target = targetValue; + up = upValue; + fovy = fovyValue; + type = typeValue; + } + + Camera3D() {} + + GETTERSETTER(::Vector3, Position, position) + GETTERSETTER(::Vector3, Target, target) + GETTERSETTER(::Vector3, Up, up) + GETTERSETTER(float, Fovy, fovy) + GETTERSETTER(int, Type, type) + + Camera3D& operator=(const ::Camera3D& camera) { + set(camera); + return *this; + } + + Camera3D& operator=(const Camera3D& camera) { + set(camera); + return *this; + } + + Camera3D& BeginMode3D() { + ::BeginMode3D(*this); + return *this; + } + Camera3D& EndMode3D() { + ::EndMode3D(); + return *this; + } + + inline Matrix GetMatrix() const { + return ::GetCameraMatrix(*this); + } + + inline Camera3D& SetMode(int mode) { + ::SetCameraMode(*this, mode); + return *this; + } + + inline Camera3D& SetAltControl(int altKey) { + ::SetCameraAltControl(altKey); + return *this; + } + + inline Camera3D& SetSmoothZoomControl(int szKey) { + ::SetCameraSmoothZoomControl(szKey); + return *this; + } + + inline Camera3D& SetMoveControls(int frontKey, int backKey, int rightKey, int leftKey, + int upKey, int downKey) { + ::SetCameraMoveControls(frontKey, backKey, rightKey, leftKey, upKey, downKey); + return *this; + } + + inline Camera3D& Update() { + ::UpdateCamera(this); + return *this; + } + + inline Camera3D& UpdateVrTracking() { + ::UpdateVrTracking(this); + return *this; + } + + inline Ray GetMouseRay(::Vector2 mousePosition) const { + return ::GetMouseRay(mousePosition, *this); + } + + inline Vector2 GetWorldToScreen(::Vector3 position) const { + return ::GetWorldToScreen(position, *this); + } + + inline Camera3D& DrawBillboard(::Texture2D texture, ::Vector3 center, float size, + ::Color tint = WHITE) { + ::DrawBillboard(*this, texture, center, size, tint); + return *this; + } + + inline Camera3D& DrawBillboard(Texture2D texture, Rectangle sourceRec, Vector3 center, + float size, ::Color tint = WHITE) { + ::DrawBillboardRec(*this, texture, sourceRec, center, size, tint); + return *this; + } + + protected: + inline void set(const ::Camera3D& camera) { + position = camera.position; + target = camera.target; + up = camera.up; + fovy = camera.fovy; + type = camera.type; + } + + inline void set(const Camera3D& camera) { + position = camera.position; + target = camera.target; + up = camera.up; + fovy = camera.fovy; + type = camera.type; + } +}; + +typedef Camera3D Camera; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_CAMERA3D_HPP_ diff --git a/include/Color.hpp b/include/Color.hpp new file mode 100644 index 0000000..67fa4c1 --- /dev/null +++ b/include/Color.hpp @@ -0,0 +1,213 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_COLOR_HPP_ +#define RAYLIB_CPP_INCLUDE_COLOR_HPP_ + +#include + +#include "./raylib.hpp" +#include "./Vector4.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Color : public ::Color { + public: + Color() { + r = 0; + g = 0; + b = 0; + a = 255; + } + + Color(::Color color) { + r = color.r; + g = color.g; + b = color.b; + a = color.a; + } + + Color(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = 255) { + r = red; + g = green; + b = blue; + a = alpha; + } + + Color(::Vector3 hsv) { + set(::ColorFromHSV(hsv.x, hsv.y, hsv.z)); + } + + static Color FromHSV(float hue, float saturation, float value) { + ::Color color = ::ColorFromHSV(hue, saturation, value); + return color; + } + + Color(int hexValue) { + set(::GetColor(hexValue)); + } + + Color(Vector4 normalized) { + set(::ColorFromNormalized(normalized)); + } + + int ToInt() const { + return ::ColorToInt(*this); + } + + operator int() const { return ::ColorToInt(*this); } + + Color Fade(float alpha) const { + return ::Fade(*this, alpha); + } + + Vector4 Normalize() const { + return ::ColorNormalize(*this); + } + + Vector3 ToHSV() const { + return ::ColorToHSV(*this); + } + + GETTERSETTER(unsigned char, R, r) + GETTERSETTER(unsigned char, G, g) + GETTERSETTER(unsigned char, B, b) + GETTERSETTER(unsigned char, A, a) + + Color& operator=(const ::Color& color) { + set(color); + return *this; + } + + Color& operator=(const Color& color) { + set(color); + return *this; + } + + inline Color& ClearBackground() { + ::ClearBackground(*this); + return *this; + } + + inline Color& DrawPixel(int x, int y) { + ::DrawPixel(x, y, *this); + return *this; + } + + inline Color& DrawPixel(::Vector2 pos) { + ::DrawPixelV(pos, *this); + return *this; + } + + inline Color& DrawLine(int startPosX, int startPosY, int endPosX, int endPosY) { + ::DrawLine(startPosX, startPosY, endPosX, endPosY, *this); + return *this; + } + + inline Color& DrawLine(::Vector2 startPos, ::Vector2 endPos) { + ::DrawLineV(startPos, endPos, *this); + return *this; + } + + inline Color& DrawLine(::Vector2 startPos, ::Vector2 endPos, float thick) { + ::DrawLineEx(startPos, endPos, thick, *this); + return *this; + } + + inline Color& DrawLineBezier(::Vector2 startPos, Vector2 endPos, float thick) { + ::DrawLineBezier(startPos, endPos, thick, *this); + return *this; + } + + inline Color& DrawLineStrip(::Vector2 *points, int numPoints) { + ::DrawLineStrip(points, numPoints, *this); + return *this; + } + + inline Color& DrawText(const std::string& text, int posX, int posY, int fontSize) { + ::DrawText(text.c_str(), posX, posY, fontSize, *this); + return *this; + } + + inline Color& DrawText(::Font font, const std::string& text, ::Vector2 position, + float fontSize, float spacing) { + ::DrawTextEx(font, text.c_str(), position, fontSize, spacing, *this); + return *this; + } + + inline Color& DrawText(::Font font, const std::string& text, ::Rectangle rec, float fontSize, + float spacing, bool wordWrap = false) { + ::DrawTextRec(font, text.c_str(), rec, fontSize, spacing, wordWrap, *this); + return *this; + } + + inline Color& DrawRectangle(int posX, int posY, int width, int height) { + ::DrawRectangle(posX, posY, width, height, *this); + return *this; + } + + inline Color& DrawRectangle(Vector2 position, Vector2 size) { + ::DrawRectangleV(position, size, *this); + return *this; + } + + inline Color& DrawRectangle(Rectangle rec) { + ::DrawRectangleRec(rec, *this); + return *this; + } + + inline Color& DrawRectangle(Rectangle rec, Vector2 origin, float rotation) { + ::DrawRectanglePro(rec, origin, rotation, *this); + return *this; + } + + inline Color& DrawRectangleLines(int posX, int posY, int width, int height) { + ::DrawRectangleLines(posX, posY, width, height, *this); + return *this; + } + + inline Color& DrawRectangleLines(Rectangle rec, int lineThick) { + ::DrawRectangleLinesEx(rec, lineThick, *this); + return *this; + } + + protected: + inline void set(const ::Color& color) { + r = color.r; + g = color.g; + b = color.b; + a = color.a; + } + + inline void set(const Color& color) { + r = color.r; + g = color.g; + b = color.b; + a = color.a; + } +}; + +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_COLOR_HPP_ diff --git a/include/DroppedFiles.hpp b/include/DroppedFiles.hpp new file mode 100644 index 0000000..8dcc0ed --- /dev/null +++ b/include/DroppedFiles.hpp @@ -0,0 +1,107 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_DROPPEDFILES_HPP_ +#define RAYLIB_CPP_INCLUDE_DROPPEDFILES_HPP_ + +#include + +#include "./raylib.hpp" + +namespace raylib { +class DroppedFiles { + public: + DroppedFiles() { + Get(); + } + + /** + * Get the dropped files names. + */ + DroppedFiles& Get() { + m_files = ::GetDroppedFiles(&m_count); + return *this; + } + + /** + * Check if a file has been dropped into window. + */ + inline bool IsFileDropped() const { + return ::IsFileDropped(); + } + + /** + * Clear dropped files paths buffer. + */ + inline DroppedFiles& Clear() { + ::ClearDroppedFiles(); + return *this; + } + + ~DroppedFiles() { + Clear(); + } + + inline std::string operator[](int pos) { + return at(pos); + } + + inline int Count() const { + return m_count; + } + + inline int size() const { + return m_count; + } + + inline bool empty() const { + return m_count == 0; + } + + inline void clear() { + Clear(); + } + + inline std::string front() const { + return at(0); + } + + inline std::string back() const { + return at(m_count - 1); + } + + std::string at(int pos) const { + if (m_files != NULL && pos < m_count && pos >= 0) { + return std::string(m_files[pos]); + } + return ""; + } + + protected: + char** m_files; + int m_count; +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_DROPPEDFILES_HPP_ diff --git a/include/Font.hpp b/include/Font.hpp new file mode 100644 index 0000000..0ce67ef --- /dev/null +++ b/include/Font.hpp @@ -0,0 +1,129 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_FONT_HPP_ +#define RAYLIB_CPP_INCLUDE_FONT_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Font : public ::Font { + public: + Font() { + set(::GetFontDefault()); + } + + Font(const std::string& fileName) { + set(::LoadFont(fileName.c_str())); + } + + Font(const std::string& fileName, int fontSize, int* fontChars, int charCount) { + set(::LoadFontEx(fileName.c_str(), fontSize, fontChars, charCount)); + } + + Font(const ::Image& image, ::Color key, int firstChar) { + set(::LoadFontFromImage(image, key, firstChar)); + } + + Font(const std::string& fileType, const unsigned char *fileData, int dataSize, int fontSize, + int *fontChars, int charsCount) { + set(::LoadFontFromMemory(fileType.c_str(), fileData, dataSize, fontSize, fontChars, + charsCount)); + } + + ~Font() { + Unload(); + } + + void Unload() { + UnloadFont(*this); + } + + GETTERSETTER(int, BaseSize, baseSize) + GETTERSETTER(int, CharsCount, charsCount) + GETTERSETTER(::Texture2D, Texture, texture) + GETTERSETTER(::Rectangle*, Recs, recs) + GETTERSETTER(::CharInfo*, Chars, chars) + + Font& operator=(const ::Font& font) { + set(font); + return *this; + } + + Font& operator=(const Font& font) { + set(font); + return *this; + } + + inline Font& DrawText(const std::string& text, ::Vector2 position, float fontSize, + float spacing, ::Color tint = WHITE) { + ::DrawTextEx(*this, text.c_str(), position, fontSize, spacing, tint); + return *this; + } + + inline Font& DrawText(const std::string& text, ::Rectangle rec, float fontSize, float spacing, + bool wordWrap, ::Color tint = WHITE) { + ::DrawTextRec(*this, text.c_str(), rec, fontSize, spacing, wordWrap, tint); + return *this; + } + + inline Font& DrawText(const std::string& text, ::Rectangle rec, float fontSize, float spacing, + bool wordWrap, Color tint, int selectStart, int selectLength, ::Color selectText, + Color selectBack) { + ::DrawTextRecEx(*this, text.c_str(), rec, fontSize, spacing, wordWrap, tint, + selectStart, selectLength, selectText, selectBack); + return *this; + } + + inline Vector2 MeasureText(const std::string& text, float fontSize, float spacing) { + return ::MeasureTextEx(*this, text.c_str(), fontSize, spacing); + } + + inline int GetGlyphIndex(int character) const { + return ::GetGlyphIndex(*this, character); + } + + protected: + void set(const ::Font font) { + baseSize = font.baseSize; + charsCount = font.charsCount; + texture = font.texture; + recs = font.recs; + chars = font.chars; + } + + void set(const Font& font) { + baseSize = font.baseSize; + charsCount = font.charsCount; + texture = font.texture; + recs = font.recs; + chars = font.chars; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_FONT_HPP_ diff --git a/include/Gamepad.hpp b/include/Gamepad.hpp new file mode 100644 index 0000000..23c8a8e --- /dev/null +++ b/include/Gamepad.hpp @@ -0,0 +1,99 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_GAMEPAD_HPP_ +#define RAYLIB_CPP_INCLUDE_GAMEPAD_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Gamepad { + public: + Gamepad(int gamepadNumber = 0) { + set(gamepadNumber); + } + int number; + + GETTERSETTER(int, Number, number) + + Gamepad& operator=(const Gamepad& gamepad) { + set(gamepad); + return *this; + } + + Gamepad& operator=(int gamepadNumber) { + set(gamepadNumber); + return *this; + } + + operator int() const { return number; } + + inline bool IsAvailable() const { + return ::IsGamepadAvailable(number); + } + inline bool IsName(const std::string& name) const { + return ::IsGamepadName(number, name.c_str()); + } + std::string GetName() const { + return std::string(::GetGamepadName(number)); + } + inline bool IsButtonPressed(int button) const { + return ::IsGamepadButtonPressed(number, button); + } + + inline bool IsButtonDown(int button) const { + return ::IsGamepadButtonDown(number, button); + } + + inline bool IsButtonReleased(int button) const { + return ::IsGamepadButtonReleased(number, button); + } + + inline bool IsButtonUp(int button) const { + return ::IsGamepadButtonUp(number, button); + } + + inline int GetButtonPressed() const { + return ::GetGamepadButtonPressed(); + } + + inline int GetAxisCount() const { + return ::GetGamepadAxisCount(number); + } + + inline float GetAxisMovement(int axis) const { + return ::GetGamepadAxisMovement(number, axis); + } + + protected: + inline void set(int gamepadNumber) { + number = gamepadNumber; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_GAMEPAD_HPP_ diff --git a/include/Image.hpp b/include/Image.hpp new file mode 100644 index 0000000..dbbed69 --- /dev/null +++ b/include/Image.hpp @@ -0,0 +1,391 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_IMAGE_HPP_ +#define RAYLIB_CPP_INCLUDE_IMAGE_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Image : public ::Image { + public: + Image() {} + Image(::Image image) { + set(image); + } + Image(const std::string& fileName) { + Load(fileName); + } + Image(const std::string& fileName, int width, int height, int format, int headerSize) { + LoadRaw(fileName, width, height, format, headerSize); + } + Image(const std::string& fileName, int* frames) { + LoadAnim(fileName, frames); + } + Image(const std::string& fileType, const unsigned char* fileData, int dataSize) { + LoadFromMemory(fileType, fileData, dataSize); + } + Image(::Texture2D texture) { + set(::GetTextureData(texture)); + } + Image(int width, int height, Color color = WHITE) { + set(::GenImageColor(width, height, color)); + } + + static Image Text(std::string text, int fontSize, Color color) { + return ::ImageText(text.c_str(), fontSize, color); + } + + static Image Text(Font font, std::string text, float fontSize, float spacing, Color tint) { + return ::ImageTextEx(font, text.c_str(), fontSize, spacing, tint); + } + + static Image GetScreenData() { + return Image(::GetScreenData()); + } + + static Image GenColor(int width, int height, Color color) { + return ::GenImageColor(width, height, color); + } + + static Image GenGradientV(int width, int height, Color top, Color bottom) { + return ::GenImageGradientV(width, height, top, bottom); + } + + static Image GenGradientH(int width, int height, Color left, Color right) { + return ::GenImageGradientH(width, height, left, right); + } + + static Image GenGradientRadial(int width, int height, float density, + Color inner, Color outer) { + return ::GenImageGradientRadial(width, height, density, inner, outer); + } + + static Image GenChecked(int width, int height, int checksX, int checksY, + Color col1, Color col2) { + return ::GenImageChecked(width, height, checksX, checksY, col1, col2); + } + + static Image GenWhiteNoise(int width, int height, float factor) { + return ::GenImageWhiteNoise(width, height, factor); + } + + static Image GenPerlinNoise(int width, int height, int offsetX, int offsetY, float scale) { + return ::GenImagePerlinNoise(width, height, offsetX, offsetY, scale); + } + + static Image GenCellular(int width, int height, int tileSize) { + return ::GenImageCellular(width, height, tileSize); + } + + ~Image() { + Unload(); + } + + Image& operator=(const ::Image& image) { + set(image); + return *this; + } + + Image& operator=(const Image& image) { + set(image); + return *this; + } + + void Load(const std::string& fileName) { + set(::LoadImage(fileName.c_str())); + } + + void LoadRaw(const std::string& fileName, int width, int height, int format, int headerSize) { + set(::LoadImageRaw(fileName.c_str(), width, height, format, headerSize)); + } + + void LoadAnim(const std::string& fileName, int* frames) { + set(::LoadImageAnim(fileName.c_str(), frames)); + } + + void LoadFromMemory(const std::string& fileType, const unsigned char *fileData, int dataSize) { + set(::LoadImageFromMemory(fileType.c_str(), fileData, dataSize)); + } + + inline void Unload() { + ::UnloadImage(*this); + } + + inline Image& Export(const std::string& fileName) { + ::ExportImage(*this, fileName.c_str()); + return *this; + } + + inline Image& ExportAsCode(const std::string& fileName) { + ::ExportImageAsCode(*this, fileName.c_str()); + return *this; + } + + GETTERSETTER(void*, Data, data) + GETTERSETTER(int, Width, width) + GETTERSETTER(int, Height, height) + GETTERSETTER(int, Mipmaps, mipmaps) + GETTERSETTER(int, Format, format) + + inline Image Copy() { + return ::ImageCopy(*this); + } + inline Image FromImage(::Rectangle rec) { + return ::ImageFromImage(*this, rec); + } + + inline Image& ToPOT(Color fillColor) { + ::ImageToPOT(this, fillColor); + return *this; + } + + inline Image& Format(int newFormat) { + ::ImageFormat(this, newFormat); + return *this; + } + + inline Image& AlphaMask(Image alphaMask) { + ::ImageAlphaMask(this, alphaMask); + return *this; + } + + inline Image& AlphaCrop(float threshold) { + ::ImageAlphaCrop(this, threshold); + return *this; + } + + inline Image& AlphaPremultiply() { + ::ImageAlphaPremultiply(this); + return *this; + } + + inline Image& Crop(::Rectangle crop) { + ::ImageCrop(this, crop); + return *this; + } + inline Image& Crop(int offsetX, int offsetY, int newWidth, int newHeight) { + ::Rectangle rect{ + static_cast(offsetX), + static_cast(offsetY), + static_cast(newWidth), + static_cast(newHeight) + }; + ::ImageCrop(this, rect); + return *this; + } + + inline Image& Resize(int newWidth, int newHeight) { + ::ImageResize(this, newWidth, newHeight); + return *this; + } + + inline Image& ResizeNN(int newWidth, int newHeight) { + ::ImageResizeNN(this, newWidth, newHeight); + return *this; + } + + inline Image& ResizeCanvas(int newWidth, int newHeight, int offsetX, int offsetY, Color color) { + ::ImageResizeCanvas(this, newWidth, newHeight, offsetX, offsetY, color); + return *this; + } + + inline Image& Mipmaps() { + ::ImageMipmaps(this); + return *this; + } + + inline Image& Dither(int rBpp, int gBpp, int bBpp, int aBpp) { + ::ImageDither(this, rBpp, gBpp, bBpp, aBpp); + return *this; + } + + inline Image& FlipVertical() { + ::ImageFlipVertical(this); + return *this; + } + inline Image& FlipHorizontal() { + ::ImageFlipHorizontal(this); + return *this; + } + + inline Image& RotateCW() { + ::ImageRotateCW(this); + return *this; + } + + inline Image& RotateCCW() { + ::ImageRotateCCW(this); + return *this; + } + + inline Image& ColorTint(::Color color = WHITE) { + ::ImageColorTint(this, color); + return *this; + } + + inline Image& ColorInvert() { + ::ImageColorInvert(this); + return *this; + } + + inline Image& ColorGrayscale() { + ::ImageColorGrayscale(this); + return *this; + } + inline Image& ColorContrast(float contrast) { + ::ImageColorContrast(this, contrast); + return *this; + } + inline Image& ColorBrightness(int brightness) { + ::ImageColorBrightness(this, brightness); + return *this; + } + inline Image& ColorReplace(::Color color, ::Color replace) { + ::ImageColorReplace(this, color, replace); + return *this; + } + + inline ::Color* GetPalette(int maxPaletteSize, int *extractCount) { + return ::GetImagePalette(*this, maxPaletteSize, extractCount); + } + + inline Rectangle GetAlphaBorder(float threshold) const { + return ::GetImageAlphaBorder(*this, threshold); + } + + inline Image& ClearBackground(::Color color = WHITE) { + ::ImageClearBackground(this, color); + return *this; + } + + inline Image& DrawPixel(int posX, int posY, ::Color color) { + ::ImageDrawPixel(this, posX, posY, color); + return *this; + } + + inline Image& DrawPixel(::Vector2 position, ::Color color) { + ::ImageDrawPixelV(this, position, color); + return *this; + } + + inline Image& DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, ::Color color) { + ::ImageDrawLine(this, startPosX, startPosY, endPosX, endPosY, color); + return *this; + } + + inline Image& DrawLine(::Vector2 start, ::Vector2 end, ::Color color) { + ::ImageDrawLineV(this, start, end, color); + return *this; + } + + inline Image& DrawCircle(int centerX, int centerY, int radius, ::Color color) { + ::ImageDrawCircle(this, centerX, centerY, radius, color); + return *this; + } + + inline Image& DrawCircle(::Vector2 center, int radius, ::Color color) { + ::ImageDrawCircleV(this, center, radius, color); + return *this; + } + + inline Image& DrawRectangle(int posX, int posY, int width, int height, ::Color color = WHITE) { + ::ImageDrawRectangle(this, posX, posY, width, height, color); + return *this; + } + + inline Image& DrawRectangle(Vector2 position, Vector2 size, ::Color color = WHITE) { + ::ImageDrawRectangleV(this, position, size, color); + return *this; + } + + inline Image& DrawRectangle(::Rectangle rec, ::Color color = WHITE) { + ::ImageDrawRectangleRec(this, rec, color); + return *this; + } + + inline Image& DrawRectangleLines(::Rectangle rec, int thick, ::Color color) { + ::ImageDrawRectangleLines(this, rec, thick, color); + return *this; + } + + inline Image& Draw(const ::Image& src, ::Rectangle srcRec, ::Rectangle dstRec, + ::Color tint = WHITE) { + ::ImageDraw(this, src, srcRec, dstRec, tint); + return *this; + } + + inline Image& DrawText(const std::string& text, ::Vector2 position, int fontSize, + ::Color color = WHITE) { + ::ImageDrawText(this, + text.c_str(), + static_cast(position.x), + static_cast(position.y), + fontSize, + color); + return *this; + } + inline Image& DrawText(const std::string& text, int x, int y, int fontSize, + ::Color color = WHITE) { + ::ImageDrawText(this, text.c_str(), x, y, fontSize, color); + return *this; + } + + inline Image& DrawText(::Font font, const std::string& text, ::Vector2 position, + float fontSize, float spacing, ::Color tint = WHITE) { + ::ImageDrawTextEx(this, font, text.c_str(), position, fontSize, spacing, tint); + return *this; + } + + inline ::Color* GetImageData() { + return ::GetImageData(*this); + } + + inline ::Vector4* GetImageDataNormalized() { + return ::GetImageDataNormalized(*this); + } + + ::Texture2D LoadTexture() { + return ::LoadTextureFromImage(*this); + } + + inline operator ::Texture2D() { + return LoadTexture(); + } + + protected: + inline void set(::Image image) { + data = image.data; + width = image.width; + height = image.height; + mipmaps = image.mipmaps; + format = image.format; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_IMAGE_HPP_ diff --git a/include/Material.hpp b/include/Material.hpp new file mode 100644 index 0000000..bc5962f --- /dev/null +++ b/include/Material.hpp @@ -0,0 +1,76 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MATERIAL_HPP_ +#define RAYLIB_CPP_INCLUDE_MATERIAL_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Material : public ::Material { + public: + Material(::Material material) { + set(material); + } + + Material() { + set(LoadMaterialDefault()); + } + + ~Material() { + Unload(); + } + + GETTERSETTER(::Shader, Shader, shader) + + Material& operator=(const ::Material& material) { + set(material); + return *this; + } + + Material& operator=(const Material& material) { + set(material); + return *this; + } + + inline void Unload() { + ::UnloadMaterial(*this); + } + + inline Material& SetTexture(int mapType, ::Texture2D texture) { + ::SetMaterialTexture(this, mapType, texture); + return *this; + } + + protected: + inline void set(::Material material) { + shader = material.shader; + maps = material.maps; + params = material.params; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MATERIAL_HPP_ diff --git a/include/Matrix.hpp b/include/Matrix.hpp new file mode 100644 index 0000000..e287d0d --- /dev/null +++ b/include/Matrix.hpp @@ -0,0 +1,260 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MATRIX_HPP_ +#define RAYLIB_CPP_INCLUDE_MATRIX_HPP_ + +#ifdef __cplusplus +extern "C" { +#endif +#include "raylib.h" // NOLINT +#ifndef RAYLIB_CPP_NO_MATH +#include "raymath.h" // NOLINT +#endif +#ifdef __cplusplus +} +#endif + +#ifndef RAYLIB_CPP_NO_MATH +#include +#endif + +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Matrix : public ::Matrix { + public: + Matrix(::Matrix mat) { + set(mat); + } + + Matrix(float M0 = 0, float M1 = 0, float M2 = 0, float M3 = 0, float M4 = 0, float M5 = 0, + float M6 = 0, float M7 = 0, float M8 = 0, float M9 = 0, float M10 = 0, float M11 = 0, + float M12 = 0, float M13 = 0, float M14 = 0, float M15 = 0) { + m0 = M0; + m1 = M1; + m2 = M2; + m3 = M3; + m4 = M4; + m5 = M5; + m6 = M6; + m7 = M7; + m8 = M8; + m9 = M9; + m10 = M10; + m11 = M11; + m12 = M12; + m13 = M13; + m14 = M14; + m15 = M15; + } + + GETTERSETTER(float, M0, m0) + GETTERSETTER(float, M1, m1) + GETTERSETTER(float, M2, m2) + GETTERSETTER(float, M3, m3) + GETTERSETTER(float, M4, m4) + GETTERSETTER(float, M5, m5) + GETTERSETTER(float, M6, m6) + GETTERSETTER(float, M7, m7) + GETTERSETTER(float, M8, m8) + GETTERSETTER(float, M9, m9) + GETTERSETTER(float, M10, m10) + GETTERSETTER(float, M11, m11) + GETTERSETTER(float, M12, m12) + GETTERSETTER(float, M13, m13) + GETTERSETTER(float, M14, m14) + GETTERSETTER(float, M15, m15) + + Matrix& operator=(const ::Matrix& matrix) { + set(matrix); + return *this; + } + + Matrix& operator=(const Matrix& matrix) { + set(matrix); + return *this; + } + + bool operator==(const Matrix& other) { + return m0 == other.m0 + && m1 == other.m1 + && m2 == other.m2 + && m3 == other.m3 + && m4 == other.m4 + && m5 == other.m5 + && m6 == other.m6 + && m7 == other.m7 + && m8 == other.m8 + && m9 == other.m9 + && m10 == other.m10 + && m11 == other.m11 + && m12 == other.m12 + && m13 == other.m13 + && m14 == other.m14 + && m15 == other.m15; + } + + inline Matrix& SetProjection() { + ::SetMatrixProjection(*this); + return *this; + } + + inline Matrix& SetModelview() { + ::SetMatrixModelview(*this); + return *this; + } + + static Matrix GetModelview() { + return ::GetMatrixModelview(); + } + + static Matrix GetProjection() { + return ::GetMatrixProjection(); + } + +#ifndef RAYLIB_CPP_NO_MATH + inline float Trace() { + return ::MatrixTrace(*this); + } + + inline Matrix Transpose() { + return ::MatrixTranspose(*this); + } + + inline Matrix Invert() { + return ::MatrixInvert(*this); + } + + inline Matrix Normalize() { + return ::MatrixNormalize(*this); + } + + static Matrix Identity() { + return ::MatrixIdentity(); + } + + Matrix Add(::Matrix right) { + return ::MatrixAdd(*this, right); + } + + Matrix operator+(const Matrix& matrix) { + return ::MatrixAdd(*this, matrix); + } + + Matrix Subtract(::Matrix right) { + return ::MatrixSubtract(*this, right); + } + + Matrix operator-(const Matrix& matrix) { + return ::MatrixSubtract(*this, matrix); + } + + static Matrix Translate(float x, float y, float z) { + return ::MatrixTranslate(x, y, z); + } + + static Matrix Rotate(Vector3 axis, float angle) { + return ::MatrixRotate(axis, angle); + } + + static Matrix RotateXYZ(Vector3 angle) { + return ::MatrixRotateXYZ(angle); + } + + static Matrix RotateX(float angle) { + return ::MatrixRotateX(angle); + } + + static Matrix RotateY(float angle) { + return ::MatrixRotateY(angle); + } + + static Matrix RotateZ(float angle) { + return ::MatrixRotateZ(angle); + } + + static Matrix Scale(float x, float y, float z) { + return ::MatrixScale(x, y, z); + } + + Matrix Multiply(Matrix right) { + return ::MatrixMultiply(*this, right); + } + + Matrix operator*(const Matrix& matrix) { + return ::MatrixMultiply(*this, matrix); + } + + static Matrix Frustum(double left, double right, double bottom, double top, + double near, double far) { + return ::MatrixFrustum(left, right, bottom, top, near, far); + } + + static Matrix Perspective(double fovy, double aspect, double near, double far) { + return ::MatrixPerspective(fovy, aspect, near, far); + } + + static Matrix Ortho(double left, double right, double bottom, double top, + double near, double far) { + return ::MatrixOrtho(left, right, bottom, top, near, far); + } + + static Matrix LookAt(Vector3 eye, Vector3 target, Vector3 up) { + return ::MatrixLookAt(eye, target, up); + } + + inline float16 ToFloatV() { + return ::MatrixToFloatV(*this); + } + + operator float16() { + return ToFloatV(); + } +#endif + + protected: + inline void set(::Matrix mat) { + m0 = mat.m0; + m1 = mat.m1; + m2 = mat.m2; + m3 = mat.m3; + m4 = mat.m4; + m5 = mat.m5; + m6 = mat.m6; + m7 = mat.m7; + m8 = mat.m8; + m9 = mat.m9; + m10 = mat.m10; + m11 = mat.m11; + m12 = mat.m12; + m13 = mat.m13; + m14 = mat.m14; + m15 = mat.m15; + } +}; +} // namespace raylib + + +#endif // RAYLIB_CPP_INCLUDE_MATRIX_HPP_ diff --git a/include/Mesh.hpp b/include/Mesh.hpp new file mode 100644 index 0000000..d582ef8 --- /dev/null +++ b/include/Mesh.hpp @@ -0,0 +1,125 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MESH_HPP_ +#define RAYLIB_CPP_INCLUDE_MESH_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "./BoundingBox.hpp" +#include "./Model.hpp" + +namespace raylib { +class Mesh : public ::Mesh { + public: + Mesh(::Mesh mesh) { + set(mesh); + } + + Mesh(int VertexCount = 0, int TriangleCount = 0) { + vertexCount = VertexCount; + triangleCount = TriangleCount; + } + + GETTERSETTER(int, VertexCount, vertexCount) + GETTERSETTER(int, TriangleCount, triangleCount) + + Mesh& operator=(const ::Mesh& mesh) { + set(mesh); + return *this; + } + + Mesh& operator=(const Mesh& mesh) { + set(mesh); + return *this; + } + + ~Mesh() { + Unload(); + } + + inline Mesh& Export(const std::string& fileName) { + ExportMesh(*this, fileName.c_str()); + return *this; + } + + inline void Unload() { + ::UnloadMesh(*this); + } + + inline raylib::BoundingBox BoundingBox() { + return ::MeshBoundingBox(*this); + } + + operator raylib::BoundingBox() { + return BoundingBox(); + } + + inline Mesh& Tangents() { + ::MeshTangents(this); + return *this; + } + + inline Mesh& Binormals() { + ::MeshBinormals(this); + return *this; + } + + inline Mesh& NormalsSmooth() { + ::MeshNormalsSmooth(this); + return *this; + } + + inline raylib::Model LoadModelFrom() { + return ::LoadModelFromMesh(*this); + } + + operator raylib::Model() { + return LoadModelFrom(); + } + + protected: + inline void set(::Mesh mesh) { + vertexCount = mesh.vertexCount; + triangleCount = mesh.triangleCount; + vertices = mesh.vertices; + texcoords = mesh.texcoords; + texcoords2 = mesh.texcoords2; + normals = mesh.normals; + tangents = mesh.tangents; + colors = mesh.colors; + indices = mesh.indices; + animVertices = mesh.animVertices; + animNormals = mesh.animNormals; + boneIds = mesh.boneIds; + boneWeights = mesh.boneWeights; + vaoId = mesh.vaoId; + vboId = mesh.vboId; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MESH_HPP_ diff --git a/include/Model.hpp b/include/Model.hpp new file mode 100644 index 0000000..d8c8f9d --- /dev/null +++ b/include/Model.hpp @@ -0,0 +1,107 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MODEL_HPP_ +#define RAYLIB_CPP_INCLUDE_MODEL_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "./Mesh.hpp" + +namespace raylib { +class Model : public ::Model { + public: + Model(::Model model) { + set(model); + } + + Model(const std::string& fileName) { + set(LoadModel(fileName.c_str())); + } + + Model(::Mesh mesh) { + set(LoadModelFromMesh(mesh)); + } + + ~Model() { + Unload(); + } + + GETTERSETTER(::Matrix, Transform, transform) + GETTERSETTER(int, MeshCount, meshCount) + GETTERSETTER(int, MaterialCount, materialCount) + GETTERSETTER(int, BoneCount, boneCount) + + Model& operator=(const ::Model& model) { + set(model); + return *this; + } + + Model& operator=(const Model& model) { + set(model); + return *this; + } + + inline void Unload() { + ::UnloadModel(*this); + } + + inline Model& SetMeshMaterial(int meshId, int materialId) { + ::SetModelMeshMaterial(this, meshId, materialId); + return *this; + } + + inline RayHitInfo GetCollision(::Ray ray) const { + return ::GetCollisionRayModel(ray, *this); + } + + inline Model& UpdateModelAnimation(::ModelAnimation anim, int frame) { + ::UpdateModelAnimation(*this, anim, frame); + return *this; + } + + inline bool IsModelAnimationValid(::ModelAnimation anim) const { + return ::IsModelAnimationValid(*this, anim); + } + + protected: + inline void set(::Model model) { + transform = model.transform; + + meshCount = model.meshCount; + materialCount = model.materialCount; + meshes = model.meshes; + materials = model.materials; + meshMaterial = model.meshMaterial; + + boneCount = model.boneCount; + bones = model.bones; + bindPose = model.bindPose; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MODEL_HPP_ diff --git a/include/ModelAnimation.hpp b/include/ModelAnimation.hpp new file mode 100644 index 0000000..273ded0 --- /dev/null +++ b/include/ModelAnimation.hpp @@ -0,0 +1,85 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MODELANIMATION_HPP_ +#define RAYLIB_CPP_INCLUDE_MODELANIMATION_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "./Mesh.hpp" + +namespace raylib { +class ModelAnimation : public ::ModelAnimation { + public: + ModelAnimation(::ModelAnimation model) { + set(model); + } + + ~ModelAnimation() { + Unload(); + } + + GETTERSETTER(int, BoneCount, boneCount) + GETTERSETTER(::BoneInfo*, Bones, bones) + GETTERSETTER(int, FrameCount, frameCount) + GETTERSETTER(::Transform**, FramePoses, framePoses) + + ModelAnimation& operator=(const ::ModelAnimation& model) { + set(model); + return *this; + } + + ModelAnimation& operator=(const ModelAnimation& model) { + set(model); + return *this; + } + + inline void Unload() { + ::UnloadModelAnimation(*this); + } + + inline ModelAnimation& UpdateAnimation(::Model model, int frame) { + ::UpdateModelAnimation(model, *this, frame); + return *this; + } + + inline bool IsValid(::Model model) const { + return ::IsModelAnimationValid(model, *this); + } + + inline bool IsModelAnimationValid(::Model model) const { + return ::IsModelAnimationValid(model, *this); + } + + protected: + inline void set(::ModelAnimation model) { + boneCount = model.boneCount; + bones = model.bones; + frameCount = model.frameCount; + framePoses = model.framePoses; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MODELANIMATION_HPP_ diff --git a/include/Mouse.hpp b/include/Mouse.hpp new file mode 100644 index 0000000..39f02cd --- /dev/null +++ b/include/Mouse.hpp @@ -0,0 +1,115 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MOUSE_HPP_ +#define RAYLIB_CPP_INCLUDE_MOUSE_HPP_ + +#include "./raylib.hpp" + +#include "./Vector2.hpp" + +namespace raylib { +class Mouse { + public: + inline bool IsButtonPressed(int button) const { + return ::IsMouseButtonPressed(button); + } + + inline bool IsButtonDown(int button) const { + return ::IsMouseButtonDown(button); + } + + inline bool IsButtonReleased(int button) const { + return ::IsMouseButtonReleased(button); + } + + inline bool IsButtonUp(int button) const { + return ::IsMouseButtonUp(button); + } + + inline int GetX() const { + return ::GetMouseX(); + } + + inline int GetY() const { + return ::GetMouseY(); + } + + inline Mouse& SetX(int x) { + ::SetMouseOffset(x, GetY()); + return *this; + } + + inline Mouse& SetY(int y) { + ::SetMouseOffset(GetX(), y); + return *this; + } + + inline Vector2 GetPosition() const { + return ::GetMousePosition(); + } + + inline Mouse& SetPosition(int x, int y) { + ::SetMousePosition(x, y); + return *this; + } + + inline Mouse& SetOffset(int offsetX, int offsetY) { + ::SetMouseOffset(offsetX, offsetY); + return *this; + } + + inline Mouse& SetScale(float scaleX, float scaleY) { + ::SetMouseScale(scaleX, scaleY); + return *this; + } + + inline float GetWheelMove() const { + return ::GetMouseWheelMove(); + } + + inline int GetCursor() const { + return ::GetMouseCursor(); + } + + inline Mouse& SetCursor(int cursor) { + ::SetMouseCursor(cursor); + return *this; + } + + inline int GetTouchX() const { + return ::GetTouchX(); + } + + inline int GetTouchY() const { + return ::GetTouchY(); + } + + inline Vector2 GetTouchPosition(int index) const { + return ::GetTouchPosition(index); + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MOUSE_HPP_ diff --git a/include/Music.hpp b/include/Music.hpp new file mode 100644 index 0000000..703b4bd --- /dev/null +++ b/include/Music.hpp @@ -0,0 +1,124 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_MUSIC_HPP_ +#define RAYLIB_CPP_INCLUDE_MUSIC_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Music : public ::Music { + public: + Music(::Music music) { + set(music); + } + + Music(const std::string& fileName) { + set(::LoadMusicStream(fileName.c_str())); + } + + ~Music() { + Unload(); + } + + GETTERSETTER(int, CtxType, ctxType) + GETTERSETTER(bool, Looping, looping) + GETTERSETTER(unsigned int, SampleCount, sampleCount) + + Music& operator=(const ::Music& music) { + set(music); + return *this; + } + + Music& operator=(const Music& music) { + set(music); + return *this; + } + + inline void Unload() { + ::UnloadMusicStream(*this); + } + + inline Music& Play() { + ::PlayMusicStream(*this); + return *this; + } + + inline Music& Update() { + ::UpdateMusicStream(*this); + return *this; + } + + inline Music& Stop() { + ::StopMusicStream(*this); + return *this; + } + + inline Music& Pause() { + ::PauseMusicStream(*this); + return *this; + } + + inline Music& Resume() { + ::ResumeMusicStream(*this); + return *this; + } + + inline bool IsPlaying() const { + return ::IsMusicPlaying(*this); + } + + inline Music& SetVolume(float volume) { + ::SetMusicVolume(*this, volume); + return *this; + } + + inline Music& SetPitch(float pitch) { + ::SetMusicPitch(*this, pitch); + return *this; + } + + inline float GetTimeLength() const { + return ::GetMusicTimeLength(*this); + } + + inline float GetTimePlayed() const { + return ::GetMusicTimePlayed(*this); + } + + protected: + inline void set(::Music music) { + ctxType = music.ctxType; + ctxData = music.ctxData; + looping = music.looping; + sampleCount = music.sampleCount; + stream = music.stream; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_MUSIC_HPP_ diff --git a/include/Physics.hpp b/include/Physics.hpp new file mode 100644 index 0000000..ce202fd --- /dev/null +++ b/include/Physics.hpp @@ -0,0 +1,152 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_PHYSICS_HPP_ +#define RAYLIB_CPP_INCLUDE_PHYSICS_HPP_ + +#include "./raylib.hpp" + +#ifdef __cplusplus +extern "C" { +#endif +#include "physac.h" // NOLINT +#ifdef __cplusplus +} +#endif + +#include "./Vector2.hpp" + +namespace raylib { +class Physics { + public: + Physics() { + Init(); + } + Physics(float gravityY) { + Init(); + SetGravity(0, gravityY); + } + Physics(float gravityX, float gravityY) { + Init(); + SetGravity(gravityX, gravityY); + } + + ~Physics() { + Close(); + } + + inline Physics& Init() { + ::InitPhysics(); + return *this; + } + + inline Physics& Close() { + ::ClosePhysics(); + return *this; + } + + inline Physics& RunStep() { + ::RunPhysicsStep(); + return *this; + } + + inline Physics& SetTimeStep(double delta) { + ::SetPhysicsTimeStep(delta); + return *this; + } + + inline bool IsEnabled() { + return ::IsPhysicsEnabled(); + } + + inline Physics& SetGravity(float x, float y) { + ::SetPhysicsGravity(x, y); + return *this; + } + + inline PhysicsBody CreateBodyCircle(Vector2 pos, float radius, float density) { + return ::CreatePhysicsBodyCircle(pos, radius, density); + } + + inline PhysicsBody CreateBodyRectangle(Vector2 pos, float width, float height, float density) { + return ::CreatePhysicsBodyRectangle(pos, width, height, density); + } + + inline PhysicsBody CreateBodyPolygon(Vector2 pos, float radius, int sides, float density) { + return ::CreatePhysicsBodyPolygon(pos, radius, sides, density); + } + + inline Physics& AddForce(PhysicsBody body, Vector2 force) { + ::PhysicsAddForce(body, force); + return *this; + } + + inline Physics& AddTorque(PhysicsBody body, float amount) { + ::PhysicsAddTorque(body, amount); + return *this; + } + + inline Physics& Shatter(PhysicsBody body, Vector2 position, float force) { + ::PhysicsShatter(body, position, force); + return *this; + } + + inline int GetBodiesCount() const { + return ::GetPhysicsBodiesCount(); + } + + inline PhysicsBody GetBody(int index) const { + return ::GetPhysicsBody(index); + } + + inline int GetShapeType(int index) const { + return ::GetPhysicsShapeType(index); + } + + inline int GetShapeVerticesCount(int index) const { + return ::GetPhysicsShapeVerticesCount(index); + } + + inline Vector2 GetShapeVertex(PhysicsBody body, int vertex) const { + return ::GetPhysicsShapeVertex(body, vertex); + } + + inline Physics& SetBodyRotation(PhysicsBody body, float radians) { + ::SetPhysicsBodyRotation(body, radians); + return *this; + } + + inline Physics& DestroyBody(PhysicsBody body) { + ::DestroyPhysicsBody(body); + return *this; + } + + inline Physics& Reset() { + ::ResetPhysics(); + return *this; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_PHYSICS_HPP_ diff --git a/include/Ray.hpp b/include/Ray.hpp new file mode 100644 index 0000000..859f122 --- /dev/null +++ b/include/Ray.hpp @@ -0,0 +1,101 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RAY_HPP_ +#define RAYLIB_CPP_INCLUDE_RAY_HPP_ + +#include "./raylib.hpp" + +#include "./raylib-cpp-utils.hpp" + +#include "./RayHitInfo.hpp" + +namespace raylib { +class Ray : public ::Ray { + public: + Ray(::Ray ray) { + set(ray); + } + + Ray(::Vector3 Position, ::Vector3 Direction) { + position = Position; + direction = Direction; + } + + Ray(::Vector2 mousePosition, ::Camera camera) { + set(GetMouseRay(mousePosition, camera)); + } + + Ray& operator=(const ::Ray& ray) { + set(ray); + return *this; + } + + Ray& operator=(const Ray& ray) { + set(ray); + return *this; + } + + GETTERSETTER(::Vector3, Position, position) + GETTERSETTER(::Vector3, Direction, direction) + + inline Ray& Draw(::Color color) { + DrawRay(*this, color); + return *this; + } + + inline bool CheckCollisionSphere(::Vector3 center, float radius) const { + return CheckCollisionRaySphere(*this, center, radius); + } + + inline bool CheckCollisionSphereEx(::Vector3 center, float radius, + ::Vector3 *collisionPoint) const { + return CheckCollisionRaySphereEx(*this, center, radius, collisionPoint); + } + + inline bool CheckCollisionBox(::BoundingBox box) const { + return CheckCollisionRayBox(*this, box); + } + + inline RayHitInfo GetCollisionModel(::Model model) { + return GetCollisionRayModel(*this, model); + } + + inline RayHitInfo GetCollisionTriangle(::Vector3 p1, ::Vector3 p2, ::Vector3 p3) { + return GetCollisionRayTriangle(*this, p1, p2, p3); + } + + inline RayHitInfo GetCollisionGround(float groundHeight) { + return GetCollisionRayGround(*this, groundHeight); + } + + protected: + inline void set(::Ray ray) { + position = ray.position; + direction = ray.direction; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_RAY_HPP_ diff --git a/include/RayHitInfo.hpp b/include/RayHitInfo.hpp new file mode 100644 index 0000000..0da12a3 --- /dev/null +++ b/include/RayHitInfo.hpp @@ -0,0 +1,70 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RAYHITINFO_HPP_ +#define RAYLIB_CPP_INCLUDE_RAYHITINFO_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class RayHitInfo : public ::RayHitInfo { + public: + RayHitInfo(::RayHitInfo ray) { + set(ray); + } + + RayHitInfo(bool Hit, float Distance, ::Vector3 Position, ::Vector3 Normal) { + hit = Hit; + distance = Distance; + position = Position; + normal = Normal; + } + + RayHitInfo& operator=(const ::RayHitInfo& ray) { + set(ray); + return *this; + } + + RayHitInfo& operator=(const RayHitInfo& ray) { + set(ray); + return *this; + } + + GETTERSETTER(bool, Hit, hit) + GETTERSETTER(float, Distance, distance) + GETTERSETTER(::Vector3, Position, position) + GETTERSETTER(::Vector3, Normal, normal) + + protected: + inline void set(::RayHitInfo ray) { + hit = ray.hit; + distance = ray.distance; + position = ray.position; + normal = ray.normal; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_RAYHITINFO_HPP_ diff --git a/include/Rectangle.hpp b/include/Rectangle.hpp new file mode 100644 index 0000000..a736c4b --- /dev/null +++ b/include/Rectangle.hpp @@ -0,0 +1,131 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RECTANGLE_HPP_ +#define RAYLIB_CPP_INCLUDE_RECTANGLE_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "./Vector2.hpp" + +namespace raylib { +class Rectangle : public ::Rectangle { + public: + Rectangle(::Rectangle vec) { + set(vec); + } + + Rectangle(float X = 0, float Y = 0, float Width = 0, float Height = 0) { + x = X; + y = Y; + width = Width; + height = Height; + } + + GETTERSETTER(float, X, x) + GETTERSETTER(float, Y, y) + GETTERSETTER(float, Width, width) + GETTERSETTER(float, Height, height) + + Rectangle& operator=(const ::Rectangle& rect) { + set(rect); + return *this; + } + + Rectangle& operator=(const Rectangle& rect) { + set(rect); + return *this; + } + + inline Rectangle& Draw(::Color color) { + ::DrawRectangle(static_cast(x), static_cast(y), static_cast(width), + static_cast(height), color); + return *this; + } + inline Rectangle& Draw(::Vector2 origin, float rotation, ::Color color) { + ::DrawRectanglePro(*this, origin, rotation, color); + return *this; + } + + inline Rectangle& DrawGradientV(::Color color1, ::Color color2) { + ::DrawRectangleGradientV(static_cast(x), static_cast(y), static_cast(width), + static_cast(height), color1, color2); + return *this; + } + + inline Rectangle& DrawGradientH(::Color color1, ::Color color2) { + ::DrawRectangleGradientH(static_cast(x), static_cast(y), static_cast(width), + static_cast(height), color1, color2); + return *this; + } + + inline Rectangle& DrawGradient(::Color col1, ::Color col2, ::Color col3, ::Color col4) { + ::DrawRectangleGradientEx(*this, col1, col2, col3, col4); + return *this; + } + + inline Rectangle& DrawLines(::Color color) { + ::DrawRectangleLines(static_cast(x), static_cast(y), static_cast(width), + static_cast(height), color); + return *this; + } + inline Rectangle& DrawLinesEx(int lineThick, ::Color color) { + ::DrawRectangleLinesEx(*this, lineThick, color); + return *this; + } + + inline Rectangle& DrawRounded(float roundness, int segments, ::Color color) { + ::DrawRectangleRounded(*this, roundness, segments, color); + return *this; + } + + inline Rectangle& DrawRoundedLines(float roundness, int segments, int lineThick, + ::Color color) { + ::DrawRectangleRoundedLines(*this, roundness, segments, lineThick, color); + return *this; + } + + inline bool CheckCollision(::Rectangle rec2) const { + return ::CheckCollisionRecs(*this, rec2); + } + + inline Rectangle GetCollision(::Rectangle rec2) const { + return ::GetCollisionRec(*this, rec2); + } + + inline bool CheckCollision(::Vector2 point) const { + return ::CheckCollisionPointRec(point, *this); + } + + protected: + inline void set(::Rectangle rect) { + x = rect.x; + y = rect.y; + width = rect.width; + height = rect.height; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_RECTANGLE_HPP_ diff --git a/include/RenderTexture.hpp b/include/RenderTexture.hpp new file mode 100644 index 0000000..b48204d --- /dev/null +++ b/include/RenderTexture.hpp @@ -0,0 +1,88 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_ +#define RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class RenderTexture : public ::RenderTexture { + public: + RenderTexture(::RenderTexture renderTexture) { + set(renderTexture); + } + + RenderTexture(unsigned int Id) { + id = Id; + } + + RenderTexture(int width, int height) { + set(LoadRenderTexture(width, height)); + } + + GETTERSETTER(unsigned int, Id, id) + GETTERSETTER(::Texture2D, Texture, texture) + GETTERSETTER(::Texture2D, Depth, depth) + + RenderTexture& operator=(const ::RenderTexture& texture) { + set(texture); + return *this; + } + + RenderTexture& operator=(const RenderTexture& texture) { + set(texture); + return *this; + } + + ~RenderTexture() { + Unload(); + } + + inline void Unload() { + UnloadRenderTexture(*this); + } + + inline RenderTexture& BeginTextureMode() { + ::BeginTextureMode(*this); + return *this; + } + + inline RenderTexture& EndTextureMode() { + ::EndTextureMode(); + return *this; + } + + protected: + inline void set(::RenderTexture renderTexture) { + id = renderTexture.id; + texture = renderTexture.texture; + depth = renderTexture.depth; + } +}; +typedef RenderTexture RenderTexture2D; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_RENDERTEXTURE_HPP_ diff --git a/include/Shader.hpp b/include/Shader.hpp new file mode 100644 index 0000000..bb84ac3 --- /dev/null +++ b/include/Shader.hpp @@ -0,0 +1,150 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_SHADER_HPP_ +#define RAYLIB_CPP_INCLUDE_SHADER_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "Texture.hpp" + +namespace raylib { +class Shader : public ::Shader { + public: + Shader(::Shader shader) { + set(shader); + } + + Shader(unsigned int Id, int* Locs) { + id = Id; + locs = Locs; + } + + Shader() { + set(GetShaderDefault()); + } + + GETTERSETTER(unsigned int, Id, id) + GETTERSETTER(int*, Locs, locs) + + Shader& operator=(const ::Shader& shader) { + set(shader); + return *this; + } + + Shader& operator=(const Shader& shader) { + set(shader); + return *this; + } + + ~Shader() { + Unload(); + } + + void Unload() { + ::UnloadShader(*this); + } + + static Shader Load(const std::string& vsFileName, const std::string& fsFileName) { + return ::LoadShader(vsFileName.c_str(), fsFileName.c_str()); + } + + static Shader LoadCode(const std::string& vsCode, const std::string& fsCode) { + return ::LoadShaderCode(vsCode.c_str(), fsCode.c_str()); + } + + inline Shader& BeginShaderMode() { + ::BeginShaderMode(*this); + return *this; + } + + inline Shader& EndShaderMode() { + ::EndShaderMode(); + return *this; + } + + inline int GetLocation(const std::string& uniformName) const { + return ::GetShaderLocation(*this, uniformName.c_str()); + } + + inline int GetLocationAttrib(const std::string& attribName) const { + return ::GetShaderLocationAttrib(*this, attribName.c_str()); + } + + inline Shader& SetValue(int uniformLoc, const std::string& value, int uniformType) { + ::SetShaderValue(*this, uniformLoc, value.c_str(), uniformType); + return *this; + } + + /** + * @see SetShaderValueV + */ + inline Shader& SetValue(int uniformLoc, const std::string& value, int uniformType, int count) { + ::SetShaderValueV(*this, uniformLoc, value.c_str(), uniformType, count); + return *this; + } + + /** + * @see ::SetShaderValueMatrix + */ + inline Shader& SetValue(int uniformLoc, Matrix mat) { + ::SetShaderValueMatrix(*this, uniformLoc, mat); + return *this; + } + + /** + * @see ::SetShaderValueTexture + */ + inline Shader& SetValue(int uniformLoc, Texture2D texture) { + ::SetShaderValueTexture(*this, uniformLoc, texture); + return *this; + } + + ::TextureCubemap GenTextureCubemap(Texture2D panorama, int size, int format) { + return ::GenTextureCubemap(*this, panorama, size, format); + } + + ::TextureCubemap GenTextureIrradiance(Texture2D panorama, int size) { + return ::GenTextureIrradiance(*this, panorama, size); + } + + ::TextureCubemap GenTexturePrefilter(Texture2D panorama, int size) { + return ::GenTexturePrefilter(*this, panorama, size); + } + + ::Texture2D GenTextureBRDF(int size) { + return ::GenTextureBRDF(*this, size); + } + + protected: + inline void set(::Shader shader) { + id = shader.id; + locs = shader.locs; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_SHADER_HPP_ diff --git a/include/Sound.hpp b/include/Sound.hpp new file mode 100644 index 0000000..907d987 --- /dev/null +++ b/include/Sound.hpp @@ -0,0 +1,125 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_SOUND_HPP_ +#define RAYLIB_CPP_INCLUDE_SOUND_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Sound : public ::Sound { + public: + Sound(::Sound vec) { + set(vec); + } + + Sound(const std::string& fileName) { + set(LoadSound(fileName.c_str())); + } + + Sound(::Wave wave) { + set(LoadSoundFromWave(wave)); + } + + ~Sound() { + Unload(); + } + + GETTERSETTER(unsigned int, SampleCount, sampleCount) + GETTERSETTER(::AudioStream, Stream, stream) + + Sound& operator=(const ::Sound& sound) { + set(sound); + return *this; + } + + Sound& operator=(const Sound& sound) { + set(sound); + return *this; + } + + inline Sound& Update(const void *data, int sampleCount) { + ::UpdateSound(*this, data, sampleCount); + return *this; + } + + inline void Unload() { + ::UnloadSound(*this); + } + + inline Sound& Play() { + ::PlaySound(*this); + return *this; + } + + inline Sound& Stop() { + ::StopSound(*this); + return *this; + } + + inline Sound& Pause() { + ::PauseSound(*this); + return *this; + } + inline Sound& Resume() { + ::ResumeSound(*this); + return *this; + } + + inline Sound& PlayMulti() { + ::PlaySoundMulti(*this); + return *this; + } + + inline Sound& StopMulti() { + ::StopSoundMulti(); + return *this; + } + + inline bool IsPlaying() const { + return ::IsSoundPlaying(*this); + } + + inline Sound& SetVolume(float volume) { + ::SetSoundVolume(*this, volume); + return *this; + } + + inline Sound& SetPitch(float pitch) { + ::SetSoundPitch(*this, pitch); + return *this; + } + + protected: + inline void set(::Sound sound) { + sampleCount = sound.sampleCount; + stream = sound.stream; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_SOUND_HPP_ diff --git a/include/Texture.hpp b/include/Texture.hpp new file mode 100644 index 0000000..ab667a2 --- /dev/null +++ b/include/Texture.hpp @@ -0,0 +1,194 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_TEXTURE_HPP_ +#define RAYLIB_CPP_INCLUDE_TEXTURE_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" +#include "./Vector2.hpp" +#include "./Material.hpp" + +namespace raylib { +class Texture : public ::Texture { + public: + Texture() { + set(::GetTextureDefault()); + } + + Texture(const ::Image& image) { + LoadFromImage(image); + } + + Texture(const std::string& fileName) { + Load(fileName); + } + + ~Texture() { + Unload(); + } + + GETTERSETTER(unsigned int, Id, id) + GETTERSETTER(int, Width, width) + GETTERSETTER(int, Height, height) + GETTERSETTER(int, Mipmaps, mipmaps) + GETTERSETTER(int, Format, format) + + Texture& operator=(const ::Texture& texture) { + set(texture); + return *this; + } + + Texture& operator=(const Texture& texture) { + set(texture); + return *this; + } + + void LoadFromImage(const ::Image& image) { + set(::LoadTextureFromImage(image)); + } + + void LoadTextureCubemap(const ::Image& image, int layoutType) { + set(::LoadTextureCubemap(image, layoutType)); + } + + void Load(const std::string& fileName) { + set(::LoadTexture(fileName.c_str())); + } + + inline void Unload() { + ::UnloadTexture(*this); + } + + inline Texture& Update(const void *pixels) { + ::UpdateTexture(*this, pixels); + return *this; + } + + inline Texture& UpdateRec(Rectangle rec, const void *pixels) { + UpdateTextureRec(*this, rec, pixels); + return *this; + } + + inline Image GetTextureData() const { + return ::GetTextureData(*this); + } + + inline operator raylib::Image() { + return GetTextureData(); + } + + inline Texture& GenMipmaps() { + ::GenTextureMipmaps(this); + return *this; + } + + inline Texture& SetFilter(int filterMode) { + ::SetTextureFilter(*this, filterMode); + return *this; + } + + inline Texture& SetWrap(int wrapMode) { + ::SetTextureWrap(*this, wrapMode); + return *this; + } + + inline Texture& Draw(int posX, int posY, ::Color tint = WHITE) { + ::DrawTexture(*this, posX, posY, tint); + return *this; + } + + inline Texture& Draw(::Vector2 position, ::Color tint = WHITE) { + ::DrawTextureV(*this, position, tint); + return *this; + } + + inline Texture& Draw(::Vector2 position, float rotation, float scale = 1.0f, + ::Color tint = WHITE) { + ::DrawTextureEx(*this, position, rotation, scale, tint); + return *this; + } + + inline Texture& Draw(::Rectangle sourceRec, ::Vector2 position, ::Color tint = WHITE) { + ::DrawTextureRec(*this, sourceRec, position, tint); + return *this; + } + + inline Texture& Draw(::Vector2 tiling, ::Vector2 offset, ::Rectangle quad, + ::Color tint = WHITE) { + ::DrawTextureQuad(*this, tiling, offset, quad, tint); + return *this; + } + + inline Texture& Draw(::Rectangle sourceRec, ::Rectangle destRec, ::Vector2 origin, + float rotation = 0, ::Color tint = WHITE) { + ::DrawTexturePro(*this, sourceRec, destRec, origin, rotation, tint); + return *this; + } + + inline Texture& Draw(::NPatchInfo nPatchInfo, ::Rectangle destRec, ::Vector2 origin, + float rotation = 0, ::Color tint = WHITE) { + ::DrawTextureNPatch(*this, nPatchInfo, destRec, origin, rotation, tint); + return *this; + } + + inline Texture& Draw(::Vector3 position, float width, float height, float length, + ::Color color = WHITE) { + ::DrawCubeTexture(*this, position, width, height, length, color); + return *this; + } + + inline Texture& DrawTiled(Rectangle sourceRec, Rectangle destRec, Vector2 origin, + float rotation, float scale, Color tint = WHITE) { + ::DrawTextureTiled(*this, sourceRec, destRec, origin, rotation, scale, tint); + return *this; + } + + inline Texture& SetMaterialTexture(Material *material, int mapType) { + ::SetMaterialTexture(material, mapType, *this); + return *this; + } + + static int GetPixelDataSize(int width, int height, int format) { + return ::GetPixelDataSize(width, height, format); + } + + protected: + inline void set(::Texture texture) { + id = texture.id; + width = texture.width; + height = texture.height; + mipmaps = texture.mipmaps; + format = texture.format; + } +}; + +// Create the Texture aliases. +typedef Texture Texture2D; +typedef Texture TextureCubemap; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_TEXTURE_HPP_ diff --git a/include/Vector2.hpp b/include/Vector2.hpp new file mode 100644 index 0000000..9f16d8c --- /dev/null +++ b/include/Vector2.hpp @@ -0,0 +1,251 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_VECTOR2_HPP_ +#define RAYLIB_CPP_INCLUDE_VECTOR2_HPP_ + +#ifndef RAYLIB_CPP_NO_MATH +#include +#endif + +#include "./raylib.hpp" +#include "./raymath.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Vector2 : public ::Vector2 { + public: + Vector2(::Vector2 vec) { + set(vec); + } + + Vector2(float x, float y) : ::Vector2{x, y} {}; + Vector2(float x) : ::Vector2{x, 0} {}; + Vector2() : ::Vector2{0, 0} {}; + + GETTERSETTER(float, X, x) + GETTERSETTER(float, Y, y) + + Vector2& operator=(const ::Vector2& vector2) { + set(vector2); + return *this; + } + + Vector2& operator=(const Vector2& vector2) { + set(vector2); + return *this; + } + + bool operator==(const Vector2& other) { + return x == other.x + && y == other.y; + } + +#ifndef RAYLIB_CPP_NO_MATH + Vector2 Add(const Vector2& vector2) { + return Vector2Add(*this, vector2); + } + + Vector2 operator+(const Vector2& vector2) { + return Vector2Add(*this, vector2); + } + + Vector2 Subtract(const Vector2& vector2) { + return Vector2Subtract(*this, vector2); + } + + Vector2 operator-(const Vector2& vector2) { + return Vector2Subtract(*this, vector2); + } + + Vector2 Negate() { + return Vector2Negate(*this); + } + + Vector2 operator-() { + return Vector2Negate(*this); + } + + Vector2 Multiply(const Vector2& vector2) { + return Vector2Multiply(*this, vector2); + } + + Vector2 operator*(const Vector2& vector2) { + return Vector2Multiply(*this, vector2); + } + + Vector2 Scale(const float scale) { + return Vector2Scale(*this, scale); + } + + Vector2 operator*(const float scale) { + return Vector2Scale(*this, scale); + } + + Vector2 Divide(const Vector2& vector2) { + return Vector2Divide(*this, vector2); + } + + Vector2 operator/(const Vector2& vector2) { + return Vector2Divide(*this, vector2); + } + + Vector2& Divide(const float div) { + x /= div; + y /= div; + + return *this; + } + + Vector2& operator/(const float div) { + x /= div; + y /= div; + + return *this; + } + + Vector2& operator+=(const Vector2& vector2) { + set(Vector2Add(*this, vector2)); + + return *this; + } + + Vector2& operator-=(const Vector2& vector2) { + set(Vector2Subtract(*this, vector2)); + + return *this; + } + + + Vector2& operator*=(const Vector2& vector2) { + set(Vector2Multiply(*this, vector2)); + + return *this; + } + + Vector2& operator*=(const float scale) { + set(Vector2Scale(*this, scale)); + + return *this; + } + + Vector2& operator/=(const Vector2& vector2) { + set(Vector2Divide(*this, vector2)); + + return *this; + } + + Vector2& operator/=(const float div) { + this->x /= div; + this->y /= div; + + return *this; + } + + float Length() const { + return Vector2Length(*this); + } + + Vector2 Normalize() { + return Vector2Normalize(*this); + } + + float DotProduct(const Vector2& vector2) { + return Vector2DotProduct(*this, vector2); + } + + float Angle(const Vector2& vector2) { + return Vector2Angle(*this, vector2); + } + + float Distance(const Vector2& vector2) { + return Vector2Distance(*this, vector2); + } + + Vector2 Lerp(const Vector2& vector2, const float amount) { + return Vector2Lerp(*this, vector2, amount); + } + + Vector2 Reflect(const Vector2& normal) { + return Vector2Reflect(*this, normal); + } + + Vector2 Rotate(float degrees) { + return Vector2Rotate(*this, degrees); + } + + static Vector2 Zero() { + return Vector2Zero(); + } + + static Vector2 One() { + return Vector2One(); + } +#endif + + inline Vector2& DrawPixel(::Color color) { + ::DrawPixelV(*this, color); + return *this; + } + + inline Vector2& DrawLine(::Vector2 endPos, ::Color color) { + ::DrawLineV(*this, endPos, color); + return *this; + } + + inline Vector2& DrawLine(::Vector2 endPos, float thick, ::Color color) { + ::DrawLineEx(*this, endPos, thick, color); + return *this; + } + + inline Vector2& DrawLineBezier(::Vector2 endPos, float thick, ::Color color) { + ::DrawLineBezier(*this, endPos, thick, color); + return *this; + } + + inline Vector2& DrawCircle(float radius, ::Color color) { + ::DrawCircleV(*this, radius, color); + return *this; + } + + inline Vector2& DrawRectangle(::Vector2 size, ::Color color) { + ::DrawRectangleV(*this, size, color); + return *this; + } + + inline Vector2& DrawPoly(int sides, float radius, float rotation, ::Color color) { + ::DrawPoly(*this, sides, radius, rotation, color); + return *this; + } + + protected: + inline void set(::Vector2 vec) { + x = vec.x; + y = vec.y; + } +}; + +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_VECTOR2_HPP_ diff --git a/include/Vector3.hpp b/include/Vector3.hpp new file mode 100644 index 0000000..7ab3735 --- /dev/null +++ b/include/Vector3.hpp @@ -0,0 +1,329 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_VECTOR3_HPP_ +#define RAYLIB_CPP_INCLUDE_VECTOR3_HPP_ + +#ifndef RAYLIB_CPP_NO_MATH +#include +#endif + +#include "./raylib.hpp" +#include "./raymath.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Vector3 : public ::Vector3 { + public: + Vector3(::Vector3 vec) { + set(vec); + } + + Vector3(float x, float y, float z) : ::Vector3{x, y, z} {}; + Vector3(float x, float y) : ::Vector3{x, y, 0} {}; + Vector3(float x) : ::Vector3{x, 0, 0} {}; + Vector3() {}; + + Vector3(::Color color) { + set(ColorToHSV(color)); + } + + GETTERSETTER(float, X, x) + GETTERSETTER(float, Y, y) + GETTERSETTER(float, Z, z) + + Vector3& operator=(const ::Vector3& vector3) { + set(vector3); + return *this; + } + + bool operator==(const ::Vector3& other) { + return x == other.x + && y == other.y + && z == other.z; + } + +#ifndef RAYLIB_CPP_NO_MATH + Vector3 Add(const Vector3& vector3) { + return Vector3Add(*this, vector3); + } + + Vector3 operator+(const Vector3& vector3) { + return Vector3Add(*this, vector3); + } + + Vector3 Subtract(const Vector3& vector3) { + return Vector3Subtract(*this, vector3); + } + + Vector3 operator-(const Vector3& vector3) { + return Vector3Subtract(*this, vector3); + } + + Vector3 Negate() { + return Vector3Negate(*this); + } + + Vector3 operator-() { + return Vector3Negate(*this); + } + + Vector3 Multiply(const Vector3& vector3) { + return Vector3Multiply(*this, vector3); + } + + Vector3 operator*(const Vector3& vector3) { + return Vector3Multiply(*this, vector3); + } + + Vector3 Scale(const float scale) { + return Vector3Scale(*this, scale); + } + + Vector3 operator*(const float scale) { + return Vector3Scale(*this, scale); + } + + Vector3 Divide(const Vector3& vector3) { + return Vector3Divide(*this, vector3); + } + + Vector3 operator/(const Vector3& vector3) { + return Vector3Divide(*this, vector3); + } + + Vector3& Divide(const float div) { + x /= div; + y /= div; + z /= div; + + return *this; + } + + Vector3 operator/(const float div) { + return Divide(div); + } + + Vector3& operator+=(const Vector3& vector3) { + set(Vector3Add(*this, vector3)); + + return *this; + } + + Vector3& operator-=(const Vector3& vector3) { + set(Vector3Subtract(*this, vector3)); + + return *this; + } + + + Vector3& operator*=(const Vector3& vector3) { + set(Vector3Multiply(*this, vector3)); + + return *this; + } + + Vector3& operator*=(const float scale) { + set(Vector3Scale(*this, scale)); + + return *this; + } + + Vector3& operator/=(const Vector3& vector3) { + x /= vector3.x; + y /= vector3.y; + z /= vector3.z; + + return *this; + } + + Vector3& operator/=(const float div) { + x /= div; + y /= div; + z /= div; + + return *this; + } + + float Length() const { + return Vector3Length(*this); + } + + Vector3 Normalize() { + return Vector3Normalize(*this); + } + + float DotProduct(const Vector3& vector3) { + return Vector3DotProduct(*this, vector3); + } + + float Distance(const Vector3& vector3) { + return Vector3Distance(*this, vector3); + } + + Vector3 Lerp(const Vector3& vector3, const float amount) { + return Vector3Lerp(*this, vector3, amount); + } + + Vector3 CrossProduct(const Vector3& vector3) { + return Vector3CrossProduct(*this, vector3); + } + + Vector3 Perpendicular() { + return Vector3Perpendicular(*this); + } + + void OrthoNormalize(Vector3* vector3) { + return Vector3OrthoNormalize(this, vector3); + } + + Vector3 Transform(const ::Matrix& matrix) { + return Vector3Transform(*this, matrix); + } + + Vector3 RotateByQuaternion(Quaternion quaternion) { + return Vector3RotateByQuaternion(*this, quaternion); + } + + Vector3 Reflect(const Vector3& normal) { + return Vector3Reflect(*this, normal); + } + + Vector3 Min(const Vector3& vector3) { + return Vector3Min(*this, vector3); + } + + Vector3 Max(const Vector3& vector3) { + return Vector3Max(*this, vector3); + } + + Vector3 Barycenter(const Vector3& a, const Vector3& b, const Vector3& c) { + return Vector3Barycenter(*this, a, b, c); + } + + static Vector3 Zero() { + return Vector3Zero(); + } + + static Vector3 One() { + return Vector3One(); + } +#endif + + inline Vector3& DrawLine3D(::Vector3 endPos, ::Color color) { + ::DrawLine3D(*this, endPos, color); + return *this; + } + inline Vector3& DrawPoint3D(::Color color) { + ::DrawPoint3D(*this, color); + return *this; + } + inline Vector3& DrawCircle3D( + float radius, + Vector3 rotationAxis, + float rotationAngle, + Color color) { + ::DrawCircle3D(*this, radius, rotationAxis, rotationAngle, color); + return *this; + } + + inline Vector3& DrawCube(float width, float height, float length, ::Color color) { + ::DrawCube(*this, width, height, length, color); + return *this; + } + inline Vector3& DrawCube(::Vector3 size, ::Color color) { + ::DrawCubeV(*this, size, color); + return *this; + } + + inline Vector3& DrawCubeWires(float width, float height, float length, ::Color color) { + ::DrawCubeWires(*this, width, height, length, color); + return *this; + } + inline Vector3& DrawCubeWires(::Vector3 size, ::Color color) { + ::DrawCubeWiresV(*this, size, color); + return *this; + } + + inline Vector3& DrawCubeTexture( + ::Texture2D texture, + float width, + float height, + float length, + ::Color color) { + ::DrawCubeTexture(texture, *this, width, height, length, color); + return *this; + } + + inline Vector3& DrawSphere(float radius, Color color) { + ::DrawSphere(*this, radius, color); + return *this; + } + + inline Vector3& DrawSphere(float radius, int rings, int slices, Color color) { + ::DrawSphereEx(*this, radius, rings, slices, color); + return *this; + } + + inline Vector3& DrawSphereWires(float radius, int rings, int slices, Color color) { + ::DrawSphereWires(*this, radius, rings, slices, color); + return *this; + } + + inline Vector3& DrawCylinder(float radiusTop, float radiusBottom, float height, + int slices, Color color) { + ::DrawCylinder(*this, radiusTop, radiusBottom, height, slices, color); + return *this; + } + + inline Vector3& DrawCylinderWires(float radiusTop, float radiusBottom, float height, + int slices, Color color) { + ::DrawCylinderWires(*this, radiusTop, radiusBottom, height, slices, color); + return *this; + } + + inline Vector3& DrawPlane(::Vector2 size, ::Color color) { + ::DrawPlane(*this, size, color); + return *this; + } + + inline Vector3& DrawGizmo() { + ::DrawGizmo(*this); + return *this; + } + + inline bool CheckCollision(float radiusA, Vector3 centerB, float radiusB) { + return CheckCollisionSpheres(*this, radiusA, centerB, radiusB); + } + + protected: + inline void set(::Vector3 vec) { + x = vec.x; + y = vec.y; + z = vec.z; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_VECTOR3_HPP_ diff --git a/include/Vector4.hpp b/include/Vector4.hpp new file mode 100644 index 0000000..c523bda --- /dev/null +++ b/include/Vector4.hpp @@ -0,0 +1,182 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_VECTOR4_HPP_ +#define RAYLIB_CPP_INCLUDE_VECTOR4_HPP_ + +#ifndef RAYLIB_CPP_NO_MATH +#include +#include +#endif + +#include "./raylib.hpp" +#include "./raymath.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Vector4 : public ::Vector4 { + public: + Vector4(::Vector4 vec) { + set(vec); + } + + Vector4(float x, float y, float z, float w) : ::Vector4{x, y, z, w} {}; + Vector4(float x, float y, float z) : ::Vector4{x, y, z, 0} {}; + Vector4(float x, float y) : ::Vector4{x, y, 0, 0} {}; + Vector4(float x) : ::Vector4{x, 0, 0, 0} {}; + Vector4() {}; + + Vector4(::Color color) { + set(ColorNormalize(color)); + } + + GETTERSETTER(float, X, x) + GETTERSETTER(float, Y, y) + GETTERSETTER(float, Z, z) + GETTERSETTER(float, W, w) + + Vector4& operator=(const ::Vector4& vector4) { + set(vector4); + return *this; + } + + Vector4& operator=(const Vector4& vector4) { + set(vector4); + return *this; + } + + bool operator==(const Vector4& other) { + return x == other.x + && y == other.y + && z == other.z + && w == other.w; + } + +#ifndef RAYLIB_CPP_NO_MATH + Vector4 Multiply(const Vector4& vector4) { + return QuaternionMultiply(*this, vector4); + } + + Vector4 operator*(const Vector4& vector4) { + return QuaternionMultiply(*this, vector4); + } + + Vector4 Lerp(const Vector4& vector4, float amount) { + return QuaternionLerp(*this, vector4, amount); + } + + Vector4 Nlerp(const Vector4& vector4, float amount) { + return QuaternionNlerp(*this, vector4, amount); + } + + Vector4 Slerp(const Vector4& vector4, float amount) { + return QuaternionSlerp(*this, vector4, amount); + } + + Matrix ToMatrix() { + return QuaternionToMatrix(*this); + } + + float Length() const { + return QuaternionLength(*this); + } + + Vector4 Normalize() { + return QuaternionNormalize(*this); + } + + Vector4 Invert() { + return QuaternionInvert(*this); + } + + void ToAxisAngle(Vector3 *outAxis, float *outAngle) { + return QuaternionToAxisAngle(*this, outAxis, outAngle); + } + + std::pair ToAxisAngle() { + Vector3 outAxis; + float outAngle; + + QuaternionToAxisAngle(*this, &outAxis, &outAngle); + + std::pair out(outAxis, outAngle); + + return out; + } + + Vector4 Transform(const ::Matrix& matrix) { + return ::QuaternionTransform(*this, matrix); + } + + static Vector4 Identity() { + return ::QuaternionIdentity(); + } + + static Vector4 FromVector3ToVector3(const Vector3& from , const Vector3& to) { + return ::QuaternionFromVector3ToVector3(from , to); + } + + static Vector4 FromMatrix(const ::Matrix& matrix) { + return ::QuaternionFromMatrix(matrix); + } + + static Vector4 FromAxisAngle(const Vector3& axis, const float angle) { + return ::QuaternionFromAxisAngle(axis, angle); + } + + static Vector4 FromEuler(const float roll, const float pitch, const float yaw) { + return ::QuaternionFromEuler(roll, pitch, yaw); + } + + static Vector4 FromEuler(const Vector3& vector3) { + return ::QuaternionFromEuler(vector3.x, vector3.y, vector3.z); + } + + Vector3 ToEuler() { + return ::QuaternionToEuler(*this); + } +#endif + + inline Color ColorFromNormalized() { + return ::ColorFromNormalized(*this); + } + + operator Color() { + return ColorFromNormalized(); + } + + protected: + inline void set(::Vector4 vec4) { + x = vec4.x; + y = vec4.y; + z = vec4.z; + w = vec4.w; + } +}; + +// Alias the Vector4 as Quaternion. +typedef Vector4 Quaternion; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_VECTOR4_HPP_ diff --git a/include/VrSimulator.hpp b/include/VrSimulator.hpp new file mode 100644 index 0000000..28234d5 --- /dev/null +++ b/include/VrSimulator.hpp @@ -0,0 +1,85 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_VRSIMULATOR_HPP_ +#define RAYLIB_CPP_INCLUDE_VRSIMULATOR_HPP_ + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class VrSimulator { + public: + VrSimulator() { + Init(); + } + + VrSimulator(::VrDeviceInfo info, ::Shader distortion) { + Init(); + Set(info, distortion); + } + + inline void Init() { + InitVrSimulator(); + } + + ~VrSimulator() { + Close(); + } + + inline bool IsReady() const { + return ::IsVrSimulatorReady(); + } + + inline VrSimulator& Update(Camera *camera) { + ::UpdateVrTracking(camera); + return *this; + } + + inline VrSimulator& Set(::VrDeviceInfo info, ::Shader distortion) { + ::SetVrConfiguration(info, distortion); + return *this; + } + + inline VrSimulator& Toggle() { + ::ToggleVrMode(); + return *this; + } + + inline VrSimulator& Begin() { + ::BeginVrDrawing(); + return *this; + } + + inline VrSimulator& End() { + ::EndVrDrawing(); + return *this; + } + inline void Close() { + ::CloseVrSimulator(); + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_VRSIMULATOR_HPP_ diff --git a/include/Wave.hpp b/include/Wave.hpp new file mode 100644 index 0000000..e0e2226 --- /dev/null +++ b/include/Wave.hpp @@ -0,0 +1,133 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_WAVE_HPP_ +#define RAYLIB_CPP_INCLUDE_WAVE_HPP_ + +#include + +#include "./raylib.hpp" +#include "./raylib-cpp-utils.hpp" + +namespace raylib { +class Wave : public ::Wave { + public: + Wave(::Wave wave) { + set(wave); + } + + Wave( + unsigned int SampleCount = 0, + unsigned int SampleRate = 0, + unsigned int SampleSize = 0, + unsigned int Channels = 0) { + sampleCount = SampleCount; + sampleRate = SampleRate; + sampleSize = SampleSize; + channels = Channels; + } + + Wave(const std::string& fileName) { + set(LoadWave(fileName.c_str())); + } + + Wave(const std::string& fileType, const unsigned char *fileData, int dataSize) { + set(LoadWaveFromMemory(fileType.c_str(), fileData, dataSize)); + } + + ~Wave() { + Unload(); + } + + GETTERSETTER(unsigned int, SampleCount, sampleCount) + GETTERSETTER(unsigned int, SampleRate, sampleRate) + GETTERSETTER(unsigned int, SampleSize, sampleSize) + GETTERSETTER(unsigned int, Channels, channels) + GETTERSETTER(void *, Data, data) + + Wave& operator=(const ::Wave& wave) { + set(wave); + return *this; + } + + Wave& operator=(const Wave& wave) { + set(wave); + return *this; + } + + inline Wave& Format(int SampleRate = 0, int SampleSize = 0, int Channels = 2) { + ::WaveFormat(this, SampleRate, SampleSize, Channels); + return *this; + } + + inline Wave Copy() { + return ::WaveCopy(*this); + } + + inline Wave& Crop(int initSample, int finalSample) { + ::WaveCrop(this, initSample, finalSample); + return *this; + } + + inline Wave& Export(const std::string& fileName) { + ::ExportWave(*this, fileName.c_str()); + return *this; + } + + inline Wave& ExportAsCode(const std::string& fileName) { + ::ExportWaveAsCode(*this, fileName.c_str()); + return *this; + } + + void Unload() { + if (data != NULL) { + ::UnloadWave(*this); + data = NULL; + } + } + + inline Sound LoadSound() { + return ::LoadSoundFromWave(*this); + } + + inline operator Sound() { + return LoadSound(); + } + + inline float* GetData() { + return ::GetWaveData(*this); + } + + protected: + inline void set(::Wave wave) { + sampleCount = wave.sampleCount; + sampleRate = wave.sampleRate; + sampleSize = wave.sampleSize; + channels = wave.channels; + data = wave.data; + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_WAVE_HPP_ diff --git a/include/Window.hpp b/include/Window.hpp new file mode 100644 index 0000000..8297945 --- /dev/null +++ b/include/Window.hpp @@ -0,0 +1,216 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_WINDOW_HPP_ +#define RAYLIB_CPP_INCLUDE_WINDOW_HPP_ + +#include + +#include "./raylib.hpp" + +namespace raylib { +/** + * Window and Graphics Device Functions. + * + * @code + * + * raylib::Window w(640, 480, "raylib-cpp"); + * while (!w.ShouldClose()) { + * // Update + * } + * @endcode + */ +class Window { + public: + /** + * Initialize window and OpenGL context. + */ + Window(int width = 800, int height = 450, const std::string& title = "raylib", + bool lateInit = false) { + if (!lateInit) { + Init(width, height, title); + } + } + + ~Window() { + Close(); + } + + void Init(int width, int height, const std::string& title) { + ::InitWindow(width, height, title.c_str()); + } + + /** + * Check if KEY_ESCAPE pressed or Close icon pressed + */ + inline bool ShouldClose() { + return ::WindowShouldClose(); + } + + /** + * Close window and unload OpenGL context + */ + inline void Close() { + ::CloseWindow(); + } + + inline bool IsCursorOnScreen() { + return ::IsCursorOnScreen(); + } + + /** + * Check if window has been initialized successfully + */ + inline static bool IsReady() { + return ::IsWindowReady(); + } + + inline bool IsMinimized() const { + return ::IsWindowMinimized(); + } + + inline bool IsFocused() const { + return ::IsWindowFocused(); + } + + inline bool IsResized() const { + return ::IsWindowResized(); + } + + inline bool IsHidden() const { + return ::IsWindowHidden(); + } + + inline bool IsFullscreen() const { + return ::IsWindowFullscreen(); + } + + inline Window& ToggleFullscreen() { + ::ToggleFullscreen(); + return *this; + } + + inline Window& Unhide() { + ::UnhideWindow(); + return *this; + } + + inline Window& Hide() { + ::HideWindow(); + return *this; + } + + inline Window& SetIcon(Image image) { + ::SetWindowIcon(image); + return *this; + } + + inline Window& SetTitle(const std::string& title) { + ::SetWindowTitle(title.c_str()); + return *this; + } + + inline Window& SetPosition(int x, int y) { + ::SetWindowPosition(x, y); + return *this; + } + + inline Window& SetMonitor(int monitor) { + ::SetWindowMonitor(monitor); + return *this; + } + + inline Window& SetMinSize(int width, int height) { + ::SetWindowMinSize(width, height); + return *this; + } + + inline Window& SetSize(int width, int height) { + ::SetWindowSize(width, height); + return *this; + } + + inline void* GetHandle() const { + return ::GetWindowHandle(); + } + + inline Window& BeginDrawing() { + ::BeginDrawing(); + return *this; + } + + inline Window& EndDrawing() { + ::EndDrawing(); + return *this; + } + + inline int GetScreenWidth() const { + return ::GetScreenWidth(); + } + + inline int GetScreenHeight() const { + return ::GetScreenHeight(); + } + + inline Vector2 GetPosition() const { + return ::GetWindowPosition(); + } + + inline Vector2 GetScaleDPI() const { + return ::GetWindowScaleDPI(); + } + + std::string GetMonitorName(int monitor) const { + return std::string(::GetMonitorName(monitor)); + } + + std::string GetClipboardText() const { + return std::string(::GetClipboardText()); + } + + inline Window& SetClipboardText(const std::string& text) { + ::SetClipboardText(text.c_str()); + return *this; + } + + inline Window& SetTargetFPS(int fps) { + ::SetTargetFPS(fps); + return *this; + } + + inline int GetFPS() const { + return ::GetFPS(); + } + + inline float GetFrameTime() const { + return ::GetFrameTime(); + } + + inline double GetTime() const { + return ::GetTime(); + } +}; +} // namespace raylib + +#endif // RAYLIB_CPP_INCLUDE_WINDOW_HPP_ diff --git a/include/raylib-cpp-utils.hpp b/include/raylib-cpp-utils.hpp new file mode 100644 index 0000000..8076854 --- /dev/null +++ b/include/raylib-cpp-utils.hpp @@ -0,0 +1,41 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RAYLIB_CPP_UTILS_HPP_ +#define RAYLIB_CPP_INCLUDE_RAYLIB_CPP_UTILS_HPP_ + +#ifndef GETTERSETTER +/** + * A utility to build get and set methods on top of a property. + * + * @param type The type of the property. + * @param method The human-readable name for the method. + * @param name The machine-readable name of the property. + */ +#define GETTERSETTER(type, method, name) \ + inline type Get##method() const { return name; } \ + inline void Set##method(type value) { name = value; } +#endif + +#endif // RAYLIB_CPP_INCLUDE_RAYLIB_CPP_UTILS_HPP_ diff --git a/include/raylib-cpp.hpp b/include/raylib-cpp.hpp new file mode 100644 index 0000000..ab3d47b --- /dev/null +++ b/include/raylib-cpp.hpp @@ -0,0 +1,108 @@ +/** +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright 2020 Rob Loach (@RobLoach) +* +* 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. +* +* \mainpage raylib-cpp +* +* [raylib-cpp](https://github.com/robloach/raylib-cpp) is a C++ wrapper library for raylib, a simple and easy-to-use library to enjoy videogames programming. This C++ header provides object-oriented wrappers around raylib's struct interfaces. +* +* See the ::raylib namespace for all available classes. +* +* @code +* #include "raylib-cpp.hpp" +* +* int main() +* { +* int screenWidth = 800; +* int screenHeight = 450; +* +* raylib::Window w(screenWidth, screenHeight, "raylib-cpp - basic window"); +* raylib::Texture logo("raylib_logo.png"); +* +* SetTargetFPS(60); +* +* while (!w.ShouldClose()) +* { +* BeginDrawing(); +* +* ClearBackground(RAYWHITE); +* +* DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); +* +* // Object methods. +* logo.Draw( +* screenWidth / 2 - texture.getWidth() / 2, +* screenHeight / 2 - texture.getHeight() / 2); +* +* EndDrawing(); +* } +* +* // UnloadTexture() and CloseWindow() are called automatically. +* +* return 0; +* } +* @endcode +* +*/ + +#ifndef RAYLIB_CPP_INCLUDE_RAYLIB_CPP_HPP_ +#define RAYLIB_CPP_INCLUDE_RAYLIB_CPP_HPP_ + +/** + * Provides all the classes associated with raylib-cpp. + */ +namespace raylib { + // Nothing. +} // namespace raylib + +#include "./AudioDevice.hpp" +#include "./AudioStream.hpp" +#include "./BoundingBox.hpp" +#include "./Camera2D.hpp" +#include "./Camera3D.hpp" +#include "./Color.hpp" +#include "./DroppedFiles.hpp" +#include "./Font.hpp" +#include "./Gamepad.hpp" +#include "./Image.hpp" +#include "./Material.hpp" +#include "./Matrix.hpp" +#include "./Mesh.hpp" +#include "./Model.hpp" +#include "./ModelAnimation.hpp" +#include "./Mouse.hpp" +#include "./Music.hpp" +#include "./Ray.hpp" +#include "./RayHitInfo.hpp" +#include "./Rectangle.hpp" +#include "./RenderTexture.hpp" +#include "./Shader.hpp" +#include "./Sound.hpp" +#include "./Texture.hpp" +#include "./Vector2.hpp" +#include "./Vector3.hpp" +#include "./Vector4.hpp" +#include "./VrSimulator.hpp" +#include "./Wave.hpp" +#include "./Window.hpp" + +#endif // RAYLIB_CPP_INCLUDE_RAYLIB_CPP_HPP_ diff --git a/include/raylib.h b/include/raylib.h new file mode 100644 index 0000000..3ec32c8 --- /dev/null +++ b/include/raylib.h @@ -0,0 +1,1504 @@ +/********************************************************************************************** +* +* raylib - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +* +* FEATURES: +* - NO external dependencies, all required libraries included with raylib +* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, MacOS, UWP, Android, Raspberry Pi, HTML5. +* - Written in plain C code (C99) in PascalCase/camelCase notation +* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES2 - choose at compile) +* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] +* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +* - Flexible Materials system, supporting classic maps and PBR maps +* - Skeletal Animation support (CPU bones-based animation) +* - Shaders support, including Model shaders and Postprocessing shaders +* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] +* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +* - VR stereo rendering with configurable HMD device parameters +* - Bindings to multiple programming languages available! +* +* NOTES: +* One custom font is loaded by default when InitWindow() [core] +* If using OpenGL 3.3 or ES2, one default shader is loaded automatically (internally defined) [rlgl] +* If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads +* +* DEPENDENCIES (included): +* [core] rglfw (github.com/glfw/glfw) for window/context management and input (only PLATFORM_DESKTOP) +* [rlgl] glad (github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (only PLATFORM_DESKTOP) +* [raudio] miniaudio (github.com/dr-soft/miniaudio) for audio device/context management +* +* OPTIONAL DEPENDENCIES (included): +* [core] rgif (Charlie Tangora, Ramon Santamaria) for GIF recording +* [textures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +* [textures] stb_image_write (Sean Barret) for image writting (BMP, TGA, PNG, JPG) +* [textures] stb_image_resize (Sean Barret) for image resizing algorithms +* [textures] stb_perlin (Sean Barret) for Perlin noise image generation +* [text] stb_truetype (Sean Barret) for ttf fonts loading +* [text] stb_rect_pack (Sean Barret) for rectangles packing +* [models] par_shapes (Philip Rideout) for parametric 3d shapes generation +* [models] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +* [models] cgltf (Johannes Kuhlmann) for models loading (glTF) +* [raudio] stb_vorbis (Sean Barret) for OGG audio loading +* [raudio] dr_flac (David Reid) for FLAC audio file loading +* [raudio] dr_mp3 (David Reid) for MP3 audio file loading +* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +* +* +* LICENSE: zlib/libpng +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013-2020 Ramon Santamaria (@raysan5) +* +* 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 RAYLIB_H +#define RAYLIB_H + +#include // Required for: va_list - Only used by TraceLogCallback + +#if defined(_WIN32) + // Microsoft attibutes to tell compiler that symbols are imported/exported from a .dll + #if defined(BUILD_LIBTYPE_SHARED) + #define RLAPI __declspec(dllexport) // We are building raylib as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RLAPI // We are building or using raylib as a static library + #endif +#else + #define RLAPI // We are building or using raylib as a static library (or Linux shared library) +#endif + +//---------------------------------------------------------------------------------- +// Some basic Defines +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif + +#define DEG2RAD (PI/180.0f) +#define RAD2DEG (180.0f/PI) + +// Allow custom memory allocators +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(ptr,sz) realloc(ptr,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(ptr) free(ptr) +#endif + +// NOTE: MSC C++ compiler does not support compound literals (C99 feature) +// Plain structures in C++ (without constructors) can be initialized from { } initializers. +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +// Temporal hack to avoid breaking old codebases using +// deprecated raylib implementation of these functions +#define FormatText TextFormat +#define SubText TextSubtext +#define ShowWindow UnhideWindow +#define LoadText LoadFileText +#define GetExtension GetFileExtension +//#define Fade(c, a) ColorAlpha(c, a) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if defined(__STDC__) && __STDC_VERSION__ >= 199901L + #include +#elif !defined(__cplusplus) && !defined(bool) + typedef enum { false, true } bool; +#endif + +// Vector2 type +typedef struct Vector2 { + float x; + float y; +} Vector2; + +// Vector3 type +typedef struct Vector3 { + float x; + float y; + float z; +} Vector3; + +// Vector4 type +typedef struct Vector4 { + float x; + float y; + float z; + float w; +} Vector4; + +// Quaternion type, same as Vector4 +typedef Vector4 Quaternion; + +// Matrix type (OpenGL style 4x4 - right handed, column major) +typedef struct Matrix { + float m0, m4, m8, m12; + float m1, m5, m9, m13; + float m2, m6, m10, m14; + float m3, m7, m11, m15; +} Matrix; + +// Color type, RGBA (32bit) +typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; +} Color; + +// Rectangle type +typedef struct Rectangle { + float x; + float y; + float width; + float height; +} Rectangle; + +// Image type, bpp always RGBA (32bit) +// NOTE: Data stored in CPU memory (RAM) +typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Image; + +// Texture type +// NOTE: Data stored in GPU memory +typedef struct Texture { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Texture; + +// Texture2D type, same as Texture +typedef Texture Texture2D; + +// TextureCubemap type, actually, same as Texture +typedef Texture TextureCubemap; + +// RenderTexture type, for texture rendering +typedef struct RenderTexture { + unsigned int id; // OpenGL Framebuffer Object (FBO) id + Texture texture; // Color buffer attachment texture + Texture depth; // Depth buffer attachment texture +} RenderTexture; + +// RenderTexture2D type, same as RenderTexture +typedef RenderTexture RenderTexture2D; + +// N-Patch layout info +typedef struct NPatchInfo { + Rectangle sourceRec; // Region in the texture + int left; // left border offset + int top; // top border offset + int right; // right border offset + int bottom; // bottom border offset + int type; // layout of the n-patch: 3x3, 1x3 or 3x1 +} NPatchInfo; + +// Font character info +typedef struct CharInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data +} CharInfo; + +// Font type, includes texture and charSet array data +typedef struct Font { + int baseSize; // Base size (default chars height) + int charsCount; // Number of characters + Texture2D texture; // Characters texture atlas + Rectangle *recs; // Characters rectangles in texture + CharInfo *chars; // Characters info data +} Font; + +#define SpriteFont Font // SpriteFont type fallback, defaults to Font + +// Camera type, defines a camera position/orientation in 3d space +typedef struct Camera3D { + Vector3 position; // Camera position + Vector3 target; // Camera target it looks-at + Vector3 up; // Camera up vector (rotation over its axis) + float fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic + int type; // Camera type, defines projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC +} Camera3D; + +typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D + +// Camera2D type, defines a 2d camera +typedef struct Camera2D { + Vector2 offset; // Camera offset (displacement from target) + Vector2 target; // Camera target (rotation and zoom origin) + float rotation; // Camera rotation in degrees + float zoom; // Camera zoom (scaling), should be 1.0f by default +} Camera2D; + +// Vertex data definning a mesh +// NOTE: Data stored in CPU memory (and GPU) +typedef struct Mesh { + int vertexCount; // Number of vertices stored in arrays + int triangleCount; // Number of triangles stored (indexed or not) + + // Default vertex data + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + float *texcoords2; // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5) + float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + unsigned short *indices;// Vertex indices (in case vertex data comes indexed) + + // Animation vertex data + float *animVertices; // Animated vertex positions (after bones transformations) + float *animNormals; // Animated normals (after bones transformations) + int *boneIds; // Vertex bone ids, up to 4 bones influence by vertex (skinning) + float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) + + // OpenGL identifiers + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) +} Mesh; + +// Shader type (generic) +typedef struct Shader { + unsigned int id; // Shader program id + int *locs; // Shader locations array (MAX_SHADER_LOCATIONS) +} Shader; + +// Material texture map +typedef struct MaterialMap { + Texture2D texture; // Material map texture + Color color; // Material map color + float value; // Material map value +} MaterialMap; + +// Material type (generic) +typedef struct Material { + Shader shader; // Material shader + MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS) + float *params; // Material generic parameters (if required) +} Material; + +// Transformation properties +typedef struct Transform { + Vector3 translation; // Translation + Quaternion rotation; // Rotation + Vector3 scale; // Scale +} Transform; + +// Bone information +typedef struct BoneInfo { + char name[32]; // Bone name + int parent; // Bone parent +} BoneInfo; + +// Model type +typedef struct Model { + Matrix transform; // Local transform matrix + + int meshCount; // Number of meshes + int materialCount; // Number of materials + Mesh *meshes; // Meshes array + Material *materials; // Materials array + int *meshMaterial; // Mesh material number + + // Animation data + int boneCount; // Number of bones + BoneInfo *bones; // Bones information (skeleton) + Transform *bindPose; // Bones base transformation (pose) +} Model; + +// Model animation +typedef struct ModelAnimation { + int boneCount; // Number of bones + int frameCount; // Number of animation frames + BoneInfo *bones; // Bones information (skeleton) + Transform **framePoses; // Poses array by frame +} ModelAnimation; + +// Ray type (useful for raycast) +typedef struct Ray { + Vector3 position; // Ray position (origin) + Vector3 direction; // Ray direction +} Ray; + +// Raycast hit information +typedef struct RayHitInfo { + bool hit; // Did the ray hit something? + float distance; // Distance to nearest hit + Vector3 position; // Position of nearest hit + Vector3 normal; // Surface normal of hit +} RayHitInfo; + +// Bounding box type +typedef struct BoundingBox { + Vector3 min; // Minimum vertex box-corner + Vector3 max; // Maximum vertex box-corner +} BoundingBox; + +// Wave type, defines audio wave data +typedef struct Wave { + unsigned int sampleCount; // Total number of samples + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo) + void *data; // Buffer data pointer +} Wave; + +typedef struct rAudioBuffer rAudioBuffer; + +// Audio stream type +// NOTE: Useful to create custom audio streams not bound to a specific file +typedef struct AudioStream { + rAudioBuffer *buffer; // Pointer to internal data used by the audio system + + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo) +} AudioStream; + +// Sound source type +typedef struct Sound { + AudioStream stream; // Audio stream + unsigned int sampleCount; // Total number of samples +} Sound; + +// Music stream type (audio file streaming from memory) +// NOTE: Anything longer than ~10 seconds should be streamed +typedef struct Music { + AudioStream stream; // Audio stream + unsigned int sampleCount; // Total number of samples + bool looping; // Music looping enable + + int ctxType; // Type of music context (audio filetype) + void *ctxData; // Audio context data, depends on type +} Music; + +// Head-Mounted-Display device parameters +typedef struct VrDeviceInfo { + int hResolution; // HMD horizontal resolution in pixels + int vResolution; // HMD vertical resolution in pixels + float hScreenSize; // HMD horizontal size in meters + float vScreenSize; // HMD vertical size in meters + float vScreenCenter; // HMD screen center in meters + float eyeToScreenDistance; // HMD distance between eye and display in meters + float lensSeparationDistance; // HMD lens separation distance in meters + float interpupillaryDistance; // HMD IPD (distance between pupils) in meters + float lensDistortionValues[4]; // HMD lens distortion constant parameters + float chromaAbCorrection[4]; // HMD chromatic aberration correction parameters +} VrDeviceInfo; + +//---------------------------------------------------------------------------------- +// Enumerators Definition +//---------------------------------------------------------------------------------- +// System config flags +// NOTE: Used for bit masks +typedef enum { + FLAG_RESERVED = 1, // Reserved + FLAG_FULLSCREEN_MODE = 2, // Set to run program in fullscreen + FLAG_WINDOW_RESIZABLE = 4, // Set to allow resizable window + FLAG_WINDOW_UNDECORATED = 8, // Set to disable window decoration (frame and buttons) + FLAG_WINDOW_TRANSPARENT = 16, // Set to allow transparent window + FLAG_WINDOW_HIDDEN = 128, // Set to create the window initially hidden + FLAG_WINDOW_ALWAYS_RUN = 256, // Set to allow windows running while minimized + FLAG_MSAA_4X_HINT = 32, // Set to try enabling MSAA 4X + FLAG_VSYNC_HINT = 64, // Set to try enabling V-Sync on GPU + FLAG_INTERLACED_HINT = 512 // Set to try V3D to choose an interlaced video format +} ConfigFlag; + +// Trace log type +typedef enum { + LOG_ALL = 0, // Display all logs + LOG_TRACE, + LOG_DEBUG, + LOG_INFO, + LOG_WARNING, + LOG_ERROR, + LOG_FATAL, + LOG_NONE // Disable logging +} TraceLogType; + +// Keyboard keys +typedef enum { + // Alphanumeric keys + KEY_APOSTROPHE = 39, + KEY_COMMA = 44, + KEY_MINUS = 45, + KEY_PERIOD = 46, + KEY_SLASH = 47, + KEY_ZERO = 48, + KEY_ONE = 49, + KEY_TWO = 50, + KEY_THREE = 51, + KEY_FOUR = 52, + KEY_FIVE = 53, + KEY_SIX = 54, + KEY_SEVEN = 55, + KEY_EIGHT = 56, + KEY_NINE = 57, + KEY_SEMICOLON = 59, + KEY_EQUAL = 61, + KEY_A = 65, + KEY_B = 66, + KEY_C = 67, + KEY_D = 68, + KEY_E = 69, + KEY_F = 70, + KEY_G = 71, + KEY_H = 72, + KEY_I = 73, + KEY_J = 74, + KEY_K = 75, + KEY_L = 76, + KEY_M = 77, + KEY_N = 78, + KEY_O = 79, + KEY_P = 80, + KEY_Q = 81, + KEY_R = 82, + KEY_S = 83, + KEY_T = 84, + KEY_U = 85, + KEY_V = 86, + KEY_W = 87, + KEY_X = 88, + KEY_Y = 89, + KEY_Z = 90, + + // Function keys + KEY_SPACE = 32, + KEY_ESCAPE = 256, + KEY_ENTER = 257, + KEY_TAB = 258, + KEY_BACKSPACE = 259, + KEY_INSERT = 260, + KEY_DELETE = 261, + KEY_RIGHT = 262, + KEY_LEFT = 263, + KEY_DOWN = 264, + KEY_UP = 265, + KEY_PAGE_UP = 266, + KEY_PAGE_DOWN = 267, + KEY_HOME = 268, + KEY_END = 269, + KEY_CAPS_LOCK = 280, + KEY_SCROLL_LOCK = 281, + KEY_NUM_LOCK = 282, + KEY_PRINT_SCREEN = 283, + KEY_PAUSE = 284, + KEY_F1 = 290, + KEY_F2 = 291, + KEY_F3 = 292, + KEY_F4 = 293, + KEY_F5 = 294, + KEY_F6 = 295, + KEY_F7 = 296, + KEY_F8 = 297, + KEY_F9 = 298, + KEY_F10 = 299, + KEY_F11 = 300, + KEY_F12 = 301, + KEY_LEFT_SHIFT = 340, + KEY_LEFT_CONTROL = 341, + KEY_LEFT_ALT = 342, + KEY_LEFT_SUPER = 343, + KEY_RIGHT_SHIFT = 344, + KEY_RIGHT_CONTROL = 345, + KEY_RIGHT_ALT = 346, + KEY_RIGHT_SUPER = 347, + KEY_KB_MENU = 348, + KEY_LEFT_BRACKET = 91, + KEY_BACKSLASH = 92, + KEY_RIGHT_BRACKET = 93, + KEY_GRAVE = 96, + + // Keypad keys + KEY_KP_0 = 320, + KEY_KP_1 = 321, + KEY_KP_2 = 322, + KEY_KP_3 = 323, + KEY_KP_4 = 324, + KEY_KP_5 = 325, + KEY_KP_6 = 326, + KEY_KP_7 = 327, + KEY_KP_8 = 328, + KEY_KP_9 = 329, + KEY_KP_DECIMAL = 330, + KEY_KP_DIVIDE = 331, + KEY_KP_MULTIPLY = 332, + KEY_KP_SUBTRACT = 333, + KEY_KP_ADD = 334, + KEY_KP_ENTER = 335, + KEY_KP_EQUAL = 336 +} KeyboardKey; + +// Android buttons +typedef enum { + KEY_BACK = 4, + KEY_MENU = 82, + KEY_VOLUME_UP = 24, + KEY_VOLUME_DOWN = 25 +} AndroidButton; + +// Mouse buttons +typedef enum { + MOUSE_LEFT_BUTTON = 0, + MOUSE_RIGHT_BUTTON = 1, + MOUSE_MIDDLE_BUTTON = 2 +} MouseButton; + +// Mouse cursor types +typedef enum { + MOUSE_CURSOR_DEFAULT = 0, + MOUSE_CURSOR_ARROW = 1, + MOUSE_CURSOR_IBEAM = 2, + MOUSE_CURSOR_CROSSHAIR = 3, + MOUSE_CURSOR_POINTING_HAND = 4, + MOUSE_CURSOR_RESIZE_EW = 5, // The horizontal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NS = 6, // The vertical resize/move arrow shape + MOUSE_CURSOR_RESIZE_NWSE = 7, // The top-left to bottom-right diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_ALL = 9, // The omni-directional resize/move cursor shape + MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape +} MouseCursor; + +// Gamepad number +typedef enum { + GAMEPAD_PLAYER1 = 0, + GAMEPAD_PLAYER2 = 1, + GAMEPAD_PLAYER3 = 2, + GAMEPAD_PLAYER4 = 3 +} GamepadNumber; + +// Gamepad buttons +typedef enum { + // This is here just for error checking + GAMEPAD_BUTTON_UNKNOWN = 0, + + // This is normally a DPAD + GAMEPAD_BUTTON_LEFT_FACE_UP, + GAMEPAD_BUTTON_LEFT_FACE_RIGHT, + GAMEPAD_BUTTON_LEFT_FACE_DOWN, + GAMEPAD_BUTTON_LEFT_FACE_LEFT, + + // This normally corresponds with PlayStation and Xbox controllers + // XBOX: [Y,X,A,B] + // PS3: [Triangle,Square,Cross,Circle] + // No support for 6 button controllers though.. + GAMEPAD_BUTTON_RIGHT_FACE_UP, + GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, + GAMEPAD_BUTTON_RIGHT_FACE_DOWN, + GAMEPAD_BUTTON_RIGHT_FACE_LEFT, + + // Triggers + GAMEPAD_BUTTON_LEFT_TRIGGER_1, + GAMEPAD_BUTTON_LEFT_TRIGGER_2, + GAMEPAD_BUTTON_RIGHT_TRIGGER_1, + GAMEPAD_BUTTON_RIGHT_TRIGGER_2, + + // These are buttons in the center of the gamepad + GAMEPAD_BUTTON_MIDDLE_LEFT, //PS3 Select + GAMEPAD_BUTTON_MIDDLE, //PS Button/XBOX Button + GAMEPAD_BUTTON_MIDDLE_RIGHT, //PS3 Start + + // These are the joystick press in buttons + GAMEPAD_BUTTON_LEFT_THUMB, + GAMEPAD_BUTTON_RIGHT_THUMB +} GamepadButton; + +// Gamepad axis +typedef enum { + // Left stick + GAMEPAD_AXIS_LEFT_X = 0, + GAMEPAD_AXIS_LEFT_Y = 1, + + // Right stick + GAMEPAD_AXIS_RIGHT_X = 2, + GAMEPAD_AXIS_RIGHT_Y = 3, + + // Pressure levels for the back triggers + GAMEPAD_AXIS_LEFT_TRIGGER = 4, // [1..-1] (pressure-level) + GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // [1..-1] (pressure-level) +} GamepadAxis; + +// Shader location points +typedef enum { + LOC_VERTEX_POSITION = 0, + LOC_VERTEX_TEXCOORD01, + LOC_VERTEX_TEXCOORD02, + LOC_VERTEX_NORMAL, + LOC_VERTEX_TANGENT, + LOC_VERTEX_COLOR, + LOC_MATRIX_MVP, + LOC_MATRIX_MODEL, + LOC_MATRIX_VIEW, + LOC_MATRIX_PROJECTION, + LOC_VECTOR_VIEW, + LOC_COLOR_DIFFUSE, + LOC_COLOR_SPECULAR, + LOC_COLOR_AMBIENT, + LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE + LOC_MAP_METALNESS, // LOC_MAP_SPECULAR + LOC_MAP_NORMAL, + LOC_MAP_ROUGHNESS, + LOC_MAP_OCCLUSION, + LOC_MAP_EMISSION, + LOC_MAP_HEIGHT, + LOC_MAP_CUBEMAP, + LOC_MAP_IRRADIANCE, + LOC_MAP_PREFILTER, + LOC_MAP_BRDF +} ShaderLocationIndex; + +#define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO +#define LOC_MAP_SPECULAR LOC_MAP_METALNESS + +// Shader uniform data types +typedef enum { + UNIFORM_FLOAT = 0, + UNIFORM_VEC2, + UNIFORM_VEC3, + UNIFORM_VEC4, + UNIFORM_INT, + UNIFORM_IVEC2, + UNIFORM_IVEC3, + UNIFORM_IVEC4, + UNIFORM_SAMPLER2D +} ShaderUniformDataType; + +// Material maps +typedef enum { + MAP_ALBEDO = 0, // MAP_DIFFUSE + MAP_METALNESS = 1, // MAP_SPECULAR + MAP_NORMAL = 2, + MAP_ROUGHNESS = 3, + MAP_OCCLUSION, + MAP_EMISSION, + MAP_HEIGHT, + MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP + MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP + MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP + MAP_BRDF +} MaterialMapType; + +#define MAP_DIFFUSE MAP_ALBEDO +#define MAP_SPECULAR MAP_METALNESS + +// Pixel formats +// NOTE: Support depends on OpenGL version and platform +typedef enum { + UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + UNCOMPRESSED_R5G6B5, // 16 bpp + UNCOMPRESSED_R8G8B8, // 24 bpp + UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + UNCOMPRESSED_R8G8B8A8, // 32 bpp + UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + COMPRESSED_DXT3_RGBA, // 8 bpp + COMPRESSED_DXT5_RGBA, // 8 bpp + COMPRESSED_ETC1_RGB, // 4 bpp + COMPRESSED_ETC2_RGB, // 4 bpp + COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + COMPRESSED_PVRT_RGB, // 4 bpp + COMPRESSED_PVRT_RGBA, // 4 bpp + COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} PixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + FILTER_POINT = 0, // No filter, just pixel aproximation + FILTER_BILINEAR, // Linear filtering + FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} TextureFilterMode; + +// Texture parameters: wrap mode +typedef enum { + WRAP_REPEAT = 0, // Repeats texture in tiled mode + WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode + WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode + WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode +} TextureWrapMode; + +// Cubemap layouts +typedef enum { + CUBEMAP_AUTO_DETECT = 0, // Automatically detect layout type + CUBEMAP_LINE_VERTICAL, // Layout is defined by a vertical line with faces + CUBEMAP_LINE_HORIZONTAL, // Layout is defined by an horizontal line with faces + CUBEMAP_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces + CUBEMAP_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces + CUBEMAP_PANORAMA // Layout is defined by a panorama image (equirectangular map) +} CubemapLayoutType; + +// Font type, defines generation method +typedef enum { + FONT_DEFAULT = 0, // Default font generation, anti-aliased + FONT_BITMAP, // Bitmap font generation, no anti-aliasing + FONT_SDF // SDF font generation, requires external shader +} FontType; + +// Color blending modes (pre-defined) +typedef enum { + BLEND_ALPHA = 0, // Blend textures considering alpha (default) + BLEND_ADDITIVE, // Blend textures adding colors + BLEND_MULTIPLIED, // Blend textures multiplying colors + BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + BLEND_CUSTOM // Belnd textures using custom src/dst factors (use SetBlendModeCustom()) +} BlendMode; + +// Gestures type +// NOTE: It could be used as flags to enable only some gestures +typedef enum { + GESTURE_NONE = 0, + GESTURE_TAP = 1, + GESTURE_DOUBLETAP = 2, + GESTURE_HOLD = 4, + GESTURE_DRAG = 8, + GESTURE_SWIPE_RIGHT = 16, + GESTURE_SWIPE_LEFT = 32, + GESTURE_SWIPE_UP = 64, + GESTURE_SWIPE_DOWN = 128, + GESTURE_PINCH_IN = 256, + GESTURE_PINCH_OUT = 512 +} GestureType; + +// Camera system modes +typedef enum { + CAMERA_CUSTOM = 0, + CAMERA_FREE, + CAMERA_ORBITAL, + CAMERA_FIRST_PERSON, + CAMERA_THIRD_PERSON +} CameraMode; + +// Camera projection modes +typedef enum { + CAMERA_PERSPECTIVE = 0, + CAMERA_ORTHOGRAPHIC +} CameraType; + +// N-patch types +typedef enum { + NPT_9PATCH = 0, // Npatch defined by 3x3 tiles + NPT_3PATCH_VERTICAL, // Npatch defined by 1x3 tiles + NPT_3PATCH_HORIZONTAL // Npatch defined by 3x1 tiles +} NPatchType; + +// Callbacks to be implemented by users +typedef void (*TraceLogCallback)(int logType, const char *text, va_list args); + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowMinimized(void); // Check if window has been minimized +RLAPI bool IsWindowMaximized(void); // Check if window has been maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window has been focused +RLAPI bool IsWindowResized(void); // Check if window has been resized +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI void ToggleFullscreen(void); // Toggle fullscreen mode (only PLATFORM_DESKTOP) +RLAPI void UnhideWindow(void); // Show the window +RLAPI void HideWindow(void); // Hide the window +RLAPI void DecorateWindow(void); // Decorate the window (only PLATFORM_DESKTOP) +RLAPI void UndecorateWindow(void); // Undecorate the window (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Maximize the window, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Restore the window, if resizable (only PLATFORM_DESKTOP) + +RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP) +RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode) +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetMonitorWidth(int monitor); // Get primary monitor width +RLAPI int GetMonitorHeight(int monitor); // Get primary monitor height +RLAPI int GetMonitorPhysicalWidth(int monitor); // Get primary monitor physical width in millimetres +RLAPI int GetMonitorPhysicalHeight(int monitor); // Get primary monitor physical height in millimetres +RLAPI int GetMonitorRefreshRate(int monitor); // Get primary monitor refresh rate +RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor +RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor +RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the primary monitor +RLAPI void SetClipboardText(const char *text); // Set clipboard text content +RLAPI const char *GetClipboardText(void); // Get clipboard text content + +// Cursor-related functions +RLAPI void ShowCursor(void); // Shows cursor +RLAPI void HideCursor(void); // Hides cursor +RLAPI bool IsCursorHidden(void); // Check if cursor is not visible +RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) +RLAPI void DisableCursor(void); // Disables cursor (lock cursor) +RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the current screen. + +// Drawing-related functions +RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) +RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing +RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering) +RLAPI void BeginMode2D(Camera2D camera); // Initialize 2D mode with custom camera (2D) +RLAPI void EndMode2D(void); // Ends 2D mode with custom camera +RLAPI void BeginMode3D(Camera3D camera); // Initializes 3D mode with custom camera (3D) +RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode +RLAPI void BeginTextureMode(RenderTexture2D target); // Initializes render texture for drawing +RLAPI void EndTextureMode(void); // Ends drawing to render texture +RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) +RLAPI void EndScissorMode(void); // End scissor mode + +// Screen-space-related functions +RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Returns a ray trace from mouse position +RLAPI Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix) +RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Returns camera 2d transform matrix +RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Returns the screen space position for a 3d world space position +RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Returns size position for a 3d world space position +RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Returns the screen space position for a 2d camera world space position +RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Returns the world space position for a 2d camera screen space position + +// Timing-related functions +RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) +RLAPI int GetFPS(void); // Returns current FPS +RLAPI float GetFrameTime(void); // Returns time in seconds for last frame drawn +RLAPI double GetTime(void); // Returns elapsed time in seconds since InitWindow() + +// Misc. functions +RLAPI void SetConfigFlags(unsigned int flags); // Setup window configuration flags (view FLAGS) + +RLAPI void SetTraceLogLevel(int logType); // Set the current threshold (minimum) log level +RLAPI void SetTraceLogExit(int logType); // Set the exit threshold (minimum) log level +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set a trace log callback to enable custom logging +RLAPI void TraceLog(int logType, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR) + +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (saved a .png) +RLAPI int GetRandomValue(int min, int max); // Returns a random value between min and max (both included) + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) +RLAPI void SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write) +RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +RLAPI void SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext);// Check file extension (including point: .png, .wav) +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (including point: ".png") +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI char **GetDirectoryFiles(const char *dirPath, int *count); // Get filenames in a directory path (memory should be freed) +RLAPI void ClearDirectoryFiles(void); // Clear directory files paths buffers (free memory) +RLAPI bool ChangeDirectory(const char *dir); // Change working directory, returns true if success +RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window +RLAPI char **GetDroppedFiles(int *count); // Get dropped files names (memory should be freed) +RLAPI void ClearDroppedFiles(void); // Clear dropped files paths buffer (free memory) +RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) + +RLAPI unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength); // Compress data (DEFLATE algorithm) +RLAPI unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength); // Decompress data (DEFLATE algorithm) + +// Persistent storage management +RLAPI void SaveStorageValue(unsigned int position, int value); // Save integer value to storage file (to defined position) +RLAPI int LoadStorageValue(unsigned int position); // Load integer value from storage file (from defined position) + +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Detect if a key has been pressed once +RLAPI bool IsKeyDown(int key); // Detect if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Detect if a key has been released once +RLAPI bool IsKeyUp(int key); // Detect if a key is NOT being pressed +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) +RLAPI int GetKeyPressed(void); // Get key pressed, call it multiple times for chars queued + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Detect if a gamepad is available +RLAPI bool IsGamepadName(int gamepad, const char *name); // Check gamepad name (if available) +RLAPI const char *GetGamepadName(int gamepad); // Return gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Detect if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Detect if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Detect if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Detect if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Return gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Return axis movement value for a gamepad axis + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Detect if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Detect if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Detect if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Detect if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Returns mouse position X +RLAPI int GetMouseY(void); // Returns mouse position Y +RLAPI Vector2 GetMousePosition(void); // Returns mouse position XY +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Returns mouse wheel movement Y +RLAPI int GetMouseCursor(void); // Returns mouse cursor if (MouseCursor enum) +RLAPI void SetMouseCursor(int cursor); // Set mouse cursor + +// Input-related functions: touch +RLAPI int GetTouchX(void); // Returns touch position X for touch point 0 (relative to screen size) +RLAPI int GetTouchY(void); // Returns touch position Y for touch point 0 (relative to screen size) +RLAPI Vector2 GetTouchPosition(int index); // Returns touch position XY for a touch point index (relative to screen size) + +//------------------------------------------------------------------------------------ +// Gestures and Touch Handling Functions (Module: gestures) +//------------------------------------------------------------------------------------ +RLAPI void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags +RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected +RLAPI int GetGestureDetected(void); // Get latest detected gesture +RLAPI int GetTouchPointsCount(void); // Get touch points count +RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds +RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector +RLAPI float GetGestureDragAngle(void); // Get gesture drag angle +RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta +RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle + +//------------------------------------------------------------------------------------ +// Camera System Functions (Module: camera) +//------------------------------------------------------------------------------------ +RLAPI void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available) +RLAPI void UpdateCamera(Camera *camera); // Update camera position for selected mode + +RLAPI void SetCameraPanControl(int panKey); // Set camera pan key to combine with mouse movement (free camera) +RLAPI void SetCameraAltControl(int altKey); // Set camera alt key to combine with mouse movement (free camera) +RLAPI void SetCameraSmoothZoomControl(int szKey); // Set camera smooth zoom key to combine with mouse (free camera) +RLAPI void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey); // Set camera move controls (1st person and 3rd person cameras) + +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ + +// Basic shapes drawing functions +RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel +RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) +RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out +RLAPI void DrawLineStrip(Vector2 *points, int numPoints, Color color); // Draw lines sequence +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int numPoints, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle + +//------------------------------------------------------------------------------------ +// Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ + +// Image loading functions +// NOTE: This functions do not require GPU access +RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. "png" +RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) +RLAPI void ExportImage(Image image, const char *fileName); // Export image data to file +RLAPI void ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient +RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm. Bigger tileSize means bigger cells + +// Image manipulation functions +RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece +RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) +RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format +RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) +RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value +RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color +RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image +RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel +RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color +RLAPI void ImageMipmaps(Image *image); // Generate all mipmap levels for a provided image +RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +RLAPI void ImageFlipVertical(Image *image); // Flip image vertically +RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally +RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg +RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg +RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint +RLAPI void ImageColorInvert(Image *image); // Modify image color: invert +RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale +RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color + +RLAPI Color *GetImageData(Image image); // Get pixel data from image as a Color struct array +RLAPI Color *GetImagePalette(Image image, int maxPaletteSize, int *extractCount); // Get color palette from image to maximum size (memory should be freed) +RLAPI Vector4 *GetImageDataNormalized(Image image); // Get pixel data from image as Vector4 array (float normalized) +RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle + +// Image drawing functions +// NOTE: Image software-rendering functions (CPU) +RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color +RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image +RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) +RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image +RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) +RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle within an image +RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw circle within an image (Vector version) +RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) +RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image +RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) +RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) +RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) + +// Texture loading functions +// NOTE: These functions require GPU access +RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data +RLAPI TextureCubemap LoadTextureCubemap(Image image, int layoutType); // Load cubemap from image, multiple image cubemap layouts supported +RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) +RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data +RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data +RLAPI Image GetTextureData(Texture2D texture); // Get pixel data from GPU texture and return an Image +RLAPI Image GetScreenData(void); // Get pixel data from screen buffer and return an Image (screenshot) + +// Texture configuration functions +RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture +RLAPI void SetTextureFilter(Texture2D texture, int filterMode); // Set texture scaling filter mode +RLAPI void SetTextureWrap(Texture2D texture, int wrapMode); // Set texture wrapping mode + +// Texture drawing functions +RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +RLAPI void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint); // Draw texture quad with tiling and offset parameters +RLAPI void DrawTextureTiled(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, float scale, Color tint); // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into destRec. +RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely + +// Color/pixel related functions +RLAPI Color Fade(Color color, float alpha); // Returns color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI int ColorToInt(Color color); // Returns hexadecimal value for a Color +RLAPI Vector4 ColorNormalize(Color color); // Returns Color normalized as float [0..1] +RLAPI Color ColorFromNormalized(Vector4 normalized); // Returns Color from normalized values [0..1] +RLAPI Vector3 ColorToHSV(Color color); // Returns HSV values for a Color +RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Returns a Color from HSV values +RLAPI Color ColorAlpha(Color color, float alpha); // Returns color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Returns src alpha-blended into dst color with tint +RLAPI Color GetColor(int hexValue); // Get Color structure from hexadecimal value +RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format +RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer +RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format + +//------------------------------------------------------------------------------------ +// Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ + +// Font loading/unloading functions +RLAPI Font GetFontDefault(void); // Get the default Font +RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount); // Load font from file with extended parameters +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount); // Load font from memory buffer, fileType refers to extension: i.e. "ttf" +RLAPI CharInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFont(Font font); // Unload Font from GPU memory (VRAM) + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Shows current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint); // Draw text using font inside rectangle limits +RLAPI void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, + int selectStart, int selectLength, Color selectTint, Color selectBackTint); // Draw text using font inside rectangle limits with support for text selection +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint); // Draw one character (codepoint) + +// Text misc. functions +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get index position for a unicode character on font + +// Text strings management functions (no utf8 strings, only byte chars) +// NOTE: Some strings allocate memory internally for returned strings, just be careful! +RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending +RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf style) +RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string +RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (memory must be freed!) +RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (memory must be freed!) +RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string +RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string +RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string +RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) +RLAPI char *TextToUtf8(int *codepoints, int length); // Encode text codepoint into utf8 text (memory must be freed!) + +// UTF8 text strings management functions +RLAPI int *GetCodepoints(const char *text, int *count); // Get all codepoints in a string, codepoints count returned by parameters +RLAPI int GetCodepointsCount(const char *text); // Get total number of characters (codepoints) in a UTF8 encoded string +RLAPI int GetNextCodepoint(const char *text, int *bytesProcessed); // Returns next codepoint in a UTF8 encoded string; 0x3f('?') is returned on failure +RLAPI const char *CodepointToUtf8(int codepoint, int *byteLength); // Encode codepoint into utf8 text (char array length returned as parameter) + +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Basic geometric 3D shapes drawing functions +RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line +RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space +RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointsCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube +RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires +RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) +RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured +RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ +RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line +RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) +RLAPI void DrawGizmo(Vector3 position); // Draw simple gizmo + +//------------------------------------------------------------------------------------ +// Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Model loading/unloading functions +RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) +RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) +RLAPI void UnloadModel(Model model); // Unload model from memory (RAM and/or VRAM) + +// Mesh loading/unloading functions +RLAPI Mesh *LoadMeshes(const char *fileName, int *meshCount); // Load meshes from model file +RLAPI void ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file +RLAPI void UnloadMesh(Mesh mesh); // Unload mesh from memory (RAM and/or VRAM) + +// Material loading/unloading functions +RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) +RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...) +RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh + +// Model animations loading/unloading functions +RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Mesh generation functions +RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh +RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh +RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data +RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data + +// Mesh manipulation functions +RLAPI BoundingBox MeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits +RLAPI void MeshTangents(Mesh *mesh); // Compute mesh tangents +RLAPI void MeshBinormals(Mesh *mesh); // Compute mesh binormals +RLAPI void MeshNormalsSmooth(Mesh *mesh); // Smooth (average) vertex normals + +// Model drawing functions +RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters +RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) +RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters +RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) +RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint); // Draw a billboard texture +RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB); // Detect collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Detect collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Detect collision between box and sphere +RLAPI bool CheckCollisionRaySphere(Ray ray, Vector3 center, float radius); // Detect collision between ray and sphere +RLAPI bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint); // Detect collision between ray and sphere, returns collision point +RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box); // Detect collision between ray and box +RLAPI RayHitInfo GetCollisionRayModel(Ray ray, Model model); // Get collision info between ray and model +RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight); // Get collision info between ray and ground plane (Y-normal plane) + +//------------------------------------------------------------------------------------ +// Shaders System Functions (Module: rlgl) +// NOTE: This functions are useless when using OpenGL 1.1 +//------------------------------------------------------------------------------------ + +// Shader loading/unloading functions +RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations +RLAPI Shader LoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations +RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) + +RLAPI Shader GetShaderDefault(void); // Get default shader +RLAPI Texture2D GetTextureDefault(void); // Get default texture +RLAPI Texture2D GetShapesTexture(void); // Get texture to draw shapes +RLAPI Rectangle GetShapesTextureRec(void); // Get texture rectangle to draw shapes +RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Define default texture used to draw shapes + +// Shader configuration functions +RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location +RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location +RLAPI void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType); // Set shader uniform value +RLAPI void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count); // Set shader uniform value vector +RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) +RLAPI void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture); // Set shader uniform value for texture +RLAPI void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) +RLAPI void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) +RLAPI Matrix GetMatrixModelview(void); // Get internal modelview matrix +RLAPI Matrix GetMatrixProjection(void); // Get internal projection matrix + +// Texture maps generation (PBR) +// NOTE: Required shaders should be provided +RLAPI TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, int format); // Generate cubemap texture from 2D panorama texture +RLAPI TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int size); // Generate irradiance texture using cubemap data +RLAPI TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int size); // Generate prefilter texture using cubemap data +RLAPI Texture2D GenTextureBRDF(Shader shader, int size); // Generate BRDF texture + +// Shading begin/end functions +RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing +RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) +RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) +RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) + +// VR control functions +RLAPI void InitVrSimulator(void); // Init VR simulator for selected device parameters +RLAPI void CloseVrSimulator(void); // Close VR simulator for current device +RLAPI void UpdateVrTracking(Camera *camera); // Update VR tracking (position and orientation) and camera +RLAPI void SetVrConfiguration(VrDeviceInfo info, Shader distortion); // Set stereo rendering configuration parameters +RLAPI bool IsVrSimulatorReady(void); // Detect if VR simulator is ready +RLAPI void ToggleVrMode(void); // Enable/Disable VR experience +RLAPI void BeginVrDrawing(void); // Begin VR simulator stereo rendering +RLAPI void EndVrDrawing(void); // End VR simulator stereo rendering + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. "wav" +RLAPI Sound LoadSound(const char *fileName); // Load sound from file +RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data +RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data +RLAPI void UnloadWave(Wave wave); // Unload wave data +RLAPI void UnloadSound(Sound sound); // Unload sound +RLAPI void ExportWave(Wave wave, const char *fileName); // Export wave data to file +RLAPI void ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h) + +// Wave/Sound management functions +RLAPI void PlaySound(Sound sound); // Play a sound +RLAPI void StopSound(Sound sound); // Stop playing a sound +RLAPI void PauseSound(Sound sound); // Pause a sound +RLAPI void ResumeSound(Sound sound); // Resume a paused sound +RLAPI void PlaySoundMulti(Sound sound); // Play a sound (using multichannel buffer pool) +RLAPI void StopSoundMulti(void); // Stop any sound playing (using multichannel buffer pool) +RLAPI int GetSoundsPlaying(void); // Get number of sounds playing in the multichannel +RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing +RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave +RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range +RLAPI float *GetWaveData(Wave wave); // Get samples data from wave as a floats array + +// Music management functions +RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file +RLAPI void UnloadMusicStream(Music music); // Unload music stream +RLAPI void PlayMusicStream(Music music); // Start music playing +RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming +RLAPI void StopMusicStream(Music music); // Stop music playing +RLAPI void PauseMusicStream(Music music); // Pause music playing +RLAPI void ResumeMusicStream(Music music); // Resume playing paused music +RLAPI bool IsMusicPlaying(Music music); // Check if music is playing +RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) +RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) +RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) +RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) + +// AudioStream management functions +RLAPI AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Init audio stream (to stream raw audio pcm data) +RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data +RLAPI void CloseAudioStream(AudioStream stream); // Close audio stream and free memory +RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream +RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream +RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream +RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing +RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream +RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams + +//------------------------------------------------------------------------------------ +// Network (Module: network) +//------------------------------------------------------------------------------------ + +// IN PROGRESS: Check rnet.h for reference + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/include/raylib.hpp b/include/raylib.hpp new file mode 100644 index 0000000..36e5435 --- /dev/null +++ b/include/raylib.hpp @@ -0,0 +1,36 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RAYLIB_HPP_ +#define RAYLIB_CPP_INCLUDE_RAYLIB_HPP_ + +#ifdef __cplusplus +extern "C" { +#endif +#include "raylib.h" // NOLINT +#ifdef __cplusplus +} +#endif + +#endif // RAYLIB_CPP_INCLUDE_RAYLIB_HPP_ diff --git a/include/raymath.h b/include/raymath.h new file mode 100644 index 0000000..086eba1 --- /dev/null +++ b/include/raymath.h @@ -0,0 +1,1519 @@ +/********************************************************************************************** +* +* raymath v1.2 - Math functions to work with Vector3, Matrix and Quaternions +* +* CONFIGURATION: +* +* #define RAYMATH_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYMATH_HEADER_ONLY +* Define static inline functions code, so #include header suffices for use. +* This may use up lots of memory. +* +* #define RAYMATH_STANDALONE +* Avoid raylib.h header inclusion in this file. +* Vector3 and Matrix data types are defined internally in raymath module. +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2015-2020 Ramon Santamaria (@raysan5) +* +* 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 RAYMATH_H +#define RAYMATH_H + +//#define RAYMATH_STANDALONE // NOTE: To use raymath as standalone lib, just uncomment this line +//#define RAYMATH_HEADER_ONLY // NOTE: To compile functions as static inline, uncomment this line + +#ifndef RAYMATH_STANDALONE + #include "raylib.h" // Required for structs: Vector3, Matrix +#endif + +#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_HEADER_ONLY) + #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_HEADER_ONLY is contradictory" +#endif + +#if defined(RAYMATH_IMPLEMENTATION) + #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) + #define RMDEF __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). + #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) + #define RMDEF __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RMDEF extern inline // Provide external definition + #endif +#elif defined(RAYMATH_HEADER_ONLY) + #define RMDEF static inline // Functions may be inlined, no external out-of-line definition +#else + #if defined(__TINYC__) + #define RMDEF static inline // plain inline not supported by tinycc (See issue #435) + #else + #define RMDEF inline // Functions may be inlined or external definition used + #endif +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846 +#endif + +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif + +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Return float vector for Matrix +#ifndef MatrixToFloat + #define MatrixToFloat(mat) (MatrixToFloatV(mat).v) +#endif + +// Return float vector for Vector3 +#ifndef Vector3ToFloat + #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- + +#if defined(RAYMATH_STANDALONE) + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; + + // Vector3 type + typedef struct Vector3 { + float x; + float y; + float z; + } Vector3; + + // Vector4 type + typedef struct Vector4 { + float x; + float y; + float z; + float w; + } Vector4; + + // Quaternion type + typedef Vector4 Quaternion; + + // Matrix type (OpenGL style 4x4 - right handed, column major) + typedef struct Matrix { + float m0, m4, m8, m12; + float m1, m5, m9, m13; + float m2, m6, m10, m14; + float m3, m7, m11, m15; + } Matrix; +#endif + +// NOTE: Helper types to be used instead of array return types for *ToFloat functions +typedef struct float3 { float v[3]; } float3; +typedef struct float16 { float v[16]; } float16; + +#include // Required for: sinf(), cosf(), sqrtf(), tan(), fabs() + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Utils math +//---------------------------------------------------------------------------------- + +// Clamp float value +RMDEF float Clamp(float value, float min, float max) +{ + const float res = value < min ? min : value; + return res > max ? max : res; +} + +// Calculate linear interpolation between two floats +RMDEF float Lerp(float start, float end, float amount) +{ + return start + amount*(end - start); +} + +// Normalize input value within input range +RMDEF float Normalize(float value, float start, float end) +{ + return (value - start) / (end - start); +} + +// Remap input value within input range to output range +RMDEF float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) +{ + return (value - inputStart) / (inputEnd - inputStart) * (outputEnd - outputStart) + outputStart; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector2 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMDEF Vector2 Vector2Zero(void) +{ + Vector2 result = { 0.0f, 0.0f }; + return result; +} + +// Vector with components value 1.0f +RMDEF Vector2 Vector2One(void) +{ + Vector2 result = { 1.0f, 1.0f }; + return result; +} + +// Add two vectors (v1 + v2) +RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x + v2.x, v1.y + v2.y }; + return result; +} + +// Add vector and float value +RMDEF Vector2 Vector2AddValue(Vector2 v, float add) +{ + Vector2 result = { v.x + add, v.y + add }; + return result; +} + +// Subtract two vectors (v1 - v2) +RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x - v2.x, v1.y - v2.y }; + return result; +} + +// Subtract vector by float value +RMDEF Vector2 Vector2SubtractValue(Vector2 v, float sub) +{ + Vector2 result = { v.x - sub, v.y - sub }; + return result; +} + +// Calculate vector length +RMDEF float Vector2Length(Vector2 v) +{ + float result = sqrtf((v.x*v.x) + (v.y*v.y)); + return result; +} + +// Calculate vector square length +RMDEF float Vector2LengthSqr(Vector2 v) +{ + float result = (v.x*v.x) + (v.y*v.y); + return result; +} + +// Calculate two vectors dot product +RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y); + return result; +} + +// Calculate distance between two vectors +RMDEF float Vector2Distance(Vector2 v1, Vector2 v2) +{ + float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + return result; +} + +// Calculate angle from two vectors in X-axis +RMDEF float Vector2Angle(Vector2 v1, Vector2 v2) +{ + float result = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/PI); + if (result < 0) result += 360.0f; + return result; +} + +// Scale vector (multiply by value) +RMDEF Vector2 Vector2Scale(Vector2 v, float scale) +{ + Vector2 result = { v.x*scale, v.y*scale }; + return result; +} + +// Multiply vector by vector +RMDEF Vector2 Vector2Multiply(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x*v2.x, v1.y*v2.y }; + return result; +} + +// Negate vector +RMDEF Vector2 Vector2Negate(Vector2 v) +{ + Vector2 result = { -v.x, -v.y }; + return result; +} + +// Divide vector by vector +RMDEF Vector2 Vector2Divide(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x/v2.x, v1.y/v2.y }; + return result; +} + +// Normalize provided vector +RMDEF Vector2 Vector2Normalize(Vector2 v) +{ + Vector2 result = Vector2Scale(v, 1/Vector2Length(v)); + return result; +} + +// Calculate linear interpolation between two vectors +RMDEF Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount) +{ + Vector2 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + + return result; +} + +// Calculate reflected vector to normal +RMDEF Vector2 Vector2Reflect(Vector2 v, Vector2 normal) +{ + Vector2 result = { 0 }; + + float dotProduct = Vector2DotProduct(v, normal); + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + + return result; +} + +// Rotate Vector by float in Degrees. +RMDEF Vector2 Vector2Rotate(Vector2 v, float degs) +{ + float rads = degs*DEG2RAD; + Vector2 result = {v.x * cosf(rads) - v.y * sinf(rads) , v.x * sinf(rads) + v.y * cosf(rads) }; + return result; +} + +// Move Vector towards target +RMDEF Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) +{ + Vector2 result = { 0 }; + float dx = target.x - v.x; + float dy = target.y - v.y; + float value = (dx*dx) + (dy*dy); + + if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) result = target; + + float dist = sqrtf(value); + + result.x = v.x + dx/dist*maxDistance; + result.y = v.y + dy/dist*maxDistance; + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector3 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMDEF Vector3 Vector3Zero(void) +{ + Vector3 result = { 0.0f, 0.0f, 0.0f }; + return result; +} + +// Vector with components value 1.0f +RMDEF Vector3 Vector3One(void) +{ + Vector3 result = { 1.0f, 1.0f, 1.0f }; + return result; +} + +// Add two vectors +RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; + return result; +} + +// Add vector and float value +RMDEF Vector3 Vector3AddValue(Vector3 v, float add) +{ + Vector3 result = { v.x + add, v.y + add, v.z + add }; + return result; +} + +// Subtract two vectors +RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; + return result; +} + +// Subtract vector by float value +RMDEF Vector3 Vector3SubtractValue(Vector3 v, float sub) +{ + Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; + return result; +} + +// Multiply vector by scalar +RMDEF Vector3 Vector3Scale(Vector3 v, float scalar) +{ + Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; + return result; +} + +// Multiply vector by vector +RMDEF Vector3 Vector3Multiply(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; + return result; +} + +// Calculate two vectors cross product +RMDEF Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + return result; +} + +// Calculate one vector perpendicular vector +RMDEF Vector3 Vector3Perpendicular(Vector3 v) +{ + Vector3 result = { 0 }; + + float min = (float) fabs(v.x); + Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; + + if (fabs(v.y) < min) + { + min = (float) fabs(v.y); + Vector3 tmp = {0.0f, 1.0f, 0.0f}; + cardinalAxis = tmp; + } + + if (fabs(v.z) < min) + { + Vector3 tmp = {0.0f, 0.0f, 1.0f}; + cardinalAxis = tmp; + } + + result = Vector3CrossProduct(v, cardinalAxis); + + return result; +} + +// Calculate vector length +RMDEF float Vector3Length(const Vector3 v) +{ + float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + return result; +} + +// Calculate vector square length +RMDEF float Vector3LengthSqr(const Vector3 v) +{ + float result = v.x*v.x + v.y*v.y + v.z*v.z; + return result; +} + +// Calculate two vectors dot product +RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + return result; +} + +// Calculate distance between two vectors +RMDEF float Vector3Distance(Vector3 v1, Vector3 v2) +{ + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + float result = sqrtf(dx*dx + dy*dy + dz*dz); + return result; +} + +// Negate provided vector (invert direction) +RMDEF Vector3 Vector3Negate(Vector3 v) +{ + Vector3 result = { -v.x, -v.y, -v.z }; + return result; +} + +// Divide vector by vector +RMDEF Vector3 Vector3Divide(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; + return result; +} + +// Normalize provided vector +RMDEF Vector3 Vector3Normalize(Vector3 v) +{ + Vector3 result = v; + + float length, ilength; + length = Vector3Length(v); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + + return result; +} + +// Orthonormalize provided vectors +// Makes vectors normalized and orthogonal to each other +// Gram-Schmidt function implementation +RMDEF void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) +{ + *v1 = Vector3Normalize(*v1); + Vector3 vn = Vector3CrossProduct(*v1, *v2); + vn = Vector3Normalize(vn); + *v2 = Vector3CrossProduct(vn, *v1); +} + +// Transforms a Vector3 by a given Matrix +RMDEF Vector3 Vector3Transform(Vector3 v, Matrix mat) +{ + Vector3 result = { 0 }; + float x = v.x; + float y = v.y; + float z = v.z; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; + + return result; +} + +// Transform a vector by quaternion rotation +RMDEF Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q) +{ + Vector3 result = { 0 }; + + result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); + result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); + result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); + + return result; +} + +// Calculate linear interpolation between two vectors +RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount) +{ + Vector3 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + result.z = v1.z + amount*(v2.z - v1.z); + + return result; +} + +// Calculate reflected vector to normal +RMDEF Vector3 Vector3Reflect(Vector3 v, Vector3 normal) +{ + // I is the original vector + // N is the normal of the incident plane + // R = I - (2*N*( DotProduct[ I,N] )) + + Vector3 result = { 0 }; + + float dotProduct = Vector3DotProduct(v, normal); + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + result.z = v.z - (2.0f*normal.z)*dotProduct; + + return result; +} + +// Return min value for each pair of components +RMDEF Vector3 Vector3Min(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + + return result; +} + +// Return max value for each pair of components +RMDEF Vector3 Vector3Max(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + + return result; +} + +// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) +// NOTE: Assumes P is on the plane of the triangle +RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) +{ + //Vector v0 = b - a, v1 = c - a, v2 = p - a; + + Vector3 v0 = Vector3Subtract(b, a); + Vector3 v1 = Vector3Subtract(c, a); + Vector3 v2 = Vector3Subtract(p, a); + float d00 = Vector3DotProduct(v0, v0); + float d01 = Vector3DotProduct(v0, v1); + float d11 = Vector3DotProduct(v1, v1); + float d20 = Vector3DotProduct(v2, v0); + float d21 = Vector3DotProduct(v2, v1); + + float denom = d00*d11 - d01*d01; + + Vector3 result = { 0 }; + + result.y = (d11*d20 - d01*d21)/denom; + result.z = (d00*d21 - d01*d20)/denom; + result.x = 1.0f - (result.z + result.y); + + return result; +} + +// Returns Vector3 as float array +RMDEF float3 Vector3ToFloatV(Vector3 v) +{ + float3 buffer = { 0 }; + + buffer.v[0] = v.x; + buffer.v[1] = v.y; + buffer.v[2] = v.z; + + return buffer; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix math +//---------------------------------------------------------------------------------- + +// Compute matrix determinant +RMDEF float MatrixDeterminant(Matrix mat) +{ + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + float result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; + + return result; +} + +// Returns the trace of the matrix (sum of the values along the diagonal) +RMDEF float MatrixTrace(Matrix mat) +{ + float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); + return result; +} + +// Transposes provided matrix +RMDEF Matrix MatrixTranspose(Matrix mat) +{ + Matrix result = { 0 }; + + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; + + return result; +} + +// Invert provided matrix +RMDEF Matrix MatrixInvert(Matrix mat) +{ + Matrix result = { 0 }; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; + result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; + result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; + result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; + result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; + result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; + result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; + result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; + result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; + result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; + result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; + result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; + result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; + result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; + result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; + result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; + + return result; +} + +// Normalize provided matrix +RMDEF Matrix MatrixNormalize(Matrix mat) +{ + Matrix result = { 0 }; + + float det = MatrixDeterminant(mat); + + result.m0 = mat.m0/det; + result.m1 = mat.m1/det; + result.m2 = mat.m2/det; + result.m3 = mat.m3/det; + result.m4 = mat.m4/det; + result.m5 = mat.m5/det; + result.m6 = mat.m6/det; + result.m7 = mat.m7/det; + result.m8 = mat.m8/det; + result.m9 = mat.m9/det; + result.m10 = mat.m10/det; + result.m11 = mat.m11/det; + result.m12 = mat.m12/det; + result.m13 = mat.m13/det; + result.m14 = mat.m14/det; + result.m15 = mat.m15/det; + + return result; +} + +// Returns identity matrix +RMDEF Matrix MatrixIdentity(void) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Add two matrices +RMDEF Matrix MatrixAdd(Matrix left, Matrix right) +{ + Matrix result = MatrixIdentity(); + + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; + + return result; +} + +// Subtract two matrices (left - right) +RMDEF Matrix MatrixSubtract(Matrix left, Matrix right) +{ + Matrix result = MatrixIdentity(); + + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; + + return result; +} + +// Returns two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +RMDEF Matrix MatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +// Returns translation matrix +RMDEF Matrix MatrixTranslate(float x, float y, float z) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Create rotation matrix from axis and angle +// NOTE: Angle should be provided in radians +RMDEF Matrix MatrixRotate(Vector3 axis, float angle) +{ + Matrix result = { 0 }; + + float x = axis.x, y = axis.y, z = axis.z; + + float length = sqrtf(x*x + y*y + z*z); + + if ((length != 1.0f) && (length != 0.0f)) + { + length = 1.0f/length; + x *= length; + y *= length; + z *= length; + } + + float sinres = sinf(angle); + float cosres = cosf(angle); + float t = 1.0f - cosres; + + result.m0 = x*x*t + cosres; + result.m1 = y*x*t + z*sinres; + result.m2 = z*x*t - y*sinres; + result.m3 = 0.0f; + + result.m4 = x*y*t - z*sinres; + result.m5 = y*y*t + cosres; + result.m6 = z*y*t + x*sinres; + result.m7 = 0.0f; + + result.m8 = x*z*t + y*sinres; + result.m9 = y*z*t - x*sinres; + result.m10 = z*z*t + cosres; + result.m11 = 0.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = 0.0f; + result.m15 = 1.0f; + + return result; +} + +// Returns x-rotation matrix (angle in radians) +RMDEF Matrix MatrixRotateX(float angle) +{ + Matrix result = MatrixIdentity(); + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m5 = cosres; + result.m6 = -sinres; + result.m9 = sinres; + result.m10 = cosres; + + return result; +} + +// Returns y-rotation matrix (angle in radians) +RMDEF Matrix MatrixRotateY(float angle) +{ + Matrix result = MatrixIdentity(); + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m2 = sinres; + result.m8 = -sinres; + result.m10 = cosres; + + return result; +} + +// Returns z-rotation matrix (angle in radians) +RMDEF Matrix MatrixRotateZ(float angle) +{ + Matrix result = MatrixIdentity(); + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m1 = -sinres; + result.m4 = sinres; + result.m5 = cosres; + + return result; +} + + +// Returns xyz-rotation matrix (angles in radians) +RMDEF Matrix MatrixRotateXYZ(Vector3 ang) +{ + Matrix result = MatrixIdentity(); + + float cosz = cosf(-ang.z); + float sinz = sinf(-ang.z); + float cosy = cosf(-ang.y); + float siny = sinf(-ang.y); + float cosx = cosf(-ang.x); + float sinx = sinf(-ang.x); + + result.m0 = cosz * cosy; + result.m4 = (cosz * siny * sinx) - (sinz * cosx); + result.m8 = (cosz * siny * cosx) + (sinz * sinx); + + result.m1 = sinz * cosy; + result.m5 = (sinz * siny * sinx) + (cosz * cosx); + result.m9 = (sinz * siny * cosx) - (cosz * sinx); + + result.m2 = -siny; + result.m6 = cosy * sinx; + result.m10= cosy * cosx; + + return result; +} + +// Returns zyx-rotation matrix (angles in radians) +// TODO: This solution is suboptimal, it should be possible to create this matrix in one go +// instead of using a 3 matrix multiplication +RMDEF Matrix MatrixRotateZYX(Vector3 ang) +{ + Matrix result = MatrixRotateZ(ang.z); + result = MatrixMultiply(result, MatrixRotateY(ang.y)); + result = MatrixMultiply(result, MatrixRotateX(ang.x)); + + return result; +} + +// Returns scaling matrix +RMDEF Matrix MatrixScale(float x, float y, float z) +{ + Matrix result = { x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Returns perspective projection matrix +RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = ((float) near*2.0f)/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + + result.m4 = 0.0f; + result.m5 = ((float) near*2.0f)/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + result.m15 = 0.0f; + + return result; +} + +// Returns perspective projection matrix +// NOTE: Angle should be provided in radians +RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far) +{ + double top = near*tan(fovy*0.5); + double right = top*aspect; + Matrix result = MatrixFrustum(-right, right, -top, top, near, far); + + return result; +} + +// Returns orthographic projection matrix +RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = 2.0f/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + result.m4 = 0.0f; + result.m5 = 2.0f/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + result.m8 = 0.0f; + result.m9 = 0.0f; + result.m10 = -2.0f/fn; + result.m11 = 0.0f; + result.m12 = -((float)left + (float)right)/rl; + result.m13 = -((float)top + (float)bottom)/tb; + result.m14 = -((float)far + (float)near)/fn; + result.m15 = 1.0f; + + return result; +} + +// Returns camera look-at matrix (view matrix) +RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up) +{ + Matrix result = { 0 }; + + Vector3 z = Vector3Subtract(eye, target); + z = Vector3Normalize(z); + Vector3 x = Vector3CrossProduct(up, z); + x = Vector3Normalize(x); + Vector3 y = Vector3CrossProduct(z, x); + y = Vector3Normalize(y); + + result.m0 = x.x; + result.m1 = x.y; + result.m2 = x.z; + result.m3 = 0.0f; + result.m4 = y.x; + result.m5 = y.y; + result.m6 = y.z; + result.m7 = 0.0f; + result.m8 = z.x; + result.m9 = z.y; + result.m10 = z.z; + result.m11 = 0.0f; + result.m12 = eye.x; + result.m13 = eye.y; + result.m14 = eye.z; + result.m15 = 1.0f; + + result = MatrixInvert(result); + + return result; +} + +// Returns float array of matrix data +RMDEF float16 MatrixToFloatV(Matrix mat) +{ + float16 buffer = { 0 }; + + buffer.v[0] = mat.m0; + buffer.v[1] = mat.m1; + buffer.v[2] = mat.m2; + buffer.v[3] = mat.m3; + buffer.v[4] = mat.m4; + buffer.v[5] = mat.m5; + buffer.v[6] = mat.m6; + buffer.v[7] = mat.m7; + buffer.v[8] = mat.m8; + buffer.v[9] = mat.m9; + buffer.v[10] = mat.m10; + buffer.v[11] = mat.m11; + buffer.v[12] = mat.m12; + buffer.v[13] = mat.m13; + buffer.v[14] = mat.m14; + buffer.v[15] = mat.m15; + + return buffer; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Quaternion math +//---------------------------------------------------------------------------------- + +// Add two quaternions +RMDEF Quaternion QuaternionAdd(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; + return result; +} + +// Add quaternion and float value +RMDEF Quaternion QuaternionAddValue(Quaternion q, float add) +{ + Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; + return result; +} + +// Subtract two quaternions +RMDEF Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; + return result; +} + +// Subtract quaternion and float value +RMDEF Quaternion QuaternionSubtractValue(Quaternion q, float sub) +{ + Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; + return result; +} + +// Returns identity quaternion +RMDEF Quaternion QuaternionIdentity(void) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + return result; +} + +// Computes the length of a quaternion +RMDEF float QuaternionLength(Quaternion q) +{ + float result = (float)sqrt(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + return result; +} + +// Normalize provided quaternion +RMDEF Quaternion QuaternionNormalize(Quaternion q) +{ + Quaternion result = { 0 }; + + float length, ilength; + length = QuaternionLength(q); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Invert provided quaternion +RMDEF Quaternion QuaternionInvert(Quaternion q) +{ + Quaternion result = q; + float length = QuaternionLength(q); + float lengthSq = length*length; + + if (lengthSq != 0.0) + { + float i = 1.0f/lengthSq; + + result.x *= -i; + result.y *= -i; + result.z *= -i; + result.w *= i; + } + + return result; +} + +// Calculate two quaternion multiplication +RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2) +{ + Quaternion result = { 0 }; + + float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; + float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; + + result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; + + return result; +} + +// Scale quaternion by float value +RMDEF Quaternion QuaternionScale(Quaternion q, float mul) +{ + Quaternion result = { 0 }; + + float qax = q.x, qay = q.y, qaz = q.z, qaw = q.w; + + result.x = qax * mul + qaw * mul + qay * mul - qaz * mul; + result.y = qay * mul + qaw * mul + qaz * mul - qax * mul; + result.z = qaz * mul + qaw * mul + qax * mul - qay * mul; + result.w = qaw * mul - qax * mul - qay * mul - qaz * mul; + + return result; +} + +// Divide two quaternions +RMDEF Quaternion QuaternionDivide(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x / q2.x, q1.y / q2.y, q1.z / q2.z, q1.w / q2.w}; + return result; +} + +// Calculate linear interpolation between two quaternions +RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + return result; +} + +// Calculate slerp-optimized interpolation between two quaternions +RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = QuaternionLerp(q1, q2, amount); + result = QuaternionNormalize(result); + + return result; +} + +// Calculates spherical linear interpolation between two quaternions +RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; + + if (fabs(cosHalfTheta) >= 1.0f) result = q1; + else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount); + else + { + float halfTheta = acosf(cosHalfTheta); + float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); + + if (fabs(sinHalfTheta) < 0.001f) + { + result.x = (q1.x*0.5f + q2.x*0.5f); + result.y = (q1.y*0.5f + q2.y*0.5f); + result.z = (q1.z*0.5f + q2.z*0.5f); + result.w = (q1.w*0.5f + q2.w*0.5f); + } + else + { + float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; + float ratioB = sinf(amount*halfTheta)/sinHalfTheta; + + result.x = (q1.x*ratioA + q2.x*ratioB); + result.y = (q1.y*ratioA + q2.y*ratioB); + result.z = (q1.z*ratioA + q2.z*ratioB); + result.w = (q1.w*ratioA + q2.w*ratioB); + } + } + + return result; +} + +// Calculate quaternion based on the rotation from one vector to another +RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to) +{ + Quaternion result = { 0 }; + + float cos2Theta = Vector3DotProduct(from, to); + Vector3 cross = Vector3CrossProduct(from, to); + + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0f + cos2Theta; // NOTE: Added QuaternioIdentity() + + // Normalize to essentially nlerp the original and identity to 0.5 + result = QuaternionNormalize(result); + + // Above lines are equivalent to: + //Quaternion result = QuaternionNlerp(q, QuaternionIdentity(), 0.5f); + + return result; +} + +// Returns a quaternion for a given rotation matrix +RMDEF Quaternion QuaternionFromMatrix(Matrix mat) +{ + Quaternion result = { 0 }; + + if ((mat.m0 > mat.m5) && (mat.m0 > mat.m10)) + { + float s = sqrtf(1.0f + mat.m0 - mat.m5 - mat.m10)*2; + + result.x = 0.25f*s; + result.y = (mat.m4 + mat.m1)/s; + result.z = (mat.m2 + mat.m8)/s; + result.w = (mat.m9 - mat.m6)/s; + } + else if (mat.m5 > mat.m10) + { + float s = sqrtf(1.0f + mat.m5 - mat.m0 - mat.m10)*2; + result.x = (mat.m4 + mat.m1)/s; + result.y = 0.25f*s; + result.z = (mat.m9 + mat.m6)/s; + result.w = (mat.m2 - mat.m8)/s; + } + else + { + float s = sqrtf(1.0f + mat.m10 - mat.m0 - mat.m5)*2; + result.x = (mat.m2 + mat.m8)/s; + result.y = (mat.m9 + mat.m6)/s; + result.z = 0.25f*s; + result.w = (mat.m4 - mat.m1)/s; + } + + return result; +} + +// Returns a matrix for a given quaternion +RMDEF Matrix QuaternionToMatrix(Quaternion q) +{ + Matrix result = MatrixIdentity(); + + float a2 = 2*(q.x*q.x), b2=2*(q.y*q.y), c2=2*(q.z*q.z); //, d2=2*(q.w*q.w); + + float ab = 2*(q.x*q.y), ac=2*(q.x*q.z), bc=2*(q.y*q.z); + float ad = 2*(q.x*q.w), bd=2*(q.y*q.w), cd=2*(q.z*q.w); + + result.m0 = 1 - b2 - c2; + result.m1 = ab - cd; + result.m2 = ac + bd; + + result.m4 = ab + cd; + result.m5 = 1 - a2 - c2; + result.m6 = bc - ad; + + result.m8 = ac - bd; + result.m9 = bc + ad; + result.m10 = 1 - a2 - b2; + + return result; +} + +// Returns rotation quaternion for an angle and axis +// NOTE: angle must be provided in radians +RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + if (Vector3Length(axis) != 0.0f) + + angle *= 0.5f; + + axis = Vector3Normalize(axis); + + float sinres = sinf(angle); + float cosres = cosf(angle); + + result.x = axis.x*sinres; + result.y = axis.y*sinres; + result.z = axis.z*sinres; + result.w = cosres; + + result = QuaternionNormalize(result); + + return result; +} + +// Returns the rotation angle and axis for a given quaternion +RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) +{ + if (fabs(q.w) > 1.0f) q = QuaternionNormalize(q); + + Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; + float resAngle = 2.0f*acosf(q.w); + float den = sqrtf(1.0f - q.w*q.w); + + if (den > 0.0001f) + { + resAxis.x = q.x/den; + resAxis.y = q.y/den; + resAxis.z = q.z/den; + } + else + { + // This occurs when the angle is zero. + // Not a problem: just set an arbitrary normalized axis. + resAxis.x = 1.0f; + } + + *outAxis = resAxis; + *outAngle = resAngle; +} + +// Returns he quaternion equivalent to Euler angles +RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw) +{ + Quaternion q = { 0 }; + + float x0 = cosf(roll*0.5f); + float x1 = sinf(roll*0.5f); + float y0 = cosf(pitch*0.5f); + float y1 = sinf(pitch*0.5f); + float z0 = cosf(yaw*0.5f); + float z1 = sinf(yaw*0.5f); + + q.x = x1*y0*z0 - x0*y1*z1; + q.y = x0*y1*z0 + x1*y0*z1; + q.z = x0*y0*z1 - x1*y1*z0; + q.w = x0*y0*z0 + x1*y1*z1; + + return q; +} + +// Return the Euler angles equivalent to quaternion (roll, pitch, yaw) +// NOTE: Angles are returned in a Vector3 struct in degrees +RMDEF Vector3 QuaternionToEuler(Quaternion q) +{ + Vector3 result = { 0 }; + + // roll (x-axis rotation) + float x0 = 2.0f*(q.w*q.x + q.y*q.z); + float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); + result.x = atan2f(x0, x1)*RAD2DEG; + + // pitch (y-axis rotation) + float y0 = 2.0f*(q.w*q.y - q.z*q.x); + y0 = y0 > 1.0f ? 1.0f : y0; + y0 = y0 < -1.0f ? -1.0f : y0; + result.y = asinf(y0)*RAD2DEG; + + // yaw (z-axis rotation) + float z0 = 2.0f*(q.w*q.z + q.x*q.y); + float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); + result.z = atan2f(z0, z1)*RAD2DEG; + + return result; +} + +// Transform a quaternion given a transformation matrix +RMDEF Quaternion QuaternionTransform(Quaternion q, Matrix mat) +{ + Quaternion result = { 0 }; + + result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; + result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; + result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; + result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; + + return result; +} + +// Projects a Vector3 from screen space into object space +RMDEF Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view) +{ + Vector3 result = { 0.0f, 0.0f, 0.0f }; + + // Calculate unproject matrix (multiply view patrix by projection matrix) and invert it + Matrix matViewProj = MatrixMultiply(view, projection); + matViewProj = MatrixInvert(matViewProj); + + // Create quaternion from source point + Quaternion quat = { source.x, source.y, source.z, 1.0f }; + + // Multiply quat point by unproject matrix + quat = QuaternionTransform(quat, matViewProj); + + // Normalized world points in vectors + result.x = quat.x/quat.w; + result.y = quat.y/quat.w; + result.z = quat.z/quat.w; + + return result; +} + +#endif // RAYMATH_H diff --git a/include/raymath.hpp b/include/raymath.hpp new file mode 100644 index 0000000..4e17405 --- /dev/null +++ b/include/raymath.hpp @@ -0,0 +1,38 @@ +/* +* LICENSE: zlib/libpng +* +* raylib-cpp is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2020 Rob Loach (@RobLoach) +* +* 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 RAYLIB_CPP_INCLUDE_RAYMATH_HPP_ +#define RAYLIB_CPP_INCLUDE_RAYMATH_HPP_ + +#ifdef __cplusplus +extern "C" { +#endif +#ifndef RAYLIB_CPP_NO_MATH +#include "raymath.h" // NOLINT +#endif +#ifdef __cplusplus +} +#endif + +#endif // RAYLIB_CPP_INCLUDE_RAYMATH_HPP_ diff --git a/lib/libraylib.a b/lib/libraylib.a new file mode 100644 index 0000000000000000000000000000000000000000..46dccb68241d032b20fb41739b5cb6bc2695fa2e GIT binary patch literal 1444032 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

mPcF%WPO>c%q-tdLw5>+#c-mkR`1cI{ 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 z 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