Clean up default constructors and Load() methods

Author: RobLoach

.github/workflows/Tests.yml

@@ -22,4 +22,4 @@ jobs:
       run: cmake --build build
 
     - name: Test
-      run: ./build/tests/raylib_test
+      run: ./build/tests/raylib_cpp_test

include/AudioDevice.hpp

@@ -3,6 +3,7 @@
 
 #include "./raylib.hpp"
 #include "./raylib-cpp-utils.hpp"
+#include "./RaylibException.hpp"
 
 namespace raylib {
 /**
@@ -17,7 +18,9 @@ class AudioDevice {
      */
     AudioDevice(bool lateInit = false) {
         if (!lateInit) {
-            Init();
+            if (!Init()) {
+                throw RaylibException("Failed to initialize AudioDevice");
+            }
         }
     }
 
@@ -31,9 +34,9 @@ class AudioDevice {
     /**
      * Initialize audio device and context.
      */
-    inline AudioDevice& Init() {
+    inline bool Init() {
         ::InitAudioDevice();
-        return *this;
+        return IsReady();
     }
 
     /**

include/AudioStream.hpp

@@ -3,6 +3,7 @@
 
 #include "./raylib.hpp"
 #include "./raylib-cpp-utils.hpp"
+#include "./RaylibException.hpp"
 
 namespace raylib {
 /**
@@ -14,11 +15,20 @@ class AudioStream : public ::AudioStream {
         set(music);
     }
 
+    AudioStream(rAudioBuffer* buffer = nullptr,
+            unsigned int sampleRate = 0,
+            unsigned int sampleSize = 0,
+            unsigned int channels = 0) : ::AudioStream{buffer, sampleRate, sampleSize, channels} {
+        // Nothing.
+    }
+
     /**
      * Init audio stream (to stream raw audio pcm data)
      */
     AudioStream(unsigned int SampleRate, unsigned int SampleSize, unsigned int Channels = 2) {
-        set(LoadAudioStream(SampleRate, SampleSize, Channels));
+        if (!Load(SampleRate, SampleSize, Channels)) {
+            throw RaylibException("Failed to create AudioStream");
+        }
     }
 
     AudioStream(const AudioStream&) = delete;
@@ -148,6 +158,18 @@ class AudioStream : public ::AudioStream {
         ::SetAudioStreamBufferSizeDefault(size);
     }
 
+    bool IsReady() {
+        return channels > 0;
+    }
+
+    /**
+     * Init audio stream (to stream raw audio pcm data)
+     */
+    bool Load(unsigned int SampleRate, unsigned int SampleSize, unsigned int Channels = 2) {
+        set(::LoadAudioStream(SampleRate, SampleSize, Channels));
+        return IsReady();
+    }
+
  private:
     inline void set(const ::AudioStream& stream) {
         buffer = stream.buffer;

include/Font.hpp

@@ -5,13 +5,23 @@
 
 #include "./raylib.hpp"
 #include "./raylib-cpp-utils.hpp"
+#include "./RaylibException.hpp"
 
 namespace raylib {
 /**
  * Font type, includes texture and charSet array data
  */
 class Font : public ::Font {
  public:
+    Font(int baseSize,
+            int glyphCount,
+            int glyphPadding,
+            ::Texture2D texture,
+            ::Rectangle *recs = nullptr,
+            ::GlyphInfo *glyphs = nullptr) : ::Font{baseSize, glyphCount, glyphPadding, texture, recs, glyphs} {
+        // Nothing.
+    }
+
     Font() {
         set(::GetFontDefault());
     }
@@ -21,21 +31,28 @@ class Font : public ::Font {
     }
 
     Font(const std::string& fileName) {
-        set(::LoadFont(fileName.c_str()));
+        if (!Load(fileName)) {
+            throw RaylibException("Failed to load Font from file");
+        }
     }
 
     Font(const std::string& fileName, int fontSize, int* fontChars, int charCount)  {
-        set(::LoadFontEx(fileName.c_str(), fontSize, fontChars, charCount));
+        if (!Load(fileName, fontSize, fontChars, charCount)) {
+            throw RaylibException("Failed to load font from font with extras");
+        }
     }
 
     Font(const ::Image& image, ::Color key, int firstChar) {
-        set(::LoadFontFromImage(image, key, firstChar));
+        if (!Load(image, key, firstChar)) {
+            throw RaylibException("Failed to load Texture from Image");
+        }
     }
 
     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));
+        if (!Load(fileType, fileData, dataSize, fontSize, fontChars, charsCount)) {
+            throw RaylibException("Failed to load Texture from file data");
+        }
     }
 
     Font(const Font&) = delete;
@@ -91,6 +108,28 @@ class Font : public ::Font {
         return *this;
     }
 
+    bool Load(const std::string& fileName) {
+        set(::LoadFont(fileName.c_str()));
+        return baseSize > 0;
+    }
+
+    bool Load(const std::string& fileName, int fontSize, int* fontChars, int charCount)  {
+        set(::LoadFontEx(fileName.c_str(), fontSize, fontChars, charCount));
+        return baseSize > 0;
+    }
+
+    bool Load(const ::Image& image, ::Color key, int firstChar) {
+        set(::LoadFontFromImage(image, key, firstChar));
+        return baseSize > 0;
+    }
+
+    bool Load(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));
+        return baseSize > 0;
+    }
+
     /**
      * Draw text using font and additional parameters.
      */

include/Image.hpp

@@ -15,41 +15,75 @@ namespace raylib {
  */
 class Image : public ::Image {
  public:
+    Image(void* data = nullptr,
+            int width = 0,
+            int height = 0,
+            int mipmaps = 0,
+            int format = 0) : ::Image{data, width, height, mipmaps, format} {
+        // Nothing.
+    }
+
     Image(const ::Image& image) {
         set(image);
     }
 
+    /**
+     * Load an image from the given file.
+     *
+     * @throws raylib::RaylibException Thrown if the image failed to load from the file.
+     *
+     * @see Load()
+     */
     Image(const std::string& fileName) {
-        Load(fileName);
-        if (!IsReady()) {
+        if (!Load(fileName)) {
             throw RaylibException(TextFormat("Failed to load Image from file: %s", fileName.c_str()));
         }
     }
 
+    /**
+     * Load a raw image from the given file, with the provided width, height, and formats.
+     *
+     * @throws raylib::RaylibException Thrown if the image failed to load from the file.
+     *
+     * @see LoadRaw()
+     */
     Image(const std::string& fileName, int width, int height, int format, int headerSize) {
-        LoadRaw(fileName, width, height, format, headerSize);
-        if (!IsReady()) {
+        if (!Load(fileName, width, height, format, headerSize)) {
             throw RaylibException(TextFormat("Failed to load Image from file: %s", fileName.c_str()));
         }
     }
 
+    /**
+     * Load an animation image from the given file.
+     *
+     * @throws raylib::RaylibException Thrown if the image failed to load from the file.
+     *
+     * @see LoadAnim()
+     */
     Image(const std::string& fileName, int* frames) {
-        LoadAnim(fileName, frames);
-        if (!IsReady()) {
+        if (!Load(fileName, frames)) {
             throw RaylibException(TextFormat("Failed to load Image from animation: %s", fileName.c_str()));
         }
     }
 
+    /**
+     * Load an image from the given file.
+     *
+     * @throws raylib::RaylibException Thrown if the image failed to load from the file.
+     */
     Image(const std::string& fileType, const unsigned char* fileData, int dataSize) {
-        LoadFromMemory(fileType, fileData, dataSize);
-        if (!IsReady()) {
+        if (!Load(fileType, fileData, dataSize)) {
             throw RaylibException("Failed to load Image from memory");
         }
     }
 
+    /**
+     * Load an image from the given file.
+     *
+     * @throws raylib::RaylibException Thrown if the image failed to load from the file.
+     */
     Image(const ::Texture2D& texture) {
-        set(::LoadImageFromTexture(texture));
-        if (!IsReady()) {
+        if (!Load(texture)) {
             throw RaylibException("Failed to load Image from Texture");
         }
     }
@@ -189,32 +223,46 @@ class Image : public ::Image {
     /**
      * Load image from file into CPU memory (RAM)
      */
-    void Load(const std::string& fileName) {
+    bool Load(const std::string& fileName) {
         set(::LoadImage(fileName.c_str()));
+        return IsReady();
     }
 
     /**
      * Load image from RAW file data.
      */
-    void LoadRaw(const std::string& fileName, int width, int height, int format, int headerSize) {
+    bool Load(const std::string& fileName, int width, int height, int format, int headerSize) {
         set(::LoadImageRaw(fileName.c_str(), width, height, format, headerSize));
+        return IsReady();
     }
 
     /**
      * Load image sequence from file (frames appended to image.data).
      */
-    void LoadAnim(const std::string& fileName, int* frames) {
+    bool Load(const std::string& fileName, int* frames) {
         set(::LoadImageAnim(fileName.c_str(), frames));
+        return IsReady();
     }
 
     /**
      * Load image from memory buffer, fileType refers to extension: i.e. "png".
      */
-    void LoadFromMemory(
+    bool Load(
             const std::string& fileType,
             const unsigned char *fileData,
             int dataSize) {
         set(::LoadImageFromMemory(fileType.c_str(), fileData, dataSize));
+        return IsReady();
+    }
+
+    /**
+     * Load an image from the given file.
+     *
+     * @return True or false depending on whether or not the image was loaded from the texture.
+     */
+    bool Load(const ::Texture2D& texture) {
+        set(::LoadImageFromTexture(texture));
+        return IsReady();
     }
 
     /**

include/Model.hpp

@@ -6,6 +6,7 @@
 #include "./raylib.hpp"
 #include "./raylib-cpp-utils.hpp"
 #include "./Mesh.hpp"
+#include "./RaylibException.hpp"
 
 namespace raylib {
 /**
@@ -18,11 +19,15 @@ class Model : public ::Model {
     }
 
     Model(const std::string& fileName) {
-        set(::LoadModel(fileName.c_str()));
+        if (!Load(fileName)) {
+            throw RaylibException("Failed to load Model from filename");
+        }
     }
 
     Model(const ::Mesh& mesh) {
-        set(::LoadModelFromMesh(mesh));
+        if (!Load(mesh)) {
+            throw RaylibException("Failed to load Model from Mesh");
+        }
     }
 
     ~Model() {
@@ -188,6 +193,20 @@ class Model : public ::Model {
         return ::GetModelBoundingBox(*this);
     }
 
+    bool IsReady() {
+        return meshCount > 0 || materialCount > 0 || boneCount > 0;
+    }
+
+    bool Load(const std::string& fileName) {
+        set(::LoadModel(fileName.c_str()));
+        return IsReady();
+    }
+
+    bool Load(const ::Mesh& mesh) {
+        set(::LoadModelFromMesh(mesh));
+        return IsReady();
+    }
+
  private:
     inline void set(const ::Model& model) {
         transform = model.transform;
@@ -203,6 +222,7 @@ class Model : public ::Model {
         bindPose = model.bindPose;
     }
 };
+
 }  // namespace raylib
 
 #endif  // RAYLIB_CPP_INCLUDE_MODEL_HPP_