commit 85f1dd7a1e19681e7633a070db1eb3b42f7a73be Author: Jonathan Moallem Date: Thu Nov 19 14:55:38 2020 +1100 Initial commit 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 0000000..46dccb6 Binary files /dev/null and b/lib/libraylib.a differ diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..226b7c9 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,35 @@ +#include + +int main() { + // Initialization + //-------------------------------------------------------------------------------------- + int screenWidth = 800; + int screenHeight = 450; + raylib::Color textColor(LIGHTGRAY); + raylib::Window w(screenWidth, screenHeight, "raylib [core] example - basic window"); + + SetTargetFPS(60); + //-------------------------------------------------------------------------------------- + + // Main game loop + while (!w.ShouldClose()) // Detect window close button or ESC key + { + // Update + //---------------------------------------------------------------------------------- + // TODO: Update your variables here + //---------------------------------------------------------------------------------- + + // Draw + //---------------------------------------------------------------------------------- + BeginDrawing(); + + ClearBackground(RAYWHITE); + + textColor.DrawText("Congrats! You created your first window!", 190, 200, 20); + + EndDrawing(); + //---------------------------------------------------------------------------------- + } + + return 0; +} \ No newline at end of file