text: #include <phpcpp.h>
  #include <raylib.h>
  #include <raymath.h>
  
  #define PHYSAC_IMPLEMENTATION
  #define PHYSAC_NO_THREADS
  #include <physac.h>
  
  #define RLIGHTS_IMPLEMENTATION
  #include "./rlights.h"
  
  using namespace std;
  
  namespace rl {
  
  template <typename T>
  class ScalarArray : public Php::Base,
                      public Php::ArrayAccess,
                      public Php::Countable {
    public:
      T *data;
      int item_count;
      ScalarArray(T *_data) {
          data = _data;
          item_count = -1;
      }
      ScalarArray(T *_data, int _count) {
          data = _data;
          item_count = _count;
      }
  
      Php::Value getArray() {
          std::vector<Php::Value> result;
          for (int i = 0; i < item_count; i++) {
              result.push_back(Php::Value(data[i]));
          }
          return result;
      }
  
      virtual bool offsetExists(const Php::Value &key) override {
          return key.isNumeric() &&
                 (item_count == -1 || item_count > key.isNumeric());
      }
  
      virtual void offsetSet(const Php::Value &key,
                             const Php::Value &value) override {
          data[key.numericValue()] = (T)(value.floatValue());
      }
  
      virtual Php::Value offsetGet(const Php::Value &key) override {
          return (T)data[key.numericValue()];
      }
  
      virtual void offsetUnset(const Php::Value &key) override { return; }
      virtual long count() override { return item_count; }
  };
  
  template <typename T, typename U>
  class StructArray : public Php::Base,
                      public Php::ArrayAccess,
                      public Php::Countable {
    public:
      T *data;
      int item_count;
      string name;
      StructArray(string _name, T *_data) {
          name = _name;
          data = _data;
          item_count = -1;
      }
      StructArray(string _name, T *_data, int _count) {
          name = _name;
          data = _data;
          item_count = _count;
      }
  
      Php::Value getArray() {
          std::vector<Php::Value> result;
          for (int i = 0; i < item_count; i++) {
              result.push_back(Php::Object(name.c_str(), new U(data[i])));
          }
          return result;
      }
  
      virtual bool offsetExists(const Php::Value &key) override {
          return key.isNumeric() &&
                 (item_count == -1 || item_count > key.isNumeric());
      }
  
      virtual void offsetSet(const Php::Value &key,
                             const Php::Value &value) override {
          data[key.numericValue()] = ((U *)value.implementation())->data;
      }
  
      virtual Php::Value offsetGet(const Php::Value &key) override {
          return Php::Object(name.c_str(), new U(data[key]));
      }
  
      virtual void offsetUnset(const Php::Value &key) override { return; }
      virtual long count() override { return item_count; }
  };
  
  class Vector2 : public Php::Base {
    public:
      ::Vector2 data;
      void __destruct() const {}
      Vector2(::Vector2 x) { data = x; }
      Php::Value getx() {
          double result = data.x;
          return result;
      }
      Php::Value gety() {
          double result = data.y;
          return result;
      }
      void setx(const Php::Value &v) { data.x = (double)v; }
      void sety(const Php::Value &v) { data.y = (double)v; }
  };
  
  class Vector3 : public Php::Base {
    public:
      ::Vector3 data;
      void __destruct() const {}
      Vector3(::Vector3 x) { data = x; }
      Php::Value getx() {
          double result = data.x;
          return result;
      }
      Php::Value gety() {
          double result = data.y;
          return result;
      }
      Php::Value getz() {
          double result = data.z;
          return result;
      }
      void setx(const Php::Value &v) { data.x = (double)v; }
      void sety(const Php::Value &v) { data.y = (double)v; }
      void setz(const Php::Value &v) { data.z = (double)v; }
  };
  
  class Vector4 : public Php::Base {
    public:
      ::Vector4 data;
      void __destruct() const {}
      Vector4(::Vector4 x) { data = x; }
      Php::Value getx() {
          double result = data.x;
          return result;
      }
      Php::Value gety() {
          double result = data.y;
          return result;
      }
      Php::Value getz() {
          double result = data.z;
          return result;
      }
      Php::Value getw() {
          double result = data.w;
          return result;
      }
      void setx(const Php::Value &v) { data.x = (double)v; }
      void sety(const Php::Value &v) { data.y = (double)v; }
      void setz(const Php::Value &v) { data.z = (double)v; }
      void setw(const Php::Value &v) { data.w = (double)v; }
  };
  
  class Matrix : public Php::Base {
    public:
      ::Matrix data;
      void __destruct() const {}
      Matrix(::Matrix x) { data = x; }
      Php::Value getm0() {
          double result = data.m0;
          return result;
      }
      Php::Value getm4() {
          double result = data.m4;
          return result;
      }
      Php::Value getm8() {
          double result = data.m8;
          return result;
      }
      Php::Value getm12() {
          double result = data.m12;
          return result;
      }
      Php::Value getm1() {
          double result = data.m1;
          return result;
      }
      Php::Value getm5() {
          double result = data.m5;
          return result;
      }
      Php::Value getm9() {
          double result = data.m9;
          return result;
      }
      Php::Value getm13() {
          double result = data.m13;
          return result;
      }
      Php::Value getm2() {
          double result = data.m2;
          return result;
      }
      Php::Value getm6() {
          double result = data.m6;
          return result;
      }
      Php::Value getm10() {
          double result = data.m10;
          return result;
      }
      Php::Value getm14() {
          double result = data.m14;
          return result;
      }
      Php::Value getm3() {
          double result = data.m3;
          return result;
      }
      Php::Value getm7() {
          double result = data.m7;
          return result;
      }
      Php::Value getm11() {
          double result = data.m11;
          return result;
      }
      Php::Value getm15() {
          double result = data.m15;
          return result;
      }
      void setm0(const Php::Value &v) { data.m0 = (double)v; }
      void setm4(const Php::Value &v) { data.m4 = (double)v; }
      void setm8(const Php::Value &v) { data.m8 = (double)v; }
      void setm12(const Php::Value &v) { data.m12 = (double)v; }
      void setm1(const Php::Value &v) { data.m1 = (double)v; }
      void setm5(const Php::Value &v) { data.m5 = (double)v; }
      void setm9(const Php::Value &v) { data.m9 = (double)v; }
      void setm13(const Php::Value &v) { data.m13 = (double)v; }
      void setm2(const Php::Value &v) { data.m2 = (double)v; }
      void setm6(const Php::Value &v) { data.m6 = (double)v; }
      void setm10(const Php::Value &v) { data.m10 = (double)v; }
      void setm14(const Php::Value &v) { data.m14 = (double)v; }
      void setm3(const Php::Value &v) { data.m3 = (double)v; }
      void setm7(const Php::Value &v) { data.m7 = (double)v; }
      void setm11(const Php::Value &v) { data.m11 = (double)v; }
      void setm15(const Php::Value &v) { data.m15 = (double)v; }
  };
  
  class Color : public Php::Base {
    public:
      ::Color data;
      void __destruct() const {}
      Color(::Color x) { data = x; }
      Php::Value getr() {
          int result = data.r;
          return result;
      }
      Php::Value getg() {
          int result = data.g;
          return result;
      }
      Php::Value getb() {
          int result = data.b;
          return result;
      }
      Php::Value geta() {
          int result = data.a;
          return result;
      }
      void setr(const Php::Value &v) { data.r = (int)v; }
      void setg(const Php::Value &v) { data.g = (int)v; }
      void setb(const Php::Value &v) { data.b = (int)v; }
      void seta(const Php::Value &v) { data.a = (int)v; }
  };
  
  class Rectangle : public Php::Base {
    public:
      ::Rectangle data;
      void __destruct() const {}
      Rectangle(::Rectangle x) { data = x; }
      Php::Value getx() {
          double result = data.x;
          return result;
      }
      Php::Value gety() {
          double result = data.y;
          return result;
      }
      Php::Value getwidth() {
          double result = data.width;
          return result;
      }
      Php::Value getheight() {
          double result = data.height;
          return result;
      }
      void setx(const Php::Value &v) { data.x = (double)v; }
      void sety(const Php::Value &v) { data.y = (double)v; }
      void setwidth(const Php::Value &v) { data.width = (double)v; }
      void setheight(const Php::Value &v) { data.height = (double)v; }
  };
  
  class Image : public Php::Base {
    public:
      ::Image data;
      void __destruct() const {}
      Image(::Image x) { data = x; }
      Php::Value getdata() {
          void *result = data.data;
          return static_cast<std::string *>(result);
      }
      Php::Value getwidth() {
          int result = data.width;
          return result;
      }
      Php::Value getheight() {
          int result = data.height;
          return result;
      }
      Php::Value getmipmaps() {
          int result = data.mipmaps;
          return result;
      }
      Php::Value getformat() {
          int result = data.format;
          return result;
      }
      void setwidth(const Php::Value &v) { data.width = (int)v; }
      void setheight(const Php::Value &v) { data.height = (int)v; }
      void setmipmaps(const Php::Value &v) { data.mipmaps = (int)v; }
      void setformat(const Php::Value &v) { data.format = (int)v; }
      void setdata(const Php::Value &v) {
          data.data = (void *)v.stringValue().data();
      }
  };
  
  class Texture2D : public Php::Base {
    public:
      ::Texture2D data;
      void __destruct() const {}
      Texture2D(::Texture2D x) { data = x; }
      Php::Value getid() {
          long result = data.id;
          return result;
      }
      Php::Value getwidth() {
          int result = data.width;
          return result;
      }
      Php::Value getheight() {
          int result = data.height;
          return result;
      }
      Php::Value getmipmaps() {
          int result = data.mipmaps;
          return result;
      }
      Php::Value getformat() {
          int result = data.format;
          return result;
      }
      void setid(const Php::Value &v) { data.id = (long)v; }
      void setwidth(const Php::Value &v) { data.width = (int)v; }
      void setheight(const Php::Value &v) { data.height = (int)v; }
      void setmipmaps(const Php::Value &v) { data.mipmaps = (int)v; }
      void setformat(const Php::Value &v) { data.format = (int)v; }
  };
  
  class RenderTexture2D : public Php::Base {
    public:
      ::RenderTexture2D data;
      void __destruct() const {}
      RenderTexture2D(::RenderTexture2D x) { data = x; }
      Php::Value getid() {
          long result = data.id;
          return result;
      }
      Php::Value gettexture() {
          Php::Value result =
              Php::Object("RayLib\\Texture2D", new Texture2D(data.texture));
          return result;
      }
      Php::Value getdepth() {
          Php::Value result =
              Php::Object("RayLib\\Texture2D", new Texture2D(data.depth));
          return result;
      }
      void setid(const Php::Value &v) { data.id = (long)v; }
      void settexture(const Php::Value &v) {
          data.texture = ((Texture2D *)(v.implementation()))->data;
      }
      void setdepth(const Php::Value &v) {
          data.depth = ((Texture2D *)(v.implementation()))->data;
      }
  };
  
  class NPatchInfo : public Php::Base {
    public:
      ::NPatchInfo data;
      void __destruct() const {}
      NPatchInfo(::NPatchInfo x) { data = x; }
      Php::Value getleft() {
          int result = data.left;
          return result;
      }
      Php::Value gettop() {
          int result = data.top;
          return result;
      }
      Php::Value getright() {
          int result = data.right;
          return result;
      }
      Php::Value getbottom() {
          int result = data.bottom;
          return result;
      }
      Php::Value gettype() {
          int result = data.type;
          return result;
      }
      void setleft(const Php::Value &v) { data.left = (int)v; }
      void settop(const Php::Value &v) { data.top = (int)v; }
      void setright(const Php::Value &v) { data.right = (int)v; }
      void setbottom(const Php::Value &v) { data.bottom = (int)v; }
      void settype(const Php::Value &v) { data.type = (int)v; }
  };
  
  class CharInfo : public Php::Base {
    public:
      ::CharInfo data;
      void __destruct() const {}
      CharInfo(::CharInfo x) { data = x; }
      Php::Value getvalue() {
          int result = data.value;
          return result;
      }
      Php::Value getoffsetX() {
          int result = data.offsetX;
          return result;
      }
      Php::Value getoffsetY() {
          int result = data.offsetY;
          return result;
      }
      Php::Value getadvanceX() {
          int result = data.advanceX;
          return result;
      }
      Php::Value getimage() {
          Php::Value result = Php::Object("RayLib\\Image", new Image(data.image));
          return result;
      }
      void setvalue(const Php::Value &v) { data.value = (int)v; }
      void setoffsetX(const Php::Value &v) { data.offsetX = (int)v; }
      void setoffsetY(const Php::Value &v) { data.offsetY = (int)v; }
      void setadvanceX(const Php::Value &v) { data.advanceX = (int)v; }
      void setimage(const Php::Value &v) {
          data.image = ((Image *)(v.implementation()))->data;
      }
  };
  
  class Font : public Php::Base {
    public:
      ::Font data;
      void __destruct() const {}
      Font(::Font x) { data = x; }
      Php::Value getbaseSize() {
          int result = data.baseSize;
          return result;
      }
      Php::Value getcharsCount() {
          int result = data.charsCount;
          return result;
      }
      Php::Value gettexture() {
          Php::Value result =
              Php::Object("RayLib\\Texture2D", new Texture2D(data.texture));
          return result;
      }
      void setbaseSize(const Php::Value &v) { data.baseSize = (int)v; }
      void setcharsCount(const Php::Value &v) { data.charsCount = (int)v; }
      void settexture(const Php::Value &v) {
          data.texture = ((Texture2D *)(v.implementation()))->data;
      }
  };
  
  class Camera3D : public Php::Base {
    public:
      ::Camera3D data;
      void __destruct() const {}
      Camera3D(::Camera3D x) { data = x; }
      Php::Value getposition() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.position));
          return result;
      }
      Php::Value gettarget() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.target));
          return result;
      }
      Php::Value getup() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.up));
          return result;
      }
      Php::Value getfovy() {
          double result = data.fovy;
          return result;
      }
      Php::Value gettype() {
          int result = data.type;
          return result;
      }
      void setposition(const Php::Value &v) {
          data.position = ((Vector3 *)(v.implementation()))->data;
      }
      void settarget(const Php::Value &v) {
          data.target = ((Vector3 *)(v.implementation()))->data;
      }
      void setup(const Php::Value &v) {
          data.up = ((Vector3 *)(v.implementation()))->data;
      }
      void setfovy(const Php::Value &v) { data.fovy = (double)v; }
      void settype(const Php::Value &v) { data.type = (int)v; }
  };
  
  class Camera2D : public Php::Base {
    public:
      ::Camera2D data;
      void __destruct() const {}
      Camera2D(::Camera2D x) { data = x; }
      Php::Value getoffset() {
          Php::Value result =
              Php::Object("RayLib\\Vector2", new Vector2(data.offset));
          return result;
      }
      Php::Value gettarget() {
          Php::Value result =
              Php::Object("RayLib\\Vector2", new Vector2(data.target));
          return result;
      }
      Php::Value getrotation() {
          double result = data.rotation;
          return result;
      }
      Php::Value getzoom() {
          double result = data.zoom;
          return result;
      }
      void setoffset(const Php::Value &v) {
          data.offset = ((Vector2 *)(v.implementation()))->data;
      }
      void settarget(const Php::Value &v) {
          data.target = ((Vector2 *)(v.implementation()))->data;
      }
      void setrotation(const Php::Value &v) { data.rotation = (double)v; }
      void setzoom(const Php::Value &v) { data.zoom = (double)v; }
  };
  
  class Mesh : public Php::Base {
    public:
      ::Mesh data;
      void __destruct() const {}
      Mesh(::Mesh x) { data = x; }
      Php::Value getvertexCount() {
          int result = data.vertexCount;
          return result;
      }
      Php::Value gettriangleCount() {
          int result = data.triangleCount;
          return result;
      }
      Php::Value getvaoId() {
          long result = data.vaoId;
          return result;
      }
      Php::Value getvertices() { throw Php::Exception("Not implemented"); }
      Php::Value gettexcoords() { throw Php::Exception("Not implemented"); }
      Php::Value gettexcoords2() { throw Php::Exception("Not implemented"); }
      Php::Value getnormals() { throw Php::Exception("Not implemented"); }
      Php::Value gettangents() { throw Php::Exception("Not implemented"); }
      Php::Value getcolors() { throw Php::Exception("Not implemented"); }
      Php::Value getindices() { throw Php::Exception("Not implemented"); }
      Php::Value getanimVertices() { throw Php::Exception("Not implemented"); }
      Php::Value getanimNormals() { throw Php::Exception("Not implemented"); }
      Php::Value getboneIds() { throw Php::Exception("Not implemented"); }
      Php::Value getboneWeights() { throw Php::Exception("Not implemented"); }
      Php::Value getvboId() { throw Php::Exception("Not implemented"); }
      void setvertexCount(const Php::Value &v) { data.vertexCount = (int)v; }
      void settriangleCount(const Php::Value &v) { data.triangleCount = (int)v; }
      void setvaoId(const Php::Value &v) { data.vaoId = (long)v; }
      void setvertices(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void settexcoords(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void settexcoords2(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setnormals(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void settangents(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setcolors(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setindices(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setanimVertices(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setanimNormals(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setboneIds(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setboneWeights(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setvboId(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
  };
  
  class Shader : public Php::Base {
    public:
      ::Shader data;
      void __destruct() const {}
      Shader(::Shader x) { data = x; }
      Php::Value getid() {
          long result = data.id;
          return result;
      }
      Php::Value getlocs() {
          std::vector<int> result;
          for (int i = 0; i < 32; i++) {
              result.push_back(data.locs[i]);
          }
          return result;
      }
      void setid(const Php::Value &v) { data.id = (long)v; }
      void setlocs(const Php::Value &v) {
          auto arr = v.vectorValue<int>();
          for (size_t i = 0; i < arr.size(); ++i) {
              data.locs[i] = arr[i];
          }
      }
  };
  
  class MaterialMap : public Php::Base {
    public:
      ::MaterialMap data;
      void __destruct() const {}
      MaterialMap(::MaterialMap x) { data = x; }
      Php::Value gettexture() {
          Php::Value result =
              Php::Object("RayLib\\Texture2D", new Texture2D(data.texture));
          return result;
      }
      Php::Value getcolor() {
          Php::Value result = Php::Object("RayLib\\Color", new Color(data.color));
          return result;
      }
      Php::Value getvalue() {
          double result = data.value;
          return result;
      }
      void settexture(const Php::Value &v) {
          data.texture = ((Texture2D *)(v.implementation()))->data;
      }
      void setcolor(const Php::Value &v) {
          data.color = ((Color *)(v.implementation()))->data;
      }
      void setvalue(const Php::Value &v) { data.value = (double)v; }
  };
  
  class Material : public Php::Base {
    public:
      ::Material data;
      void __destruct() const {}
      Material(::Material x) { data = x; }
      Php::Value getshader() {
          Php::Value result =
              Php::Object("RayLib\\Shader", new Shader(data.shader));
          return result;
      }
      Php::Value getmaps() {
          std::vector<Php::Value> result;
          for (int i = 0; i < 12; i++) {
              result.push_back(Php::Object("RayLib\\MaterialMap",
                                           new MaterialMap(data.maps[i])));
          }
          return result;
      }
      Php::Value getparams() { throw Php::Exception("Not implemented"); }
      void setshader(const Php::Value &v) {
          data.shader = ((Shader *)(v.implementation()))->data;
      }
      void setmaps(const Php::Value &v) {
          auto arr = v.vectorValue<Php::Value>();
          for (size_t i = 0; i < arr.size(); ++i) {
              data.maps[i] = ((MaterialMap *)(arr[i].implementation()))->data;
          }
      }
      void setparams(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
  };
  
  class Transform : public Php::Base {
    public:
      ::Transform data;
      void __destruct() const {}
      Transform(::Transform x) { data = x; }
      Php::Value gettranslation() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.translation));
          return result;
      }
      Php::Value getrotation() {
          Php::Value result =
              Php::Object("RayLib\\Vector4", new Vector4(data.rotation));
          return result;
      }
      Php::Value getscale() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.scale));
          return result;
      }
      void settranslation(const Php::Value &v) {
          data.translation = ((Vector3 *)(v.implementation()))->data;
      }
      void setrotation(const Php::Value &v) {
          data.rotation = ((Vector4 *)(v.implementation()))->data;
      }
      void setscale(const Php::Value &v) {
          data.scale = ((Vector3 *)(v.implementation()))->data;
      }
  };
  
  class BoneInfo : public Php::Base {
    public:
      ::BoneInfo data;
      void __destruct() const {}
      BoneInfo(::BoneInfo x) { data = x; }
      Php::Value getname() {
          string result(data.name, 32);
          return result;
      }
      Php::Value getparent() {
          int result = data.parent;
          return result;
      }
      void setname(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setparent(const Php::Value &v) { data.parent = (int)v; }
  };
  
  class Model : public Php::Base {
    public:
      ::Model data;
      void __destruct() const {}
      Model(::Model x) { data = x; }
      Php::Value gettransform() {
          Php::Value result =
              Php::Object("RayLib\\Matrix", new Matrix(data.transform));
          return result;
      }
      Php::Value getmeshCount() {
          int result = data.meshCount;
          return result;
      }
      Php::Value getmeshes() {
          std::vector<Php::Value> result;
          for (int i = 0; i < data.meshCount; i++) {
              result.push_back(
                  Php::Object("RayLib\\Mesh", new Mesh(data.meshes[i])));
          }
          return result;
      }
      Php::Value getmaterials() {
          std::vector<Php::Value> result;
          for (int i = 0; i < data.materialCount; i++) {
              result.push_back(Php::Object("RayLib\\Material",
                                           new Material(data.materials[i])));
          }
          return result;
      }
      Php::Value getmeshMaterial() { throw Php::Exception("Not implemented"); }
      Php::Value getmaterialCount() {
          int result = data.materialCount;
          return result;
      }
      Php::Value getboneCount() {
          int result = data.boneCount;
          return result;
      }
      void settransform(const Php::Value &v) {
          data.transform = ((Matrix *)(v.implementation()))->data;
      }
      void setmeshCount(const Php::Value &v) { data.meshCount = (int)v; }
      void setmeshes(const Php::Value &v) {
          auto arr = v.vectorValue<Php::Value>();
          for (size_t i = 0; i < arr.size(); ++i) {
              data.meshes[i] = ((Mesh *)(arr[i].implementation()))->data;
          }
      }
      void setmaterialCount(const Php::Value &v) { data.materialCount = (int)v; }
      void setmaterials(const Php::Value &v) {
          auto arr = v.vectorValue<Php::Value>();
          for (size_t i = 0; i < arr.size(); ++i) {
              data.materials[i] = ((Material *)(arr[i].implementation()))->data;
          }
      }
      void setmeshMaterial(const Php::Value &v) {
          throw Php::Exception("Not implemented");
      }
      void setboneCount(const Php::Value &v) { data.boneCount = (int)v; }
  };
  
  class ModelAnimation : public Php::Base {
    public:
      ::ModelAnimation data;
      void __destruct() const {}
      ModelAnimation(::ModelAnimation x) { data = x; }
      Php::Value getboneCount() {
          int result = data.boneCount;
          return result;
      }
      Php::Value getframeCount() {
          int result = data.frameCount;
          return result;
      }
      void setboneCount(const Php::Value &v) { data.boneCount = (int)v; }
      void setframeCount(const Php::Value &v) { data.frameCount = (int)v; }
  };
  
  class Ray : public Php::Base {
    public:
      ::Ray data;
      void __destruct() const {}
      Ray(::Ray x) { data = x; }
      Php::Value getposition() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.position));
          return result;
      }
      Php::Value getdirection() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.direction));
          return result;
      }
      void setposition(const Php::Value &v) {
          data.position = ((Vector3 *)(v.implementation()))->data;
      }
      void setdirection(const Php::Value &v) {
          data.direction = ((Vector3 *)(v.implementation()))->data;
      }
  };
  
  class RayHitInfo : public Php::Base {
    public:
      ::RayHitInfo data;
      void __destruct() const {}
      RayHitInfo(::RayHitInfo x) { data = x; }
  };
  
  class BoundingBox : public Php::Base {
    public:
      ::BoundingBox data;
      void __destruct() const {}
      BoundingBox(::BoundingBox x) { data = x; }
      Php::Value getmin() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.min));
          return result;
      }
      Php::Value getmax() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.max));
          return result;
      }
      void setmin(const Php::Value &v) {
          data.min = ((Vector3 *)(v.implementation()))->data;
      }
      void setmax(const Php::Value &v) {
          data.max = ((Vector3 *)(v.implementation()))->data;
      }
  };
  
  class Wave : public Php::Base {
    public:
      ::Wave data;
      void __destruct() const {}
      Wave(::Wave x) { data = x; }
      Php::Value getsampleCount() {
          long result = data.sampleCount;
          return result;
      }
      Php::Value getsampleRate() {
          long result = data.sampleRate;
          return result;
      }
      Php::Value getsampleSize() {
          long result = data.sampleSize;
          return result;
      }
      Php::Value getchannels() {
          long result = data.channels;
          return result;
      }
      void setsampleCount(const Php::Value &v) { data.sampleCount = (long)v; }
      void setsampleRate(const Php::Value &v) { data.sampleRate = (long)v; }
      void setsampleSize(const Php::Value &v) { data.sampleSize = (long)v; }
      void setchannels(const Php::Value &v) { data.channels = (long)v; }
  };
  
  class rAudioBuffer : public Php::Base {
    public:
      void *data; // rAudioBuffer
      rAudioBuffer(void *x) { data = x; }
  };
  
  class AudioStream : public Php::Base {
    public:
      ::AudioStream data;
      void __destruct() const {}
      AudioStream(::AudioStream x) { data = x; }
      Php::Value getsampleRate() {
          long result = data.sampleRate;
          return result;
      }
      Php::Value getsampleSize() {
          long result = data.sampleSize;
          return result;
      }
      Php::Value getchannels() {
          long result = data.channels;
          return result;
      }
      void setsampleRate(const Php::Value &v) { data.sampleRate = (long)v; }
      void setsampleSize(const Php::Value &v) { data.sampleSize = (long)v; }
      void setchannels(const Php::Value &v) { data.channels = (long)v; }
  };
  
  class Sound : public Php::Base {
    public:
      ::Sound data;
      void __destruct() const {}
      Sound(::Sound x) { data = x; }
      Php::Value getsampleCount() {
          long result = data.sampleCount;
          return result;
      }
      Php::Value getstream() {
          Php::Value result =
              Php::Object("RayLib\\AudioStream", new AudioStream(data.stream));
          return result;
      }
      void setsampleCount(const Php::Value &v) { data.sampleCount = (long)v; }
      void setstream(const Php::Value &v) {
          data.stream = ((AudioStream *)(v.implementation()))->data;
      }
  };
  
  class Music : public Php::Base {
    public:
      ::Music data;
      void __destruct() const {}
      Music(::Music x) { data = x; }
      Php::Value getctxType() {
          int result = data.ctxType;
          return result;
      }
      Php::Value getsampleCount() {
          long result = data.sampleCount;
          return result;
      }
      Php::Value getstream() {
          Php::Value result =
              Php::Object("RayLib\\AudioStream", new AudioStream(data.stream));
          return result;
      }
      void setctxType(const Php::Value &v) { data.ctxType = (int)v; }
      void setsampleCount(const Php::Value &v) { data.sampleCount = (long)v; }
      void setstream(const Php::Value &v) {
          data.stream = ((AudioStream *)(v.implementation()))->data;
      }
  };
  
  class VrDeviceInfo : public Php::Base {
    public:
      ::VrDeviceInfo data;
      void __destruct() const {}
      VrDeviceInfo(::VrDeviceInfo x) { data = x; }
      Php::Value gethResolution() {
          int result = data.hResolution;
          return result;
      }
      Php::Value getvResolution() {
          int result = data.vResolution;
          return result;
      }
      Php::Value gethScreenSize() {
          double result = data.hScreenSize;
          return result;
      }
      Php::Value getvScreenSize() {
          double result = data.vScreenSize;
          return result;
      }
      Php::Value getvScreenCenter() {
          double result = data.vScreenCenter;
          return result;
      }
      Php::Value geteyeToScreenDistance() {
          double result = data.eyeToScreenDistance;
          return result;
      }
      Php::Value getlensSeparationDistance() {
          double result = data.lensSeparationDistance;
          return result;
      }
      Php::Value getinterpupillaryDistance() {
          double result = data.interpupillaryDistance;
          return result;
      }
      Php::Value getlensDistortionValues() {
          Php::Value result;
          for (int i = 0; i < 4; i++) {
              result[i] = data.lensDistortionValues[i];
          }
          return result;
      }
      Php::Value getchromaAbCorrection() {
          Php::Value result;
          for (int i = 0; i < 4; i++) {
              result[i] = data.chromaAbCorrection[i];
          }
          return result;
      }
      void sethResolution(const Php::Value &v) { data.hResolution = (int)v; }
      void setvResolution(const Php::Value &v) { data.vResolution = (int)v; }
      void sethScreenSize(const Php::Value &v) { data.hScreenSize = (double)v; }
      void setvScreenSize(const Php::Value &v) { data.vScreenSize = (double)v; }
      void setvScreenCenter(const Php::Value &v) {
          data.vScreenCenter = (double)v;
      }
      void seteyeToScreenDistance(const Php::Value &v) {
          data.eyeToScreenDistance = (double)v;
      }
      void setlensSeparationDistance(const Php::Value &v) {
          data.lensSeparationDistance = (double)v;
      }
      void setinterpupillaryDistance(const Php::Value &v) {
          data.interpupillaryDistance = (double)v;
      }
      void setlensDistortionValues(const Php::Value &v) {
          for (int i = 0; i < 4; i++) {
              data.lensDistortionValues[i] = v[i].floatValue();
          }
      }
      void setchromaAbCorrection(const Php::Value &v) {
          for (int i = 0; i < 4; i++) {
              data.chromaAbCorrection[i] = v[i].floatValue();
          }
      }
  };
  
  class TraceLogCallback : public Php::Base {
    public:
      ::TraceLogCallback data;
      void __destruct() const {}
      TraceLogCallback(::TraceLogCallback x) { data = x; }
  };
  
  class rlPhysicsBody : public Php::Base {
    public:
      ::PhysicsBodyData *data;
      rlPhysicsBody(::PhysicsBodyData *x) { data = x; }
      Php::Value getid() {
          long result = data->id;
          return result;
      }
      Php::Value getenabled() { return data->enabled; }
      Php::Value getposition() {
          Php::Value result =
              Php::Object("RayLib\\Vector2", new Vector2(data->position));
          return result;
      }
      Php::Value getvelocity() {
          Php::Value result =
              Php::Object("RayLib\\Vector2", new Vector2(data->velocity));
          return result;
      }
      Php::Value getforce() {
          Php::Value result =
              Php::Object("RayLib\\Vector2", new Vector2(data->force));
          return result;
      }
      Php::Value getangularVelocity() {
          double result = data->angularVelocity;
          return result;
      }
      Php::Value gettorque() {
          double result = data->torque;
          return result;
      }
      Php::Value getorient() {
          double result = data->orient;
          return result;
      }
      Php::Value getinertia() {
          double result = data->inertia;
          return result;
      }
      Php::Value getinverseInertia() {
          double result = data->inverseInertia;
          return result;
      }
      Php::Value getmass() {
          double result = data->mass;
          return result;
      }
      Php::Value getinverseMass() {
          double result = data->inverseMass;
          return result;
      }
      Php::Value getstaticFriction() {
          double result = data->staticFriction;
          return result;
      }
      Php::Value getdynamicFriction() {
          double result = data->dynamicFriction;
          return result;
      }
      Php::Value getrestitution() {
          double result = data->restitution;
          return result;
      }
      Php::Value getuseGravity() { return data->useGravity; }
      Php::Value getisGrounded() { return data->isGrounded; }
      Php::Value getfreezeOrient() { return data->freezeOrient; }
      // Php::Value getshape() {
      //   Php::Value result =
      //       Php::Object("RayLib\\PhysicsShape", new PhysicsShape(data->shape));
      //   return result;
      // }
      void setid(const Php::Value &v) { data->id = (long)v; }
      void setenabled(const Php::Value &v) { data->enabled = (bool)v; }
      void setposition(const Php::Value &v) {
          data->position = ((Vector2 *)(v.implementation()))->data;
      }
      void setvelocity(const Php::Value &v) {
          data->velocity = ((Vector2 *)(v.implementation()))->data;
      }
      void setforce(const Php::Value &v) {
          data->force = ((Vector2 *)(v.implementation()))->data;
      }
      void setangularVelocity(const Php::Value &v) {
          data->angularVelocity = (double)v;
      }
      void settorque(const Php::Value &v) { data->torque = (double)v; }
      void setorient(const Php::Value &v) { data->orient = (double)v; }
      void setinertia(const Php::Value &v) { data->inertia = (double)v; }
      void setinverseInertia(const Php::Value &v) {
          data->inverseInertia = (double)v;
      }
      void setmass(const Php::Value &v) { data->mass = (double)v; }
      void setinverseMass(const Php::Value &v) { data->inverseMass = (double)v; }
      void setstaticFriction(const Php::Value &v) {
          data->staticFriction = (double)v;
      }
      void setdynamicFriction(const Php::Value &v) {
          data->dynamicFriction = (double)v;
      }
      void setrestitution(const Php::Value &v) { data->restitution = (double)v; }
      void setuseGravity(const Php::Value &v) {}
      void setisGrounded(const Php::Value &v) {}
      void setfreezeOrient(const Php::Value &v) {}
      // void setshape(const Php::Value &v) {
      //   data->shape = ((PhysicsShape *)(v.implementation()))->data;
      // }
  };
  
  class Light : public Php::Base {
    public:
      ::Light data;
      Light(::Light x) { data = x; }
      Php::Value gettype() {
          int result = data.type;
          return result;
      }
      Php::Value getposition() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.position));
          return result;
      }
      Php::Value gettarget() {
          Php::Value result =
              Php::Object("RayLib\\Vector3", new Vector3(data.target));
          return result;
      }
      Php::Value getcolor() {
          Php::Value result = Php::Object("RayLib\\Color", new Color(data.color));
          return result;
      }
      Php::Value getenabled() { return data.enabled; }
      Php::Value getenabledLoc() {
          int result = data.enabledLoc;
          return result;
      }
      Php::Value gettypeLoc() {
          int result = data.typeLoc;
          return result;
      }
      Php::Value getposLoc() {
          int result = data.posLoc;
          return result;
      }
      Php::Value gettargetLoc() {
          int result = data.targetLoc;
          return result;
      }
      Php::Value getcolorLoc() {
          int result = data.colorLoc;
          return result;
      }
      void settype(const Php::Value &v) { data.type = (int)v; }
      void setposition(const Php::Value &v) {
          data.position = ((Vector3 *)(v.implementation()))->data;
      }
      void settarget(const Php::Value &v) {
          data.target = ((Vector3 *)(v.implementation()))->data;
      }
      void setcolor(const Php::Value &v) {
          data.color = ((Color *)(v.implementation()))->data;
      }
      void setenabled(const Php::Value &v) {}
      void setenabledLoc(const Php::Value &v) { data.enabledLoc = (int)v; }
      void settypeLoc(const Php::Value &v) { data.typeLoc = (int)v; }
      void setposLoc(const Php::Value &v) { data.posLoc = (int)v; }
      void settargetLoc(const Php::Value &v) { data.targetLoc = (int)v; }
      void setcolorLoc(const Php::Value &v) { data.colorLoc = (int)v; }
  };
  
  class RL : public Php::Base {
    public:
      RL() {}
      virtual ~RL() {}
      virtual void __construct() {}
      virtual void __destruct() {}
  
      static void InitWindow(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          string p2 = params[2];
          ::InitWindow(p0, p1, p2.c_str());
      }
  
      static Php::Value WindowShouldClose(Php::Parameters &params) {
          int result = ::WindowShouldClose();
          return result;
      }
  
      static void CloseWindow(Php::Parameters &params) { ::CloseWindow(); }
  
      static Php::Value IsWindowReady(Php::Parameters &params) {
          int result = ::IsWindowReady();
          return result;
      }
  
      static Php::Value IsWindowMinimized(Php::Parameters &params) {
          int result = ::IsWindowMinimized();
          return result;
      }
  
      static Php::Value IsWindowResized(Php::Parameters &params) {
          int result = ::IsWindowResized();
          return result;
      }
  
      static Php::Value IsWindowHidden(Php::Parameters &params) {
          int result = ::IsWindowHidden();
          return result;
      }
  
      static Php::Value IsWindowFullscreen(Php::Parameters &params) {
          int result = ::IsWindowFullscreen();
          return result;
      }
  
      static void ToggleFullscreen(Php::Parameters &params) {
          ::ToggleFullscreen();
      }
  
      static void SetWindowIcon(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::SetWindowIcon(p0);
      }
  
      static void SetWindowTitle(Php::Parameters &params) {
          string p0 = params[0];
          ::SetWindowTitle(p0.c_str());
      }
  
      static void SetWindowPosition(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::SetWindowPosition(p0, p1);
      }
  
      static void SetWindowMonitor(Php::Parameters &params) {
          int p0 = params[0];
          ::SetWindowMonitor(p0);
      }
  
      static void SetWindowMinSize(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::SetWindowMinSize(p0, p1);
      }
  
      static void SetWindowSize(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::SetWindowSize(p0, p1);
      }
  
      // GetWindowHandle is not supported
      static Php::Value GetScreenWidth(Php::Parameters &params) {
          int result = ::GetScreenWidth();
          return result;
      }
  
      static Php::Value GetScreenHeight(Php::Parameters &params) {
          int result = ::GetScreenHeight();
          return result;
      }
  
      static Php::Value GetMonitorCount(Php::Parameters &params) {
          int result = ::GetMonitorCount();
          return result;
      }
  
      static Php::Value GetMonitorWidth(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetMonitorWidth(p0);
          return result;
      }
  
      static Php::Value GetMonitorHeight(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetMonitorHeight(p0);
          return result;
      }
  
      static Php::Value GetMonitorPhysicalWidth(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetMonitorPhysicalWidth(p0);
          return result;
      }
  
      static Php::Value GetMonitorPhysicalHeight(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetMonitorPhysicalHeight(p0);
          return result;
      }
  
      static Php::Value GetWindowPosition(Php::Parameters &params) {
          Vector2 result = ::GetWindowPosition();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetMonitorName(Php::Parameters &params) {
          int p0 = params[0];
          string result = ::GetMonitorName(p0);
          return result;
      }
  
      static Php::Value GetClipboardText(Php::Parameters &params) {
          string result = ::GetClipboardText();
          return result;
      }
  
      static void SetClipboardText(Php::Parameters &params) {
          string p0 = params[0];
          ::SetClipboardText(p0.c_str());
      }
  
      static void ShowCursor(Php::Parameters &params) { ::ShowCursor(); }
  
      static void HideCursor(Php::Parameters &params) { ::HideCursor(); }
  
      static Php::Value IsCursorHidden(Php::Parameters &params) {
          int result = ::IsCursorHidden();
          return result;
      }
  
      static void EnableCursor(Php::Parameters &params) { ::EnableCursor(); }
  
      static void DisableCursor(Php::Parameters &params) { ::DisableCursor(); }
  
      static void ClearBackground(Php::Parameters &params) {
          ::Color p0 = ((Color *)(params[0].implementation()))->data;
          ::ClearBackground(p0);
      }
  
      static void BeginDrawing(Php::Parameters &params) { ::BeginDrawing(); }
  
      static void EndDrawing(Php::Parameters &params) { ::EndDrawing(); }
  
      static void BeginMode2D(Php::Parameters &params) {
          ::Camera2D p0 = ((Camera2D *)(params[0].implementation()))->data;
          ::BeginMode2D(p0);
      }
  
      static void EndMode2D(Php::Parameters &params) { ::EndMode2D(); }
  
      static void BeginMode3D(Php::Parameters &params) {
          ::Camera3D p0 = ((Camera3D *)(params[0].implementation()))->data;
          ::BeginMode3D(p0);
      }
  
      static void EndMode3D(Php::Parameters &params) { ::EndMode3D(); }
  
      static void BeginTextureMode(Php::Parameters &params) {
          ::RenderTexture2D p0 =
              ((RenderTexture2D *)(params[0].implementation()))->data;
          ::BeginTextureMode(p0);
      }
  
      static void EndTextureMode(Php::Parameters &params) { ::EndTextureMode(); }
  
      static void BeginScissorMode(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::BeginScissorMode(p0, p1, p2, p3);
      }
  
      static void EndScissorMode(Php::Parameters &params) { ::EndScissorMode(); }
  
      static Php::Value GetMouseRay(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Camera3D p1 = ((Camera3D *)(params[1].implementation()))->data;
          Ray result = ::GetMouseRay(p0, p1);
          return Php::Object("RayLib\\Ray", new Ray(result));
      }
  
      static Php::Value GetCameraMatrix(Php::Parameters &params) {
          ::Camera3D p0 = ((Camera3D *)(params[0].implementation()))->data;
          Matrix result = ::GetCameraMatrix(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value GetCameraMatrix2D(Php::Parameters &params) {
          ::Camera2D p0 = ((Camera2D *)(params[0].implementation()))->data;
          Matrix result = ::GetCameraMatrix2D(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value GetWorldToScreen(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Camera3D p1 = ((Camera3D *)(params[1].implementation()))->data;
          Vector2 result = ::GetWorldToScreen(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetWorldToScreenEx(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Camera3D p1 = ((Camera3D *)(params[1].implementation()))->data;
          int p2 = params[2];
          int p3 = params[3];
          Vector2 result = ::GetWorldToScreenEx(p0, p1, p2, p3);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetWorldToScreen2D(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Camera2D p1 = ((Camera2D *)(params[1].implementation()))->data;
          Vector2 result = ::GetWorldToScreen2D(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetScreenToWorld2D(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Camera2D p1 = ((Camera2D *)(params[1].implementation()))->data;
          Vector2 result = ::GetScreenToWorld2D(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static void SetTargetFPS(Php::Parameters &params) {
          int p0 = params[0];
          ::SetTargetFPS(p0);
      }
  
      static Php::Value GetFPS(Php::Parameters &params) {
          int result = ::GetFPS();
          return result;
      }
  
      static Php::Value GetFrameTime(Php::Parameters &params) {
          double result = ::GetFrameTime();
          return result;
      }
  
      static Php::Value GetTime(Php::Parameters &params) {
          double result = ::GetTime();
          return result;
      }
  
      static Php::Value ColorToInt(Php::Parameters &params) {
          ::Color p0 = ((Color *)(params[0].implementation()))->data;
          int result = ::ColorToInt(p0);
          return result;
      }
  
      static Php::Value ColorNormalize(Php::Parameters &params) {
          ::Color p0 = ((Color *)(params[0].implementation()))->data;
          Vector4 result = ::ColorNormalize(p0);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value ColorFromNormalized(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          Color result = ::ColorFromNormalized(p0);
          return Php::Object("RayLib\\Color", new Color(result));
      }
  
      static Php::Value ColorToHSV(Php::Parameters &params) {
          ::Color p0 = ((Color *)(params[0].implementation()))->data;
          Vector3 result = ::ColorToHSV(p0);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value ColorFromHSV(Php::Parameters &params) {
          float p0 = params[0].floatValue();
          float p1 = params[1].floatValue();
          float p2 = params[2].floatValue();
          Color result = ::ColorFromHSV(p0, p1, p2);
          return Php::Object("RayLib\\Color", new Color(result));
      }
  
      static Php::Value GetColor(Php::Parameters &params) {
          int p0 = params[0];
          Color result = ::GetColor(p0);
          return Php::Object("RayLib\\Color", new Color(result));
      }
  
      static Php::Value Fade(Php::Parameters &params) {
          ::Color p0 = ((Color *)(params[0].implementation()))->data;
          double p1 = params[1];
          Color result = ::Fade(p0, p1);
          return Php::Object("RayLib\\Color", new Color(result));
      }
  
      static void SetConfigFlags(Php::Parameters &params) {
          long p0 = params[0];
          ::SetConfigFlags(p0);
      }
  
      static void SetTraceLogLevel(Php::Parameters &params) {
          int p0 = params[0];
          ::SetTraceLogLevel(p0);
      }
  
      static void SetTraceLogExit(Php::Parameters &params) {
          int p0 = params[0];
          ::SetTraceLogExit(p0);
      }
  
      static void SetTraceLogCallback(Php::Parameters &params) {
          ::TraceLogCallback p0 =
              ((TraceLogCallback *)(params[0].implementation()))->data;
          ::SetTraceLogCallback(p0);
      }
  
      static void TraceLog(Php::Parameters &params) {
          int p0 = params[0];
          string p1 = params[1];
          ::TraceLog(p0, p1.c_str());
      }
  
      static void TakeScreenshot(Php::Parameters &params) {
          string p0 = params[0];
          ::TakeScreenshot(p0.c_str());
      }
  
      static Php::Value GetRandomValue(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int result = ::GetRandomValue(p0, p1);
          return result;
      }
  
      // LoadFileData is not supported
      static void SaveFileData(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          long p2 = params[2];
          ::SaveFileData(p0.c_str(), (void *)p1.c_str(), p2);
      }
  
      static Php::Value LoadFileText(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::LoadFileText(p0.c_str());
          return result;
      }
  
      static void SaveFileText(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          /// ::SaveFileText(p0.c_str(), p1.c_str());
      }
  
      static Php::Value FileExists(Php::Parameters &params) {
          string p0 = params[0];
          int result = ::FileExists(p0.c_str());
          return result;
      }
  
      static Php::Value IsFileExtension(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          int result = ::IsFileExtension(p0.c_str(), p1.c_str());
          return result;
      }
  
      static Php::Value DirectoryExists(Php::Parameters &params) {
          string p0 = params[0];
          int result = ::DirectoryExists(p0.c_str());
          return result;
      }
  
      static Php::Value GetExtension(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::GetExtension(p0.c_str());
          return result;
      }
  
      static Php::Value GetFileName(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::GetFileName(p0.c_str());
          return result;
      }
  
      static Php::Value GetFileNameWithoutExt(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::GetFileNameWithoutExt(p0.c_str());
          return result;
      }
  
      static Php::Value GetDirectoryPath(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::GetDirectoryPath(p0.c_str());
          return result;
      }
  
      static Php::Value GetPrevDirectoryPath(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::GetPrevDirectoryPath(p0.c_str());
          return result;
      }
  
      static Php::Value GetWorkingDirectory(Php::Parameters &params) {
          string result = ::GetWorkingDirectory();
          return result;
      }
  
      // GetDirectoryFiles is not supported
      static void ClearDirectoryFiles(Php::Parameters &params) {
          ::ClearDirectoryFiles();
      }
  
      static Php::Value ChangeDirectory(Php::Parameters &params) {
          string p0 = params[0];
          int result = ::ChangeDirectory(p0.c_str());
          return result;
      }
  
      static Php::Value IsFileDropped(Php::Parameters &params) {
          int result = ::IsFileDropped();
          return result;
      }
  
      static Php::Value GetDroppedFiles(Php::Parameters &params) {
          int p0 = 0;
          auto files = ::GetDroppedFiles(&p0);
          std::vector<string> result;
          for (int i = 0; i < p0; i++) {
              result.push_back(string(files[i]));
          }
          return result;
      }
  
      static void ClearDroppedFiles(Php::Parameters &params) {
          ::ClearDroppedFiles();
      }
  
      static Php::Value GetFileModTime(Php::Parameters &params) {
          string p0 = params[0];
          long result = ::GetFileModTime(p0.c_str());
          return result;
      }
  
      // CompressData is not supported
      // DecompressData is not supported
      static void SaveStorageValue(Php::Parameters &params) {
          long p0 = params[0];
          int p1 = params[1];
          ::SaveStorageValue(p0, p1);
      }
  
      static Php::Value LoadStorageValue(Php::Parameters &params) {
          long p0 = params[0];
          int result = ::LoadStorageValue(p0);
          return result;
      }
  
      static void OpenURL(Php::Parameters &params) {
          string p0 = params[0];
          ::OpenURL(p0.c_str());
      }
  
      static Php::Value IsKeyPressed(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsKeyPressed(p0);
          return result;
      }
  
      static Php::Value IsKeyDown(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsKeyDown(p0);
          return result;
      }
  
      static Php::Value IsKeyReleased(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsKeyReleased(p0);
          return result;
      }
  
      static Php::Value IsKeyUp(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsKeyUp(p0);
          return result;
      }
  
      static void SetExitKey(Php::Parameters &params) {
          int p0 = params[0];
          ::SetExitKey(p0);
      }
  
      static Php::Value GetKeyPressed(Php::Parameters &params) {
          int result = ::GetKeyPressed();
          return result;
      }
  
      static Php::Value IsGamepadAvailable(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsGamepadAvailable(p0);
          return result;
      }
  
      static Php::Value IsGamepadName(Php::Parameters &params) {
          int p0 = params[0];
          string p1 = params[1];
          int result = ::IsGamepadName(p0, p1.c_str());
          return result;
      }
  
      static Php::Value GetGamepadName(Php::Parameters &params) {
          int p0 = params[0];
          string result = ::GetGamepadName(p0);
          return result;
      }
  
      static Php::Value IsGamepadButtonPressed(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int result = ::IsGamepadButtonPressed(p0, p1);
          return result;
      }
  
      static Php::Value IsGamepadButtonDown(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int result = ::IsGamepadButtonDown(p0, p1);
          return result;
      }
  
      static Php::Value IsGamepadButtonReleased(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int result = ::IsGamepadButtonReleased(p0, p1);
          return result;
      }
  
      static Php::Value IsGamepadButtonUp(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int result = ::IsGamepadButtonUp(p0, p1);
          return result;
      }
  
      static Php::Value GetGamepadButtonPressed(Php::Parameters &params) {
          int result = ::GetGamepadButtonPressed();
          return result;
      }
  
      static Php::Value GetGamepadAxisCount(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetGamepadAxisCount(p0);
          return result;
      }
  
      static Php::Value GetGamepadAxisMovement(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double result = ::GetGamepadAxisMovement(p0, p1);
          return result;
      }
  
      static Php::Value IsMouseButtonPressed(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsMouseButtonPressed(p0);
          return result;
      }
  
      static Php::Value IsMouseButtonDown(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsMouseButtonDown(p0);
          return result;
      }
  
      static Php::Value IsMouseButtonReleased(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsMouseButtonReleased(p0);
          return result;
      }
  
      static Php::Value IsMouseButtonUp(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsMouseButtonUp(p0);
          return result;
      }
  
      static Php::Value GetMouseX(Php::Parameters &params) {
          int result = ::GetMouseX();
          return result;
      }
  
      static Php::Value GetMouseY(Php::Parameters &params) {
          int result = ::GetMouseY();
          return result;
      }
  
      static Php::Value GetMousePosition(Php::Parameters &params) {
          Vector2 result = ::GetMousePosition();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static void SetMousePosition(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::SetMousePosition(p0, p1);
      }
  
      static void SetMouseOffset(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::SetMouseOffset(p0, p1);
      }
  
      static void SetMouseScale(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          ::SetMouseScale(p0, p1);
      }
  
      static Php::Value GetMouseWheelMove(Php::Parameters &params) {
          int result = ::GetMouseWheelMove();
          return result;
      }
  
      static Php::Value GetTouchX(Php::Parameters &params) {
          int result = ::GetTouchX();
          return result;
      }
  
      static Php::Value GetTouchY(Php::Parameters &params) {
          int result = ::GetTouchY();
          return result;
      }
  
      static Php::Value GetTouchPosition(Php::Parameters &params) {
          int p0 = params[0];
          Vector2 result = ::GetTouchPosition(p0);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static void SetGesturesEnabled(Php::Parameters &params) {
          long p0 = params[0];
          ::SetGesturesEnabled(p0);
      }
  
      static Php::Value IsGestureDetected(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::IsGestureDetected(p0);
          return result;
      }
  
      static Php::Value GetGestureDetected(Php::Parameters &params) {
          int result = ::GetGestureDetected();
          return result;
      }
  
      static Php::Value GetTouchPointsCount(Php::Parameters &params) {
          int result = ::GetTouchPointsCount();
          return result;
      }
  
      static Php::Value GetGestureHoldDuration(Php::Parameters &params) {
          double result = ::GetGestureHoldDuration();
          return result;
      }
  
      static Php::Value GetGestureDragVector(Php::Parameters &params) {
          Vector2 result = ::GetGestureDragVector();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetGestureDragAngle(Php::Parameters &params) {
          double result = ::GetGestureDragAngle();
          return result;
      }
  
      static Php::Value GetGesturePinchVector(Php::Parameters &params) {
          Vector2 result = ::GetGesturePinchVector();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetGesturePinchAngle(Php::Parameters &params) {
          double result = ::GetGesturePinchAngle();
          return result;
      }
  
      static void SetCameraMode(Php::Parameters &params) {
          ::Camera3D p0 = ((Camera3D *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::SetCameraMode(p0, p1);
      }
  
      static void UpdateCamera(Php::Parameters &params) {
          ::Camera3D *p0 = &((Camera3D *)(params[0].implementation()))->data;
          ::UpdateCamera(p0);
      }
  
      static void SetCameraPanControl(Php::Parameters &params) {
          int p0 = params[0];
          ::SetCameraPanControl(p0);
      }
  
      static void SetCameraAltControl(Php::Parameters &params) {
          int p0 = params[0];
          ::SetCameraAltControl(p0);
      }
  
      static void SetCameraSmoothZoomControl(Php::Parameters &params) {
          int p0 = params[0];
          ::SetCameraSmoothZoomControl(p0);
      }
  
      static void SetCameraMoveControls(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          int p5 = params[5];
          ::SetCameraMoveControls(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawPixel(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawPixel(p0, p1, p2);
      }
  
      static void DrawPixelV(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::DrawPixelV(p0, p1);
      }
  
      static void DrawLine(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawLine(p0, p1, p2, p3, p4);
      }
  
      static void DrawLineV(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawLineV(p0, p1, p2);
      }
  
      static void DrawLineEx(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawLineEx(p0, p1, p2, p3);
      }
  
      static void DrawLineBezier(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawLineBezier(p0, p1, p2, p3);
      }
  
      static void DrawLineStrip(Php::Parameters &params) {
          auto p0 = params[0].vectorValue<Php::Value>();
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          std::vector<::Vector2> arr;
          for (int i = 0; i < p1; i++) {
              arr.push_back(((Vector2 *)p0[i].implementation())->data);
          }
          ::DrawLineStrip(arr.data(), p1, p2);
      }
  
      static void DrawCircle(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawCircle(p0, p1, p2, p3);
      }
  
      static void DrawCircleSector(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawCircleSector(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawCircleSectorLines(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawCircleSectorLines(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawCircleGradient(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawCircleGradient(p0, p1, p2, p3, p4);
      }
  
      static void DrawCircleV(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawCircleV(p0, p1, p2);
      }
  
      static void DrawCircleLines(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawCircleLines(p0, p1, p2, p3);
      }
  
      static void DrawEllipse(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawEllipse(p0, p1, p2, p3, p4);
      }
  
      static void DrawEllipseLines(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawEllipseLines(p0, p1, p2, p3, p4);
      }
  
      static void DrawRing(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          int p5 = params[5];
          ::Color p6 = ((Color *)(params[6].implementation()))->data;
          ::DrawRing(p0, p1, p2, p3, p4, p5, p6);
      }
  
      static void DrawRingLines(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          int p5 = params[5];
          ::Color p6 = ((Color *)(params[6].implementation()))->data;
          ::DrawRingLines(p0, p1, p2, p3, p4, p5, p6);
      }
  
      static void DrawRectangle(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawRectangle(p0, p1, p2, p3, p4);
      }
  
      static void DrawRectangleV(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawRectangleV(p0, p1, p2);
      }
  
      static void DrawRectangleRec(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::DrawRectangleRec(p0, p1);
      }
  
      static void DrawRectanglePro(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawRectanglePro(p0, p1, p2, p3);
      }
  
      static void DrawRectangleGradientV(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawRectangleGradientV(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawRectangleGradientH(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawRectangleGradientH(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawRectangleGradientEx(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawRectangleGradientEx(p0, p1, p2, p3, p4);
      }
  
      static void DrawRectangleLines(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawRectangleLines(p0, p1, p2, p3, p4);
      }
  
      static void DrawRectangleLinesEx(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawRectangleLinesEx(p0, p1, p2);
      }
  
      static void DrawRectangleRounded(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawRectangleRounded(p0, p1, p2, p3);
      }
  
      static void DrawRectangleRoundedLines(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawRectangleRoundedLines(p0, p1, p2, p3, p4);
      }
  
      static void DrawTriangle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawTriangle(p0, p1, p2, p3);
      }
  
      static void DrawTriangleLines(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawTriangleLines(p0, p1, p2, p3);
      }
  
      static void DrawTriangleFan(Php::Parameters &params) {
          auto p0 = params[0].vectorValue<Php::Value>();
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          std::vector<::Vector2> arr;
          for (int i = 0; i < p1; i++) {
              arr.push_back(((Vector2 *)p0[i].implementation())->data);
          }
          ::DrawTriangleFan(arr.data(), p1, p2);
      }
  
      static void DrawTriangleStrip(Php::Parameters &params) {
          auto p0 = params[0].vectorValue<Php::Value>();
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          std::vector<::Vector2> arr;
          for (int i = 0; i < p1; i++) {
              arr.push_back(((Vector2 *)p0[i].implementation())->data);
          }
          ::DrawTriangleStrip(arr.data(), p1, p2);
      }
  
      static void DrawPoly(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          int p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawPoly(p0, p1, p2, p3, p4);
      }
  
      static void DrawPolyLines(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          int p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawPolyLines(p0, p1, p2, p3, p4);
      }
  
      static Php::Value CheckCollisionRecs(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          int result = ::CheckCollisionRecs(p0, p1);
          return result;
      }
  
      static Php::Value CheckCollisionCircles(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          double p3 = params[3];
          int result = ::CheckCollisionCircles(p0, p1, p2, p3);
          return result;
      }
  
      static Php::Value CheckCollisionCircleRec(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          int result = ::CheckCollisionCircleRec(p0, p1, p2);
          return result;
      }
  
      static Php::Value GetCollisionRec(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          Rectangle result = ::GetCollisionRec(p0, p1);
          return Php::Object("RayLib\\Rectangle", new Rectangle(result));
      }
  
      static Php::Value CheckCollisionPointRec(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          int result = ::CheckCollisionPointRec(p0, p1);
          return result;
      }
  
      static Php::Value CheckCollisionPointCircle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          int result = ::CheckCollisionPointCircle(p0, p1, p2);
          return result;
      }
  
      static Php::Value CheckCollisionPointTriangle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Vector2 p3 = ((Vector2 *)(params[3].implementation()))->data;
          int result = ::CheckCollisionPointTriangle(p0, p1, p2, p3);
          return result;
      }
  
      static Php::Value LoadImage(Php::Parameters &params) {
          string p0 = params[0];
          Image result = ::LoadImage(p0.c_str());
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value LoadImageRaw(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          Image result = ::LoadImageRaw(p0.c_str(), p1, p2, p3, p4);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static void UnloadImage(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::UnloadImage(p0);
      }
  
      static void ExportImage(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::ExportImage(p0, p1.c_str());
      }
  
      static void ExportImageAsCode(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::ExportImageAsCode(p0, p1.c_str());
      }
  
      static Php::Value GetImageData(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::Color *result = ::GetImageData(p0);
          return Php::Object(
              "RayLib\\StructArray_Color",
              new StructArray<::Color, Color>("RayLib\\Color", result));
      }
  
      static Php::Value GenImageColor(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          Image result = ::GenImageColor(p0, p1, p2);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageGradientV(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          Image result = ::GenImageGradientV(p0, p1, p2, p3);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageGradientH(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          Image result = ::GenImageGradientH(p0, p1, p2, p3);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageGradientRadial(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          Image result = ::GenImageGradientRadial(p0, p1, p2, p3, p4);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageChecked(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          Image result = ::GenImageChecked(p0, p1, p2, p3, p4, p5);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageWhiteNoise(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          double p2 = params[2];
          Image result = ::GenImageWhiteNoise(p0, p1, p2);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImagePerlinNoise(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          double p4 = params[4];
          Image result = ::GenImagePerlinNoise(p0, p1, p2, p3, p4);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GenImageCellular(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          Image result = ::GenImageCellular(p0, p1, p2);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value ImageCopy(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          Image result = ::ImageCopy(p0);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value ImageFromImage(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          Image result = ::ImageFromImage(p0, p1);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value ImageText(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          Image result = ::ImageText(p0.c_str(), p1, p2);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value ImageTextEx(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          string p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          Image result = ::ImageTextEx(p0, p1.c_str(), p2, p3, p4);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static void ImageToPOT(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::ImageToPOT(p0, p1);
      }
  
      static void ImageFormat(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::ImageFormat(p0, p1);
      }
  
      static void ImageAlphaMask(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Image p1 = ((Image *)(params[1].implementation()))->data;
          ::ImageAlphaMask(p0, p1);
      }
  
      static void ImageAlphaClear(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::ImageAlphaClear(p0, p1, p2);
      }
  
      static void ImageAlphaCrop(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::ImageAlphaCrop(p0, p1);
      }
  
      static void ImageAlphaPremultiply(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageAlphaPremultiply(p0);
      }
  
      static void ImageCrop(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          ::ImageCrop(p0, p1);
      }
  
      static void ImageResize(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::ImageResize(p0, p1, p2);
      }
  
      static void ImageResizeNN(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::ImageResizeNN(p0, p1, p2);
      }
  
      static void ImageResizeCanvas(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::ImageResizeCanvas(p0, p1, p2, p3, p4, p5);
      }
  
      static void ImageMipmaps(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageMipmaps(p0);
      }
  
      static void ImageDither(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::ImageDither(p0, p1, p2, p3, p4);
      }
  
      static void ImageFlipVertical(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageFlipVertical(p0);
      }
  
      static void ImageFlipHorizontal(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageFlipHorizontal(p0);
      }
  
      static void ImageRotateCW(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageRotateCW(p0);
      }
  
      static void ImageRotateCCW(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageRotateCCW(p0);
      }
  
      static void ImageColorTint(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::ImageColorTint(p0, p1);
      }
  
      static void ImageColorInvert(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageColorInvert(p0);
      }
  
      static void ImageColorGrayscale(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::ImageColorGrayscale(p0);
      }
  
      static void ImageColorContrast(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::ImageColorContrast(p0, p1);
      }
  
      static void ImageColorBrightness(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::ImageColorBrightness(p0, p1);
      }
  
      static void ImageColorReplace(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::ImageColorReplace(p0, p1, p2);
      }
  
      static Php::Value GetImageAlphaBorder(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          double p1 = params[1];
          Rectangle result = ::GetImageAlphaBorder(p0, p1);
          return Php::Object("RayLib\\Rectangle", new Rectangle(result));
      }
  
      static void ImageClearBackground(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::ImageClearBackground(p0, p1);
      }
  
      static void ImageDrawPixel(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::ImageDrawPixel(p0, p1, p2, p3);
      }
  
      static void ImageDrawPixelV(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::ImageDrawPixelV(p0, p1, p2);
      }
  
      static void ImageDrawLine(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::ImageDrawLine(p0, p1, p2, p3, p4, p5);
      }
  
      static void ImageDrawLineV(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::ImageDrawLineV(p0, p1, p2, p3);
      }
  
      static void ImageDrawCircle(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::ImageDrawCircle(p0, p1, p2, p3, p4);
      }
  
      static void ImageDrawCircleV(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          int p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::ImageDrawCircleV(p0, p1, p2, p3);
      }
  
      static void ImageDrawRectangle(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::ImageDrawRectangle(p0, p1, p2, p3, p4, p5);
      }
  
      static void ImageDrawRectangleV(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::ImageDrawRectangleV(p0, p1, p2, p3);
      }
  
      static void ImageDrawRectangleRec(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::ImageDrawRectangleRec(p0, p1, p2);
      }
  
      static void ImageDrawRectangleLines(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          int p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::ImageDrawRectangleLines(p0, p1, p2, p3);
      }
  
      static void ImageDraw(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Image p1 = ((Image *)(params[1].implementation()))->data;
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          ::Rectangle p3 = ((Rectangle *)(params[3].implementation()))->data;
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::ImageDraw(p0, p1, p2, p3, p4);
      }
  
      static void ImageDrawText(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          string p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[3];
          ::Color p5 = ((Color *)(params[4].implementation()))->data;
          ::ImageDrawText(p0, p1.c_str(), p2, p3, p4, p5);
      }
  
      static void ImageDrawTextEx(Php::Parameters &params) {
          ::Image *p0 = &((Image *)(params[0].implementation()))->data;
          ::Font p1 = ((Font *)(params[1].implementation()))->data;
          string p2 = params[2];
          ::Vector2 p3 = ((Vector2 *)(params[2].implementation()))->data;
          double p4 = params[4];
          double p5 = params[5];
          ::Color p6 = ((Color *)(params[6].implementation()))->data;
          ::ImageDrawTextEx(p0, p1, p2.c_str(), p3, p4, p5, p6);
      }
  
      static Php::Value LoadTexture(Php::Parameters &params) {
          string p0 = params[0];
          Texture2D result = ::LoadTexture(p0.c_str());
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value LoadTextureFromImage(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          Texture2D result = ::LoadTextureFromImage(p0);
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value LoadTextureCubemap(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          int p1 = params[1];
          TextureCubemap result = ::LoadTextureCubemap(p0, p1);
          return Php::Object("RayLib\\TextureCubemap",
                             new TextureCubemap(result));
      }
  
      static Php::Value LoadRenderTexture(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          RenderTexture2D result = ::LoadRenderTexture(p0, p1);
          return Php::Object("RayLib\\RenderTexture2D",
                             new RenderTexture2D(result));
      }
  
      static void UnloadTexture(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::UnloadTexture(p0);
      }
  
      static void UnloadRenderTexture(Php::Parameters &params) {
          ::RenderTexture2D p0 =
              ((RenderTexture2D *)(params[0].implementation()))->data;
          ::UnloadRenderTexture(p0);
      }
  
      static void UpdateTexture(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          if (params[1].isString()) {
              return ::UpdateTexture(p0, params[1].stringValue().data());
          }
          if (params[1].instanceOf("RayLib\\ScalarArray_float")) {
              return ::UpdateTexture(
                  p0, ((ScalarArray<float> *)params[1].implementation())->data);
          }
          if (params[1].instanceOf("RayLib\\StructArray_Vector4")) {
              return ::UpdateTexture(
                  p0,
                  ((StructArray<::Vector4, Vector4> *)params[1].implementation())
                      ->data);
          }
          if (params[1].instanceOf("RayLib\\StructArray_Color")) {
              return ::UpdateTexture(
                  p0, ((StructArray<::Color, Color> *)params[1].implementation())
                          ->data);
          }
      }
  
      static Php::Value GetTextureData(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          Image result = ::GetTextureData(p0);
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static Php::Value GetScreenData(Php::Parameters &params) {
          Image result = ::GetScreenData();
          return Php::Object("RayLib\\Image", new Image(result));
      }
  
      static void GenTextureMipmaps(Php::Parameters &params) {
          ::Texture2D *p0 = &((Texture2D *)(params[0].implementation()))->data;
          ::GenTextureMipmaps(p0);
      }
  
      static void SetTextureFilter(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::SetTextureFilter(p0, p1);
      }
  
      static void SetTextureWrap(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::SetTextureWrap(p0, p1);
      }
  
      static void DrawTexture(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawTexture(p0, p1, p2, p3);
      }
  
      static void DrawTextureV(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawTextureV(p0, p1, p2);
      }
  
      static void DrawTextureEx(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawTextureEx(p0, p1, p2, p3, p4);
      }
  
      static void DrawTextureRec(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawTextureRec(p0, p1, p2, p3);
      }
  
      static void DrawTextureQuad(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          ::Rectangle p3 = ((Rectangle *)(params[3].implementation()))->data;
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawTextureQuad(p0, p1, p2, p3, p4);
      }
  
      static void DrawTexturePro(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          ::Vector2 p3 = ((Vector2 *)(params[3].implementation()))->data;
          double p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawTexturePro(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawTextureNPatch(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::NPatchInfo p1 = ((NPatchInfo *)(params[1].implementation()))->data;
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          ::Vector2 p3 = ((Vector2 *)(params[3].implementation()))->data;
          double p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawTextureNPatch(p0, p1, p2, p3, p4, p5);
      }
  
      static Php::Value GetPixelDataSize(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int result = ::GetPixelDataSize(p0, p1, p2);
          return result;
      }
  
      static Php::Value GetFontDefault(Php::Parameters &params) {
          Font result = ::GetFontDefault();
          return Php::Object("RayLib\\Font", new Font(result));
      }
  
      static Php::Value LoadFont(Php::Parameters &params) {
          string p0 = params[0];
          Font result = ::LoadFont(p0.c_str());
          return Php::Object("RayLib\\Font", new Font(result));
      }
  
      static Php::Value LoadFontEx(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          int p2 = 0;
          int p3 = params[3];
          Font result = ::LoadFontEx(p0.c_str(), p1, &p2, p3);
          params[2] = p2;
          return Php::Object("RayLib\\Font", new Font(result));
      }
  
      static Php::Value LoadFontFromImage(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          int p2 = params[2];
          Font result = ::LoadFontFromImage(p0, p1, p2);
          return Php::Object("RayLib\\Font", new Font(result));
      }
  
      // LoadFontData is not supported
      // static Php::Value GenImageFontAtlas(Php::Parameters &params) {
      //   ::const struct CharInfo *p0 =
      //       &((const struct CharInfo *)(params[0].implementation()))->data;
      //   int p2 = params[2];
      //   int p3 = params[3];
      //   int p4 = params[4];
      //   int p5 = params[5];
      //   Image result = ::GenImageFontAtlas(p0, p1, p2, p3, p4, p5);
      //   return Php::Object("RayLib\\Image", new Image(result));
      // }
  
      static void UnloadFont(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          ::UnloadFont(p0);
      }
  
      static void DrawFPS(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          ::DrawFPS(p0, p1);
      }
  
      static void DrawText(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawText(p0.c_str(), p1, p2, p3, p4);
      }
  
      static void DrawTextEx(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          double p3 = params[3];
          double p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawTextEx(p0, p1.c_str(), p2, p3, p4, p5);
      }
  
      static void DrawTextRec(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          double p3 = params[3];
          double p4 = params[4];
          int p5 = params[5];
          ::Color p6 = ((Color *)(params[6].implementation()))->data;
          ::DrawTextRec(p0, p1.c_str(), p2, p3, p4, p5, p6);
      }
  
      static void DrawTextRecEx(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          double p3 = params[3];
          double p4 = params[4];
          int p5 = params[5];
          ::Color p6 = ((Color *)(params[6].implementation()))->data;
          int p7 = params[7];
          int p8 = params[8];
          ::Color p9 = ((Color *)(params[9].implementation()))->data;
          ::Color p10 = ((Color *)(params[10].implementation()))->data;
          ::DrawTextRecEx(p0, p1.c_str(), p2, p3, p4, p5, p6, p7, p8, p9, p10);
      }
  
      static void DrawTextCodepoint(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Vector2 p2 = ((Vector2 *)(params[2].implementation()))->data;
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawTextCodepoint(p0, p1, p2, p3, p4);
      }
  
      static Php::Value MeasureText(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          int result = ::MeasureText(p0.c_str(), p1);
          return result;
      }
  
      static Php::Value MeasureTextEx(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          string p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          Vector2 result = ::MeasureTextEx(p0, p1.c_str(), p2, p3);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value GetGlyphIndex(Php::Parameters &params) {
          ::Font p0 = ((Font *)(params[0].implementation()))->data;
          int p1 = params[1];
          int result = ::GetGlyphIndex(p0, p1);
          return result;
      }
  
      // static Php::Value TextCopy(Php::Parameters &params) {
      //   string p0 = params[0];
      //   string p1 = params[1];
      //   int result = ::TextCopy(p0.c_str(), p1.c_str());
      //   return result;
      // }
  
      // static Php::Value TextIsEqual(Php::Parameters &params) {
      //   string p0 = params[0];
      //   string p1 = params[1];
      //   int result = ::TextIsEqual(p0.c_str(), p1.c_str());
      //   return result;
      // }
  
      static Php::Value TextLength(Php::Parameters &params) {
          string p0 = params[0];
          long result = ::TextLength(p0.c_str());
          return result;
      }
  
      static Php::Value TextFormat(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::TextFormat(p0.c_str());
          return result;
      }
  
      static Php::Value TextSubtext(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          string result = ::TextSubtext(p0.c_str(), p1, p2);
          return result;
      }
  
      // static Php::Value TextReplace(Php::Parameters &params) {
      //   string p0 = params[0];
      //   string p1 = params[1];
      //   string p2 = params[2];
      //   string result = ::TextReplace(p0.c_str(), p1.c_str(), p2.c_str());
      // }
  
      static Php::Value TextInsert(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          int p2 = params[2];
          string result = ::TextInsert(p0.c_str(), p1.c_str(), p2);
          return result;
      }
  
      // static Php::Value TextJoin(Php::Parameters &params) {
      //   int p1 = params[1];
      //   string p2 = params[2];
      //   string result = ::TextJoin(p0, p1, p2.c_str());
      // }
  
      // TextSplit is not supported
      // static void TextAppend(Php::Parameters &params) {
      //   string p0 = params[0];
      //   string p1 = params[1];
      //   // Pointer to scalar as argument is not supported
      //   ::TextAppend(p0.c_str(), p1.c_str(), p2);
      // }
  
      static Php::Value TextFindIndex(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          int result = ::TextFindIndex(p0.c_str(), p1.c_str());
          return result;
      }
  
      static Php::Value TextToUpper(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::TextToUpper(p0.c_str());
          return result;
      }
  
      static Php::Value TextToLower(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::TextToLower(p0.c_str());
          return result;
      }
  
      static Php::Value TextToPascal(Php::Parameters &params) {
          string p0 = params[0];
          string result = ::TextToPascal(p0.c_str());
          return result;
      }
  
      static Php::Value TextToInteger(Php::Parameters &params) {
          string p0 = params[0];
          int result = ::TextToInteger(p0.c_str());
          return result;
      }
  
      // static Php::Value TextToUtf8(Php::Parameters &params) {
      //   // Pointer to scalar as argument is not supported
      //   int p1 = params[1];
      //   string result = ::TextToUtf8(p0, p1);
      // }
  
      // GetCodepoints is not supported
      static Php::Value GetCodepointsCount(Php::Parameters &params) {
          string p0 = params[0];
          int result = ::GetCodepointsCount(p0.c_str());
          return result;
      }
  
      // static Php::Value GetNextCodepoint(Php::Parameters &params) {
      //   string p0 = params[0];
      //   // Pointer to scalar as argument is not supported
      //   int result = ::GetNextCodepoint(p0.c_str(), p1);
      //   return result;
      // }
  
      // static Php::Value CodepointToUtf8(Php::Parameters &params) {
      //   int p0 = params[0];
      //   // Pointer to scalar as argument is not supported
      //   string result = ::CodepointToUtf8(p0, p1);
      // }
  
      static void DrawLine3D(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawLine3D(p0, p1, p2);
      }
  
      static void DrawPoint3D(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::DrawPoint3D(p0, p1);
      }
  
      static void DrawCircle3D(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawCircle3D(p0, p1, p2, p3, p4);
      }
  
      static void DrawCube(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawCube(p0, p1, p2, p3, p4);
      }
  
      static void DrawCubeV(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawCubeV(p0, p1, p2);
      }
  
      static void DrawCubeWires(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawCubeWires(p0, p1, p2, p3, p4);
      }
  
      static void DrawCubeWiresV(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawCubeWiresV(p0, p1, p2);
      }
  
      static void DrawCubeTexture(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          double p3 = params[3];
          double p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawCubeTexture(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawSphere(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawSphere(p0, p1, p2);
      }
  
      static void DrawSphereEx(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawSphereEx(p0, p1, p2, p3, p4);
      }
  
      static void DrawSphereWires(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawSphereWires(p0, p1, p2, p3, p4);
      }
  
      static void DrawCylinder(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawCylinder(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawCylinderWires(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          int p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawCylinderWires(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawPlane(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          ::Color p2 = ((Color *)(params[2].implementation()))->data;
          ::DrawPlane(p0, p1, p2);
      }
  
      static void DrawRay(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::DrawRay(p0, p1);
      }
  
      static void DrawGrid(Php::Parameters &params) {
          int p0 = params[0];
          double p1 = params[1];
          ::DrawGrid(p0, p1);
      }
  
      static void DrawGizmo(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::DrawGizmo(p0);
      }
  
      static Php::Value LoadModel(Php::Parameters &params) {
          string p0 = params[0];
          Model result = ::LoadModel(p0.c_str());
          return Php::Object("RayLib\\Model", new Model(result));
      }
  
      static Php::Value LoadModelFromMesh(Php::Parameters &params) {
          ::Mesh p0 = ((Mesh *)(params[0].implementation()))->data;
          Model result = ::LoadModelFromMesh(p0);
          return Php::Object("RayLib\\Model", new Model(result));
      }
  
      static void UnloadModel(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::UnloadModel(p0);
      }
  
      static Php::Value LoadMeshes(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = params[1];
          ::Mesh *result = ::LoadMeshes(p0.c_str(), &p1);
          return Php::Object("RayLib\\StructArray", new StructArray<::Mesh, Mesh>(
                                                        "RayLib\\Mesh", result));
      }
  
      static void ExportMesh(Php::Parameters &params) {
          ::Mesh p0 = ((Mesh *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::ExportMesh(p0, p1.c_str());
      }
  
      static void UnloadMesh(Php::Parameters &params) {
          ::Mesh p0 = ((Mesh *)(params[0].implementation()))->data;
          ::UnloadMesh(p0);
      }
  
      static Php::Value LoadMaterials(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = 0;
          ::Material *result = ::LoadMaterials(p0.c_str(), &p1);
          return Php::Object("RayLib\\StructArray",
                             new StructArray<::Material, Material>(
                                 "RayLib\\Material", result, p1));
      }
  
      static Php::Value LoadMaterialDefault(Php::Parameters &params) {
          Material result = ::LoadMaterialDefault();
          return Php::Object("RayLib\\Material", new Material(result));
      }
  
      static void UnloadMaterial(Php::Parameters &params) {
          ::Material p0 = ((Material *)(params[0].implementation()))->data;
          ::UnloadMaterial(p0);
      }
  
      static void SetMaterialTexture(Php::Parameters &params) {
          ::Material *p0 = &((Material *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Texture2D p2 = ((Texture2D *)(params[2].implementation()))->data;
          ::SetMaterialTexture(p0, p1, p2);
      }
  
      static void SetModelMeshMaterial(Php::Parameters &params) {
          ::Model *p0 = &((Model *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::SetModelMeshMaterial(p0, p1, p2);
      }
  
      static Php::Value LoadModelAnimations(Php::Parameters &params) {
          string p0 = params[0];
          int p1 = 0;
          ::ModelAnimation *result = ::LoadModelAnimations(p0.c_str(), &p1);
          return Php::Object("RayLib\\StructArray",
                             new StructArray<::ModelAnimation, ModelAnimation>(
                                 "RayLib\\ModelAnimation", result, p1));
      }
  
      static void UpdateModelAnimation(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::ModelAnimation p1 =
              ((ModelAnimation *)(params[1].implementation()))->data;
          int p2 = params[2];
          ::UpdateModelAnimation(p0, p1, p2);
      }
  
      static void UnloadModelAnimation(Php::Parameters &params) {
          ::ModelAnimation p0 =
              ((ModelAnimation *)(params[0].implementation()))->data;
          ::UnloadModelAnimation(p0);
      }
  
      static Php::Value IsModelAnimationValid(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::ModelAnimation p1 =
              ((ModelAnimation *)(params[1].implementation()))->data;
          int result = ::IsModelAnimationValid(p0, p1);
          return result;
      }
  
      static Php::Value GenMeshPoly(Php::Parameters &params) {
          int p0 = params[0];
          double p1 = params[1];
          Mesh result = ::GenMeshPoly(p0, p1);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshPlane(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          Mesh result = ::GenMeshPlane(p0, p1, p2, p3);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshCube(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          Mesh result = ::GenMeshCube(p0, p1, p2);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshSphere(Php::Parameters &params) {
          double p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          Mesh result = ::GenMeshSphere(p0, p1, p2);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshHemiSphere(Php::Parameters &params) {
          double p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          Mesh result = ::GenMeshHemiSphere(p0, p1, p2);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshCylinder(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          int p2 = params[2];
          Mesh result = ::GenMeshCylinder(p0, p1, p2);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshTorus(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          Mesh result = ::GenMeshTorus(p0, p1, p2, p3);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshKnot(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          Mesh result = ::GenMeshKnot(p0, p1, p2, p3);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshHeightmap(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Mesh result = ::GenMeshHeightmap(p0, p1);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value GenMeshCubicmap(Php::Parameters &params) {
          ::Image p0 = ((Image *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Mesh result = ::GenMeshCubicmap(p0, p1);
          return Php::Object("RayLib\\Mesh", new Mesh(result));
      }
  
      static Php::Value MeshBoundingBox(Php::Parameters &params) {
          ::Mesh p0 = ((Mesh *)(params[0].implementation()))->data;
          BoundingBox result = ::MeshBoundingBox(p0);
          return Php::Object("RayLib\\BoundingBox", new BoundingBox(result));
      }
  
      static void MeshTangents(Php::Parameters &params) {
          ::Mesh *p0 = &((Mesh *)(params[0].implementation()))->data;
          ::MeshTangents(p0);
      }
  
      static void MeshBinormals(Php::Parameters &params) {
          ::Mesh *p0 = &((Mesh *)(params[0].implementation()))->data;
          ::MeshBinormals(p0);
      }
  
      static void DrawModel(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawModel(p0, p1, p2, p3);
      }
  
      static void DrawModelEx(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          ::Vector3 p4 = ((Vector3 *)(params[4].implementation()))->data;
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawModelEx(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawModelWires(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::DrawModelWires(p0, p1, p2, p3);
      }
  
      static void DrawModelWiresEx(Php::Parameters &params) {
          ::Model p0 = ((Model *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          ::Vector3 p4 = ((Vector3 *)(params[4].implementation()))->data;
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawModelWiresEx(p0, p1, p2, p3, p4, p5);
      }
  
      static void DrawBoundingBox(Php::Parameters &params) {
          ::BoundingBox p0 = ((BoundingBox *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          ::DrawBoundingBox(p0, p1);
      }
  
      static void DrawBillboard(Php::Parameters &params) {
          ::Camera3D p0 = ((Camera3D *)(params[0].implementation()))->data;
          ::Texture2D p1 = ((Texture2D *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          ::Color p4 = ((Color *)(params[4].implementation()))->data;
          ::DrawBillboard(p0, p1, p2, p3, p4);
      }
  
      static void DrawBillboardRec(Php::Parameters &params) {
          ::Camera3D p0 = ((Camera3D *)(params[0].implementation()))->data;
          ::Texture2D p1 = ((Texture2D *)(params[1].implementation()))->data;
          ::Rectangle p2 = ((Rectangle *)(params[2].implementation()))->data;
          ::Vector3 p3 = ((Vector3 *)(params[3].implementation()))->data;
          double p4 = params[4];
          ::Color p5 = ((Color *)(params[5].implementation()))->data;
          ::DrawBillboardRec(p0, p1, p2, p3, p4, p5);
      }
  
      static Php::Value CheckCollisionSpheres(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          int result = ::CheckCollisionSpheres(p0, p1, p2, p3);
          return result;
      }
  
      static Php::Value CheckCollisionBoxes(Php::Parameters &params) {
          ::BoundingBox p0 = ((BoundingBox *)(params[0].implementation()))->data;
          ::BoundingBox p1 = ((BoundingBox *)(params[1].implementation()))->data;
          int result = ::CheckCollisionBoxes(p0, p1);
          return result;
      }
  
      static Php::Value CheckCollisionBoxSphere(Php::Parameters &params) {
          ::BoundingBox p0 = ((BoundingBox *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          int result = ::CheckCollisionBoxSphere(p0, p1, p2);
          return result;
      }
  
      static Php::Value CheckCollisionRaySphere(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          int result = ::CheckCollisionRaySphere(p0, p1, p2);
          return result;
      }
  
      static Php::Value CheckCollisionRaySphereEx(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          ::Vector3 *p3 = &((Vector3 *)(params[3].implementation()))->data;
          int result = ::CheckCollisionRaySphereEx(p0, p1, p2, p3);
          return result;
      }
  
      static Php::Value CheckCollisionRayBox(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::BoundingBox p1 = ((BoundingBox *)(params[1].implementation()))->data;
          int result = ::CheckCollisionRayBox(p0, p1);
          return result;
      }
  
      static Php::Value GetCollisionRayModel(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::Model p1 = ((Model *)(params[1].implementation()))->data;
          RayHitInfo result = ::GetCollisionRayModel(p0, p1);
          return Php::Object("RayLib\\RayHitInfo", new RayHitInfo(result));
      }
  
      static Php::Value GetCollisionRayTriangle(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          ::Vector3 p3 = ((Vector3 *)(params[3].implementation()))->data;
          RayHitInfo result = ::GetCollisionRayTriangle(p0, p1, p2, p3);
          return Php::Object("RayLib\\RayHitInfo", new RayHitInfo(result));
      }
  
      static Php::Value GetCollisionRayGround(Php::Parameters &params) {
          ::Ray p0 = ((Ray *)(params[0].implementation()))->data;
          double p1 = params[1];
          RayHitInfo result = ::GetCollisionRayGround(p0, p1);
          return Php::Object("RayLib\\RayHitInfo", new RayHitInfo(result));
      }
  
      static Php::Value LoadShader(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          Shader result = ::LoadShader(params[0].isNull() ? 0 : p0.c_str(),
                                       params[1].isNull() ? 0 : p1.c_str());
          return Php::Object("RayLib\\Shader", new Shader(result));
      }
  
      static Php::Value LoadShaderCode(Php::Parameters &params) {
          string p0 = params[0];
          string p1 = params[1];
          Shader result = ::LoadShaderCode(params[0].isNull() ? 0 : p0.c_str(),
                                           params[1].isNull() ? 0 : p1.c_str());
          return Php::Object("RayLib\\Shader", new Shader(result));
      }
  
      static void UnloadShader(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::UnloadShader(p0);
      }
  
      static Php::Value GetShaderDefault(Php::Parameters &params) {
          Shader result = ::GetShaderDefault();
          return Php::Object("RayLib\\Shader", new Shader(result));
      }
  
      static Php::Value GetTextureDefault(Php::Parameters &params) {
          Texture2D result = ::GetTextureDefault();
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value GetShapesTexture(Php::Parameters &params) {
          Texture2D result = ::GetShapesTexture();
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value GetShapesTextureRec(Php::Parameters &params) {
          Rectangle result = ::GetShapesTextureRec();
          return Php::Object("RayLib\\Rectangle", new Rectangle(result));
      }
  
      static void SetShapesTexture(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Rectangle p1 = ((Rectangle *)(params[1].implementation()))->data;
          ::SetShapesTexture(p0, p1);
      }
  
      static Php::Value GetShaderLocation(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          string p1 = params[1];
          int result = ::GetShaderLocation(p0, p1.c_str());
          return result;
      }
  
      static void SetShaderValue(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          int p1 = params[1];
          string p2 = params[2];
          int p3 = params[3];
          ::SetShaderValue(p0, p1, p2.c_str(), p3);
      }
  
      static void SetShaderValueV(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          int p1 = params[1];
          string p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          ::SetShaderValueV(p0, p1, p2.data(), p3, p4);
      }
  
      static void SetShaderValueMatrix(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Matrix p2 = ((Matrix *)(params[2].implementation()))->data;
          ::SetShaderValueMatrix(p0, p1, p2);
      }
  
      static void SetShaderValueTexture(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Texture2D p2 = ((Texture2D *)(params[2].implementation()))->data;
          ::SetShaderValueTexture(p0, p1, p2);
      }
  
      static void SetMatrixProjection(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          ::SetMatrixProjection(p0);
      }
  
      static void SetMatrixModelview(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          ::SetMatrixModelview(p0);
      }
  
      static Php::Value GetMatrixModelview(Php::Parameters &params) {
          Matrix result = ::GetMatrixModelview();
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value GetMatrixProjection(Php::Parameters &params) {
          Matrix result = ::GetMatrixProjection();
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value GenTextureCubemap(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::Texture2D p1 = ((Texture2D *)(params[1].implementation()))->data;
          int p2 = params[2];
          int p3 = params[2];
          Texture2D result = ::GenTextureCubemap(p0, p1, p2, p3);
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value GenTextureIrradiance(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::Texture2D p1 = ((Texture2D *)(params[1].implementation()))->data;
          int p2 = params[2];
          Texture2D result = ::GenTextureIrradiance(p0, p1, p2);
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value GenTexturePrefilter(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::Texture2D p1 = ((Texture2D *)(params[1].implementation()))->data;
          int p2 = params[2];
          Texture2D result = ::GenTexturePrefilter(p0, p1, p2);
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static Php::Value GenTextureBRDF(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          int p1 = params[1];
          Texture2D result = ::GenTextureBRDF(p0, p1);
          return Php::Object("RayLib\\Texture2D", new Texture2D(result));
      }
  
      static void BeginShaderMode(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::BeginShaderMode(p0);
      }
  
      static void EndShaderMode(Php::Parameters &params) { ::EndShaderMode(); }
  
      static void BeginBlendMode(Php::Parameters &params) {
          int p0 = params[0];
          ::BeginBlendMode(p0);
      }
  
      static void EndBlendMode(Php::Parameters &params) { ::EndBlendMode(); }
  
      static void InitVrSimulator(Php::Parameters &params) {
          ::InitVrSimulator();
      }
  
      static void CloseVrSimulator(Php::Parameters &params) {
          ::CloseVrSimulator();
      }
  
      static void UpdateVrTracking(Php::Parameters &params) {
          ::Camera3D *p0 = &((Camera3D *)(params[0].implementation()))->data;
          ::UpdateVrTracking(p0);
      }
  
      static void SetVrConfiguration(Php::Parameters &params) {
          ::VrDeviceInfo p0 =
              ((VrDeviceInfo *)(params[0].implementation()))->data;
          ::Shader p1 = ((Shader *)(params[1].implementation()))->data;
          ::SetVrConfiguration(p0, p1);
      }
  
      static Php::Value IsVrSimulatorReady(Php::Parameters &params) {
          int result = ::IsVrSimulatorReady();
          return result;
      }
  
      static void ToggleVrMode(Php::Parameters &params) { ::ToggleVrMode(); }
  
      static void BeginVrDrawing(Php::Parameters &params) { ::BeginVrDrawing(); }
  
      static void EndVrDrawing(Php::Parameters &params) { ::EndVrDrawing(); }
  
      static void InitAudioDevice(Php::Parameters &params) {
          ::InitAudioDevice();
      }
  
      static void CloseAudioDevice(Php::Parameters &params) {
          ::CloseAudioDevice();
      }
  
      static Php::Value IsAudioDeviceReady(Php::Parameters &params) {
          int result = ::IsAudioDeviceReady();
          return result;
      }
  
      static void SetMasterVolume(Php::Parameters &params) {
          double p0 = params[0];
          ::SetMasterVolume(p0);
      }
  
      static Php::Value LoadWave(Php::Parameters &params) {
          string p0 = params[0];
          Wave result = ::LoadWave(p0.c_str());
          return Php::Object("RayLib\\Wave", new Wave(result));
      }
  
      static Php::Value LoadSound(Php::Parameters &params) {
          string p0 = params[0];
          Sound result = ::LoadSound(p0.c_str());
          return Php::Object("RayLib\\Sound", new Sound(result));
      }
  
      static Php::Value LoadSoundFromWave(Php::Parameters &params) {
          ::Wave p0 = ((Wave *)(params[0].implementation()))->data;
          Sound result = ::LoadSoundFromWave(p0);
          return Php::Object("RayLib\\Sound", new Sound(result));
      }
  
      static void UpdateSound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          string p1 = params[1];
          int p2 = params[2];
          ::UpdateSound(p0, p1.data(), p2);
      }
  
      static void UnloadWave(Php::Parameters &params) {
          ::Wave p0 = ((Wave *)(params[0].implementation()))->data;
          ::UnloadWave(p0);
      }
  
      static void UnloadSound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::UnloadSound(p0);
      }
  
      static void ExportWave(Php::Parameters &params) {
          ::Wave p0 = ((Wave *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::ExportWave(p0, p1.c_str());
      }
  
      static void ExportWaveAsCode(Php::Parameters &params) {
          ::Wave p0 = ((Wave *)(params[0].implementation()))->data;
          string p1 = params[1];
          ::ExportWaveAsCode(p0, p1.c_str());
      }
  
      static void PlaySound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::PlaySound(p0);
      }
  
      static void StopSound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::StopSound(p0);
      }
  
      static void PauseSound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::PauseSound(p0);
      }
  
      static void ResumeSound(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::ResumeSound(p0);
      }
  
      static void PlaySoundMulti(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          ::PlaySoundMulti(p0);
      }
  
      static void StopSoundMulti(Php::Parameters &params) { ::StopSoundMulti(); }
  
      static Php::Value GetSoundsPlaying(Php::Parameters &params) {
          int result = ::GetSoundsPlaying();
          return result;
      }
  
      static Php::Value IsSoundPlaying(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          int result = ::IsSoundPlaying(p0);
          return result;
      }
  
      static void SetSoundVolume(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetSoundVolume(p0, p1);
      }
  
      static void SetSoundPitch(Php::Parameters &params) {
          ::Sound p0 = ((Sound *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetSoundPitch(p0, p1);
      }
  
      static void WaveFormat(Php::Parameters &params) {
          ::Wave *p0 = &((Wave *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::WaveFormat(p0, p1, p2, p3);
      }
  
      static Php::Value WaveCopy(Php::Parameters &params) {
          ::Wave p0 = ((Wave *)(params[0].implementation()))->data;
          Wave result = ::WaveCopy(p0);
          return Php::Object("RayLib\\Wave", new Wave(result));
      }
  
      static void WaveCrop(Php::Parameters &params) {
          ::Wave *p0 = &((Wave *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          ::WaveCrop(p0, p1, p2);
      }
  
      static Php::Value LoadMusicStream(Php::Parameters &params) {
          string p0 = params[0];
          Music result = ::LoadMusicStream(p0.c_str());
          return Php::Object("RayLib\\Music", new Music(result));
      }
  
      static void UnloadMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::UnloadMusicStream(p0);
      }
  
      static void PlayMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::PlayMusicStream(p0);
      }
  
      static void UpdateMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::UpdateMusicStream(p0);
      }
  
      static void StopMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::StopMusicStream(p0);
      }
  
      static void PauseMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::PauseMusicStream(p0);
      }
  
      static void ResumeMusicStream(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          ::ResumeMusicStream(p0);
      }
  
      static Php::Value IsMusicPlaying(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          int result = ::IsMusicPlaying(p0);
          return result;
      }
  
      static void SetMusicVolume(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetMusicVolume(p0, p1);
      }
  
      static void SetMusicPitch(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetMusicPitch(p0, p1);
      }
  
      static Php::Value GetMusicTimeLength(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          double result = ::GetMusicTimeLength(p0);
          return result;
      }
  
      static Php::Value GetMusicTimePlayed(Php::Parameters &params) {
          ::Music p0 = ((Music *)(params[0].implementation()))->data;
          double result = ::GetMusicTimePlayed(p0);
          return result;
      }
  
      static Php::Value InitAudioStream(Php::Parameters &params) {
          long p0 = params[0];
          long p1 = params[1];
          long p2 = params[2];
          AudioStream result = ::InitAudioStream(p0, p1, p2);
          return Php::Object("RayLib\\AudioStream", new AudioStream(result));
      }
  
      static void UpdateAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          int p2 = params[2];
          string p1 = params[1];
          ::UpdateAudioStream(p0, p1.c_str(), p2);
      }
  
      static void CloseAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          ::CloseAudioStream(p0);
      }
  
      static Php::Value IsAudioStreamProcessed(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          int result = ::IsAudioStreamProcessed(p0);
          return result;
      }
  
      static void PlayAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          ::PlayAudioStream(p0);
      }
  
      static void PauseAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          ::PauseAudioStream(p0);
      }
  
      static void ResumeAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          ::ResumeAudioStream(p0);
      }
  
      static Php::Value IsAudioStreamPlaying(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          int result = ::IsAudioStreamPlaying(p0);
          return result;
      }
  
      static void StopAudioStream(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          ::StopAudioStream(p0);
      }
  
      static void SetAudioStreamVolume(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetAudioStreamVolume(p0, p1);
      }
  
      static void SetAudioStreamPitch(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetAudioStreamPitch(p0, p1);
      }
  
      static void SetAudioStreamBufferSizeDefault(Php::Parameters &params) {
          int p0 = params[0];
          ::SetAudioStreamBufferSizeDefault(p0);
      }
  
      static Php::Value createVector2(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          return Php::Object("RayLib\\Vector2",
                             new Vector2(::Vector2{(float)p0, (float)p1}));
      }
  
      static Php::Value createVector3(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          return Php::Object(
              "RayLib\\Vector3",
              new Vector3(::Vector3{(float)p0, (float)p1, (float)p2}));
      }
  
      static Php::Value createVector4(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          return Php::Object(
              "RayLib\\Vector4",
              new Vector4(::Vector4{(float)p0, (float)p1, (float)p2, (float)p3}));
      }
  
      static Php::Value createMatrix(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          double p4 = params[4];
          double p5 = params[5];
          double p6 = params[6];
          double p7 = params[7];
          double p8 = params[8];
          double p9 = params[9];
          double p10 = params[10];
          double p11 = params[11];
          double p12 = params[12];
          double p13 = params[13];
          double p14 = params[14];
          double p15 = params[15];
          return Php::Object(
              "RayLib\\Matrix",
              new Matrix(::Matrix{(float)p0, (float)p1, (float)p2, (float)p3,
                                  (float)p4, (float)p5, (float)p6, (float)p7,
                                  (float)p8, (float)p9, (float)p10, (float)p11,
                                  (float)p12, (float)p13, (float)p14,
                                  (float)p15}));
      }
  
      static Php::Value createColor(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          return Php::Object(
              "RayLib\\Color",
              new Color(::Color{(unsigned char)p0, (unsigned char)p1,
                                (unsigned char)p2, (unsigned char)p3}));
      }
  
      static Php::Value createRectangle(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          return Php::Object("RayLib\\Rectangle",
                             new Rectangle(::Rectangle{(float)p0, (float)p1,
                                                       (float)p2, (float)p3}));
      }
  
      static Php::Value createTexture2D(Php::Parameters &params) {
          long p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          return Php::Object(
              "RayLib\\Texture2D",
              new Texture2D(::Texture2D{(unsigned int)p0, p1, p2, p3, p4}));
      }
  
      static Php::Value createRenderTexture2D(Php::Parameters &params) {
          return Php::Object("RayLib\\RenderTexture2D",
                             new RenderTexture2D(::RenderTexture2D{}));
      }
  
      static Php::Value createNPatchInfo(Php::Parameters &params) {
          ::Rectangle p0 = ((Rectangle *)(params[0].implementation()))->data;
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          int p4 = params[4];
          int p5 = params[5];
          return Php::Object("RayLib\\NPatchInfo", new NPatchInfo(::NPatchInfo{
                                                       p0, p1, p2, p3, p4, p5}));
      }
  
      static Php::Value createCharInfo(Php::Parameters &params) {
          int p0 = params[0];
          int p1 = params[1];
          int p2 = params[2];
          int p3 = params[3];
          ::Image p4 = ((Image *)(params[4].implementation()))->data;
          return Php::Object("RayLib\\CharInfo",
                             new CharInfo(::CharInfo{p0, p1, p2, p3, p4}));
      }
  
      static Php::Value createCamera3D(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          double p3 = params[3];
          int p4 = params[4];
          return Php::Object("RayLib\\Camera3D",
                             new Camera3D(::Camera3D{p0, p1, p2, (float)p3, p4}));
      }
  
      static Php::Value createCamera2D(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          double p3 = params[3];
          return Php::Object(
              "RayLib\\Camera2D",
              new Camera2D(::Camera2D{p0, p1, (float)p2, (float)p3}));
      }
  
      static Php::Value createMaterialMap(Php::Parameters &params) {
          ::Texture2D p0 = ((Texture2D *)(params[0].implementation()))->data;
          ::Color p1 = ((Color *)(params[1].implementation()))->data;
          double p2 = params[2];
          return Php::Object("RayLib\\MaterialMap",
                             new MaterialMap(::MaterialMap{p0, p1, (float)p2}));
      }
  
      static Php::Value createTransform(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          return Php::Object("RayLib\\Transform",
                             new Transform(::Transform{p0, p1, p2}));
      }
  
      static Php::Value createRay(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          return Php::Object("RayLib\\Ray", new Ray(::Ray{p0, p1}));
      }
  
      static Php::Value createRayHitInfo(Php::Parameters &params) {
          return Php::Object("RayLib\\RayHitInfo",
                             new RayHitInfo(::RayHitInfo{}));
      }
  
      static Php::Value createBoundingBox(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          return Php::Object("RayLib\\BoundingBox",
                             new BoundingBox(::BoundingBox{p0, p1}));
      }
  
      static Php::Value createSound(Php::Parameters &params) {
          ::AudioStream p0 = ((AudioStream *)(params[0].implementation()))->data;
          long p1 = params[1];
          return Php::Object("RayLib\\Sound",
                             new Sound(::Sound{p0, (unsigned int)p1}));
      }
  
      static Php::Value getColorLIGHTGRAY() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{200, 200, 200, 255}));
      }
  
      static Php::Value getColorGRAY() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{130, 130, 130, 255}));
      }
  
      static Php::Value getColorDARKGRAY() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{80, 80, 80, 255}));
      }
  
      static Php::Value getColorYELLOW() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{253, 249, 0, 255}));
      }
  
      static Php::Value getColorGOLD() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{255, 203, 0, 255}));
      }
  
      static Php::Value getColorORANGE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{255, 161, 0, 255}));
      }
  
      static Php::Value getColorPINK() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{255, 109, 194, 255}));
      }
  
      static Php::Value getColorRED() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{230, 41, 55, 255}));
      }
  
      static Php::Value getColorMAROON() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{190, 33, 55, 255}));
      }
  
      static Php::Value getColorGREEN() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{0, 228, 48, 255}));
      }
  
      static Php::Value getColorLIME() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{0, 158, 47, 255}));
      }
  
      static Php::Value getColorDARKGREEN() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{0, 117, 44, 255}));
      }
  
      static Php::Value getColorSKYBLUE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{102, 191, 255, 255}));
      }
  
      static Php::Value getColorBLUE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{0, 121, 241, 255}));
      }
  
      static Php::Value getColorDARKBLUE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{0, 82, 172, 255}));
      }
  
      static Php::Value getColorPURPLE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{200, 122, 255, 255}));
      }
  
      static Php::Value getColorVIOLET() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{135, 60, 190, 255}));
      }
  
      static Php::Value getColorDARKPURPLE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{112, 31, 126, 255}));
      }
  
      static Php::Value getColorBEIGE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{211, 176, 131, 255}));
      }
  
      static Php::Value getColorBROWN() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{127, 106, 79, 255}));
      }
  
      static Php::Value getColorDARKBROWN() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{76, 63, 47, 255}));
      }
  
      static Php::Value getColorWHITE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{255, 255, 255, 255}));
      }
  
      static Php::Value getColorBLACK() {
          return Php::Object("RayLib\\Color", new Color(::Color{0, 0, 0, 255}));
      }
  
      static Php::Value getColorBLANK() {
          return Php::Object("RayLib\\Color", new Color(::Color{0, 0, 0, 0}));
      }
  
      static Php::Value getColorMAGENTA() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{255, 0, 255, 255}));
      }
  
      static Php::Value getColorRAYWHITE() {
          return Php::Object("RayLib\\Color",
                             new Color(::Color{245, 245, 245, 255}));
      }
  
      static Php::Value Clamp(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double result = ::Clamp(p0, p1, p2);
          return result;
      }
  
      static Php::Value Lerp(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double result = ::Lerp(p0, p1, p2);
          return result;
      }
  
      static Php::Value Vector2Zero(Php::Parameters &params) {
          Vector2 result = ::Vector2Zero();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2One(Php::Parameters &params) {
          Vector2 result = ::Vector2One();
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Add(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          Vector2 result = ::Vector2Add(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Subtract(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          Vector2 result = ::Vector2Subtract(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Length(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double result = ::Vector2Length(p0);
          return result;
      }
  
      static Php::Value Vector2DotProduct(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double result = ::Vector2DotProduct(p0, p1);
          return result;
      }
  
      static Php::Value Vector2Distance(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double result = ::Vector2Distance(p0, p1);
          return result;
      }
  
      static Php::Value Vector2Angle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double result = ::Vector2Angle(p0, p1);
          return result;
      }
  
      static Php::Value Vector2Scale(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          Vector2 result = ::Vector2Scale(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Negate(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          Vector2 result = ::Vector2Negate(p0);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Divide(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[0].implementation()))->data;
          Vector2 result = ::Vector2Divide(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Normalize(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          Vector2 result = ::Vector2Normalize(p0);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Lerp(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[1].implementation()))->data;
          double p2 = params[2];
          Vector2 result = ::Vector2Lerp(p0, p1, p2);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector2Rotate(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          Vector2 result = ::Vector2Rotate(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static Php::Value Vector3Zero(Php::Parameters &params) {
          Vector3 result = ::Vector3Zero();
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3One(Php::Parameters &params) {
          Vector3 result = ::Vector3One();
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Add(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Add(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Subtract(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Subtract(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Scale(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          Vector3 result = ::Vector3Scale(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Multiply(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Multiply(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3CrossProduct(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3CrossProduct(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Perpendicular(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          Vector3 result = ::Vector3Perpendicular(p0);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Length(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double result = ::Vector3Length(p0);
          return result;
      }
  
      static Php::Value Vector3DotProduct(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double result = ::Vector3DotProduct(p0, p1);
          return result;
      }
  
      static Php::Value Vector3Distance(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double result = ::Vector3Distance(p0, p1);
          return result;
      }
  
      static Php::Value Vector3Negate(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          Vector3 result = ::Vector3Negate(p0);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Divide(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[0].implementation()))->data;
          Vector3 result = ::Vector3Divide(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Normalize(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          Vector3 result = ::Vector3Normalize(p0);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static void Vector3OrthoNormalize(Php::Parameters &params) {
          ::Vector3 *p0 = &((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 *p1 = &((Vector3 *)(params[1].implementation()))->data;
          ::Vector3OrthoNormalize(p0, p1);
      }
  
      static Php::Value Vector3Transform(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Matrix p1 = ((Matrix *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Transform(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3RotateByQuaternion(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3RotateByQuaternion(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Lerp(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          double p2 = params[2];
          Vector3 result = ::Vector3Lerp(p0, p1, p2);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Reflect(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Reflect(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Min(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Min(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Max(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector3 result = ::Vector3Max(p0, p1);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3Barycenter(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          ::Vector3 p3 = ((Vector3 *)(params[3].implementation()))->data;
          Vector3 result = ::Vector3Barycenter(p0, p1, p2, p3);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value Vector3ToFloatV(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          float3 result = ::Vector3ToFloatV(p0);
          return Php::Object("RayLib\\float3", new float3(result));
      }
  
      static Php::Value MatrixDeterminant(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          double result = ::MatrixDeterminant(p0);
          return result;
      }
  
      static Php::Value MatrixTrace(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          double result = ::MatrixTrace(p0);
          return result;
      }
  
      static Php::Value MatrixTranspose(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          Matrix result = ::MatrixTranspose(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixInvert(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          Matrix result = ::MatrixInvert(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixNormalize(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          Matrix result = ::MatrixNormalize(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixIdentity(Php::Parameters &params) {
          Matrix result = ::MatrixIdentity();
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixAdd(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          ::Matrix p1 = ((Matrix *)(params[1].implementation()))->data;
          Matrix result = ::MatrixAdd(p0, p1);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixSubtract(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          ::Matrix p1 = ((Matrix *)(params[1].implementation()))->data;
          Matrix result = ::MatrixSubtract(p0, p1);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixTranslate(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          Matrix result = ::MatrixTranslate(p0, p1, p2);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixRotate(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          Matrix result = ::MatrixRotate(p0, p1);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixRotateXYZ(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          Matrix result = ::MatrixRotateXYZ(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixRotateX(Php::Parameters &params) {
          double p0 = params[0];
          Matrix result = ::MatrixRotateX(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixRotateY(Php::Parameters &params) {
          double p0 = params[0];
          Matrix result = ::MatrixRotateY(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixRotateZ(Php::Parameters &params) {
          double p0 = params[0];
          Matrix result = ::MatrixRotateZ(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixScale(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          Matrix result = ::MatrixScale(p0, p1, p2);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixMultiply(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          ::Matrix p1 = ((Matrix *)(params[1].implementation()))->data;
          Matrix result = ::MatrixMultiply(p0, p1);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixFrustum(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          double p4 = params[4];
          double p5 = params[5];
          Matrix result = ::MatrixFrustum(p0, p1, p2, p3, p4, p5);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixPerspective(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          Matrix result = ::MatrixPerspective(p0, p1, p2, p3);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixOrtho(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          double p4 = params[4];
          double p5 = params[5];
          Matrix result = ::MatrixOrtho(p0, p1, p2, p3, p4, p5);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixLookAt(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          Matrix result = ::MatrixLookAt(p0, p1, p2);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value MatrixToFloatV(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          float16 result = ::MatrixToFloatV(p0);
          return Php::Object("RayLib\\float16", new float16(result));
      }
  
      static Php::Value QuaternionIdentity(Php::Parameters &params) {
          Vector4 result = ::QuaternionIdentity();
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionLength(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          double result = ::QuaternionLength(p0);
          return result;
      }
  
      static Php::Value QuaternionNormalize(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          Vector4 result = ::QuaternionNormalize(p0);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionInvert(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          Vector4 result = ::QuaternionInvert(p0);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionMultiply(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          Vector4 result = ::QuaternionMultiply(p0, p1);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionLerp(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          double p2 = params[2];
          Vector4 result = ::QuaternionLerp(p0, p1, p2);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionNlerp(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          double p2 = params[2];
          Vector4 result = ::QuaternionNlerp(p0, p1, p2);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionSlerp(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          ::Vector4 p1 = ((Vector4 *)(params[1].implementation()))->data;
          double p2 = params[2];
          Vector4 result = ::QuaternionSlerp(p0, p1, p2);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionFromVector3ToVector3(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          Vector4 result = ::QuaternionFromVector3ToVector3(p0, p1);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionFromMatrix(Php::Parameters &params) {
          ::Matrix p0 = ((Matrix *)(params[0].implementation()))->data;
          Vector4 result = ::QuaternionFromMatrix(p0);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionToMatrix(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          Matrix result = ::QuaternionToMatrix(p0);
          return Php::Object("RayLib\\Matrix", new Matrix(result));
      }
  
      static Php::Value QuaternionFromAxisAngle(Php::Parameters &params) {
          ::Vector3 p0 = ((Vector3 *)(params[0].implementation()))->data;
          double p1 = params[1];
          Vector4 result = ::QuaternionFromAxisAngle(p0, p1);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static void QuaternionToAxisAngle(Php::Parameters &params) {
          // ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          // ::Vector3 *p1 = &((Vector3 *)(params[1].implementation()))->data;
          // Pointer to scalar as argument is not supported
          // ::QuaternionToAxisAngle(p0, p1, p2);
      }
  
      static Php::Value QuaternionFromEuler(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          double p2 = params[2];
          Vector4 result = ::QuaternionFromEuler(p0, p1, p2);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static Php::Value QuaternionToEuler(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          Vector3 result = ::QuaternionToEuler(p0);
          return Php::Object("RayLib\\Vector3", new Vector3(result));
      }
  
      static Php::Value QuaternionTransform(Php::Parameters &params) {
          ::Vector4 p0 = ((Vector4 *)(params[0].implementation()))->data;
          ::Matrix p1 = ((Matrix *)(params[1].implementation()))->data;
          Vector4 result = ::QuaternionTransform(p0, p1);
          return Php::Object("RayLib\\Vector4", new Vector4(result));
      }
  
      static void InitPhysics(Php::Parameters &params) { ::InitPhysics(); }
  
      static void RunPhysicsStep(Php::Parameters &params) { ::RunPhysicsStep(); }
  
      static void SetPhysicsTimeStep(Php::Parameters &params) {
          double p0 = params[0];
          ::SetPhysicsTimeStep(p0);
      }
  
      static Php::Value IsPhysicsEnabled(Php::Parameters &params) {
          bool result = ::IsPhysicsEnabled();
          return result;
      }
  
      static void SetPhysicsGravity(Php::Parameters &params) {
          double p0 = params[0];
          double p1 = params[1];
          ::SetPhysicsGravity(p0, p1);
      }
  
      static Php::Value CreatePhysicsBodyCircle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          PhysicsBody result = ::CreatePhysicsBodyCircle(p0, p1, p2);
          return Php::Object("RayLib\\PhysicsBody", new rlPhysicsBody(result));
      }
  
      static Php::Value CreatePhysicsBodyRectangle(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          double p2 = params[2];
          double p3 = params[3];
          PhysicsBody result = ::CreatePhysicsBodyRectangle(p0, p1, p2, p3);
          return Php::Object("RayLib\\PhysicsBody", new rlPhysicsBody(result));
      }
  
      static Php::Value CreatePhysicsBodyPolygon(Php::Parameters &params) {
          ::Vector2 p0 = ((Vector2 *)(params[0].implementation()))->data;
          double p1 = params[1];
          int p2 = params[2];
          double p3 = params[3];
          PhysicsBody result = ::CreatePhysicsBodyPolygon(p0, p1, p2, p3);
          return Php::Object("RayLib\\PhysicsBody", new rlPhysicsBody(result));
      }
  
      static void PhysicsAddForce(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[0].implementation()))->data;
          ::PhysicsAddForce(p0, p1);
      }
  
      static void PhysicsAddTorque(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::PhysicsAddTorque(p0, p1);
      }
  
      static void PhysicsShatter(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          ::Vector2 p1 = ((Vector2 *)(params[0].implementation()))->data;
          double p2 = params[2];
          ::PhysicsShatter(p0, p1, p2);
      }
  
      static Php::Value GetPhysicsBodiesCount(Php::Parameters &params) {
          int result = ::GetPhysicsBodiesCount();
          return result;
      }
  
      static Php::Value GetPhysicsBody(Php::Parameters &params) {
          int p0 = params[0];
          PhysicsBody result = ::GetPhysicsBody(p0);
          if (result) {
              return Php::Object("RayLib\\PhysicsBody",
                                 new rlPhysicsBody(result));
          } else {
              return nullptr;
          }
      }
  
      static Php::Value GetPhysicsShapeType(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetPhysicsShapeType(p0);
          return result;
      }
  
      static Php::Value GetPhysicsShapeVerticesCount(Php::Parameters &params) {
          int p0 = params[0];
          int result = ::GetPhysicsShapeVerticesCount(p0);
          return result;
      }
  
      static Php::Value GetPhysicsShapeVertex(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          int p1 = params[1];
          ::Vector2 result = ::GetPhysicsShapeVertex(p0, p1);
          return Php::Object("RayLib\\Vector2", new Vector2(result));
      }
  
      static void SetPhysicsBodyRotation(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          double p1 = params[1];
          ::SetPhysicsBodyRotation(p0, p1);
      }
  
      static void DestroyPhysicsBody(Php::Parameters &params) {
          ::PhysicsBody p0 =
              ((rlPhysicsBody *)(params[0].implementation()))->data;
          ::DestroyPhysicsBody(p0);
      }
  
      static void ResetPhysics(Php::Parameters &params) { ::ResetPhysics(); }
  
      static void ClosePhysics(Php::Parameters &params) { ::ClosePhysics(); }
  
      static Php::Value CreateLight(Php::Parameters &params) {
          int p0 = params[0];
          ::Vector3 p1 = ((Vector3 *)(params[1].implementation()))->data;
          ::Vector3 p2 = ((Vector3 *)(params[2].implementation()))->data;
          ::Color p3 = ((Color *)(params[3].implementation()))->data;
          ::Shader p4 = ((Shader *)(params[4].implementation()))->data;
          Light result = ::CreateLight(p0, p1, p2, p3, p4);
          return Php::Object("RayLib\\Light", new Light(result));
      }
  
      static void UpdateLightValues(Php::Parameters &params) {
          ::Shader p0 = ((Shader *)(params[0].implementation()))->data;
          ::Light p1 = ((Light *)(params[1].implementation()))->data;
          ::UpdateLightValues(p0, p1);
      }
  };
  
  // symbols are exported according to the "C" language
  extern "C" {
  // export the "get_module" function that will be called by the Zend engine
  PHPCPP_EXPORT void *get_module() {
      // create extension
      static Php::Extension extension("raylib", "1.0");
  
      Php::Namespace rlNamespace("RayLib");
  
      Php::Class<RL> rlClass("RL");
  
      Php::Class<ScalarArray<float>> scalarArrayFloat("ScalarArray_float");
      rlNamespace.add(scalarArrayFloat);
  
      Php::Class<StructArray<::Color, Color>> structArrayColor(
          "StructArray_Color");
      rlNamespace.add(structArrayColor);
  
      Php::Class<StructArray<::Vector4, Vector4>> structArrayVector4(
          "StructArray_Vector4");
      rlNamespace.add(structArrayVector4);
  
      Php::Class<Vector2> rlVector2("Vector2");
      rlNamespace.add(rlVector2);
      rlVector2.property("x", &Vector2::getx, &Vector2::setx);
      rlVector2.property("y", &Vector2::gety, &Vector2::sety);
  
      Php::Class<Vector3> rlVector3("Vector3");
      rlNamespace.add(rlVector3);
      rlVector3.property("x", &Vector3::getx, &Vector3::setx);
      rlVector3.property("y", &Vector3::gety, &Vector3::sety);
      rlVector3.property("z", &Vector3::getz, &Vector3::setz);
  
      Php::Class<Vector4> rlVector4("Vector4");
      rlNamespace.add(rlVector4);
      rlVector4.property("x", &Vector4::getx, &Vector4::setx);
      rlVector4.property("y", &Vector4::gety, &Vector4::sety);
      rlVector4.property("z", &Vector4::getz, &Vector4::setz);
      rlVector4.property("w", &Vector4::getw, &Vector4::setw);
  
      Php::Class<Matrix> rlMatrix("Matrix");
      rlNamespace.add(rlMatrix);
      rlMatrix.property("m0", &Matrix::getm0, &Matrix::setm0);
      rlMatrix.property("m4", &Matrix::getm4, &Matrix::setm4);
      rlMatrix.property("m8", &Matrix::getm8, &Matrix::setm8);
      rlMatrix.property("m12", &Matrix::getm12, &Matrix::setm12);
      rlMatrix.property("m1", &Matrix::getm1, &Matrix::setm1);
      rlMatrix.property("m5", &Matrix::getm5, &Matrix::setm5);
      rlMatrix.property("m9", &Matrix::getm9, &Matrix::setm9);
      rlMatrix.property("m13", &Matrix::getm13, &Matrix::setm13);
      rlMatrix.property("m2", &Matrix::getm2, &Matrix::setm2);
      rlMatrix.property("m6", &Matrix::getm6, &Matrix::setm6);
      rlMatrix.property("m10", &Matrix::getm10, &Matrix::setm10);
      rlMatrix.property("m14", &Matrix::getm14, &Matrix::setm14);
      rlMatrix.property("m3", &Matrix::getm3, &Matrix::setm3);
      rlMatrix.property("m7", &Matrix::getm7, &Matrix::setm7);
      rlMatrix.property("m11", &Matrix::getm11, &Matrix::setm11);
      rlMatrix.property("m15", &Matrix::getm15, &Matrix::setm15);
  
      Php::Class<Color> rlColor("Color");
      rlNamespace.add(rlColor);
      rlColor.property("r", &Color::getr, &Color::setr);
      rlColor.property("g", &Color::getg, &Color::setg);
      rlColor.property("b", &Color::getb, &Color::setb);
      rlColor.property("a", &Color::geta, &Color::seta);
  
      Php::Class<Rectangle> rlRectangle("Rectangle");
      rlNamespace.add(rlRectangle);
      rlRectangle.property("x", &Rectangle::getx, &Rectangle::setx);
      rlRectangle.property("y", &Rectangle::gety, &Rectangle::sety);
      rlRectangle.property("width", &Rectangle::getwidth, &Rectangle::setwidth);
      rlRectangle.property("height", &Rectangle::getheight,
                           &Rectangle::setheight);
  
      Php::Class<Image> rlImage("Image");
      rlNamespace.add(rlImage);
      rlImage.property("data", &Image::getdata, &Image::setdata);
      rlImage.property("width", &Image::getwidth, &Image::setwidth);
      rlImage.property("height", &Image::getheight, &Image::setheight);
      rlImage.property("mipmaps", &Image::getmipmaps, &Image::setmipmaps);
      rlImage.property("format", &Image::getformat, &Image::setformat);
  
      Php::Class<Texture2D> rlTexture2D("Texture2D");
      rlNamespace.add(rlTexture2D);
      rlTexture2D.property("id", &Texture2D::getid, &Texture2D::setid);
      rlTexture2D.property("width", &Texture2D::getwidth, &Texture2D::setwidth);
      rlTexture2D.property("height", &Texture2D::getheight,
                           &Texture2D::setheight);
      rlTexture2D.property("mipmaps", &Texture2D::getmipmaps,
                           &Texture2D::setmipmaps);
      rlTexture2D.property("format", &Texture2D::getformat,
                           &Texture2D::setformat);
  
      Php::Class<RenderTexture2D> rlRenderTexture2D("RenderTexture2D");
      rlRenderTexture2D.property("id", &RenderTexture2D::getid,
                                 &RenderTexture2D::setid);
      rlRenderTexture2D.property("texture", &RenderTexture2D::gettexture,
                                 &RenderTexture2D::settexture);
      rlRenderTexture2D.property("depth", &RenderTexture2D::getdepth,
                                 &RenderTexture2D::setdepth);
      rlNamespace.add(rlRenderTexture2D);
  
      Php::Class<NPatchInfo> rlNPatchInfo("NPatchInfo");
      rlNamespace.add(rlNPatchInfo);
      rlNPatchInfo.property("left", &NPatchInfo::getleft, &NPatchInfo::setleft);
      rlNPatchInfo.property("top", &NPatchInfo::gettop, &NPatchInfo::settop);
      rlNPatchInfo.property("right", &NPatchInfo::getright,
                            &NPatchInfo::setright);
      rlNPatchInfo.property("bottom", &NPatchInfo::getbottom,
                            &NPatchInfo::setbottom);
      rlNPatchInfo.property("type", &NPatchInfo::gettype, &NPatchInfo::settype);
  
      Php::Class<CharInfo> rlCharInfo("CharInfo");
      rlNamespace.add(rlCharInfo);
      rlCharInfo.property("value", &CharInfo::getvalue, &CharInfo::setvalue);
      rlCharInfo.property("offsetX", &CharInfo::getoffsetX,
                          &CharInfo::setoffsetX);
      rlCharInfo.property("offsetY", &CharInfo::getoffsetY,
                          &CharInfo::setoffsetY);
      rlCharInfo.property("advanceX", &CharInfo::getadvanceX,
                          &CharInfo::setadvanceX);
      rlCharInfo.property("image", &CharInfo::getimage, &CharInfo::setimage);
  
      Php::Class<Font> rlFont("Font");
      rlNamespace.add(rlFont);
      rlFont.property("baseSize", &Font::getbaseSize, &Font::setbaseSize);
      rlFont.property("charsCount", &Font::getcharsCount, &Font::setcharsCount);
      rlFont.property("texture", &Font::gettexture, &Font::settexture);
  
      Php::Class<Camera3D> rlCamera3D("Camera3D");
      rlNamespace.add(rlCamera3D);
      rlCamera3D.property("position", &Camera3D::getposition,
                          &Camera3D::setposition);
      rlCamera3D.property("target", &Camera3D::gettarget, &Camera3D::settarget);
      rlCamera3D.property("up", &Camera3D::getup, &Camera3D::setup);
      rlCamera3D.property("fovy", &Camera3D::getfovy, &Camera3D::setfovy);
      rlCamera3D.property("type", &Camera3D::gettype, &Camera3D::settype);
  
      Php::Class<Camera2D> rlCamera2D("Camera2D");
      rlNamespace.add(rlCamera2D);
      rlCamera2D.property("offset", &Camera2D::getoffset, &Camera2D::setoffset);
      rlCamera2D.property("target", &Camera2D::gettarget, &Camera2D::settarget);
      rlCamera2D.property("rotation", &Camera2D::getrotation,
                          &Camera2D::setrotation);
      rlCamera2D.property("zoom", &Camera2D::getzoom, &Camera2D::setzoom);
  
      Php::Class<Mesh> rlMesh("Mesh");
      rlNamespace.add(rlMesh);
      rlMesh.property("vertexCount", &Mesh::getvertexCount,
                      &Mesh::setvertexCount);
      rlMesh.property("triangleCount", &Mesh::gettriangleCount,
                      &Mesh::settriangleCount);
      rlMesh.property("vaoId", &Mesh::getvaoId, &Mesh::setvaoId);
      rlMesh.property("vertices", &Mesh::getvertices, &Mesh::setvertices);
      rlMesh.property("texcoords", &Mesh::gettexcoords, &Mesh::settexcoords);
      rlMesh.property("texcoords2", &Mesh::gettexcoords2, &Mesh::settexcoords2);
      rlMesh.property("normals", &Mesh::getnormals, &Mesh::setnormals);
      rlMesh.property("tangents", &Mesh::gettangents, &Mesh::settangents);
      rlMesh.property("colors", &Mesh::getcolors, &Mesh::setcolors);
      rlMesh.property("indices", &Mesh::getindices, &Mesh::setindices);
      rlMesh.property("animVertices", &Mesh::getanimVertices,
                      &Mesh::setanimVertices);
      rlMesh.property("animNormals", &Mesh::getanimNormals,
                      &Mesh::setanimNormals);
      rlMesh.property("boneIds", &Mesh::getboneIds, &Mesh::setboneIds);
      rlMesh.property("boneWeights", &Mesh::getboneWeights,
                      &Mesh::setboneWeights);
      rlMesh.property("vboId", &Mesh::getvboId, &Mesh::setvboId);
  
      Php::Class<Shader> rlShader("Shader");
      rlNamespace.add(rlShader);
      rlShader.property("id", &Shader::getid, &Shader::setid);
      rlShader.property("locs", &Shader::getlocs, &Shader::setlocs);
  
      Php::Class<MaterialMap> rlMaterialMap("MaterialMap");
      rlNamespace.add(rlMaterialMap);
      rlMaterialMap.property("texture", &MaterialMap::gettexture,
                             &MaterialMap::settexture);
      rlMaterialMap.property("color", &MaterialMap::getcolor,
                             &MaterialMap::setcolor);
      rlMaterialMap.property("value", &MaterialMap::getvalue,
                             &MaterialMap::setvalue);
  
      Php::Class<Material> rlMaterial("Material");
      rlNamespace.add(rlMaterial);
      rlMaterial.property("shader", &Material::getshader, &Material::setshader);
      rlMaterial.property("maps", &Material::getmaps, &Material::setmaps);
      rlMaterial.property("params", &Material::getparams, &Material::setparams);
  
      Php::Class<Transform> rlTransform("Transform");
      rlNamespace.add(rlTransform);
      rlTransform.property("translation", &Transform::gettranslation,
                           &Transform::settranslation);
      rlTransform.property("rotation", &Transform::getrotation,
                           &Transform::setrotation);
      rlTransform.property("scale", &Transform::getscale, &Transform::setscale);
  
      Php::Class<BoneInfo> rlBoneInfo("BoneInfo");
      rlNamespace.add(rlBoneInfo);
      rlBoneInfo.property("name", &BoneInfo::getname, &BoneInfo::setname);
      rlBoneInfo.property("parent", &BoneInfo::getparent, &BoneInfo::setparent);
  
      Php::Class<Model> rlModel("Model");
      rlNamespace.add(rlModel);
      rlModel.property("transform", &Model::gettransform, &Model::settransform);
      rlModel.property("meshCount", &Model::getmeshCount, &Model::setmeshCount);
      rlModel.property("meshes", &Model::getmeshes, &Model::setmeshes);
      rlModel.property("materialCount", &Model::getmaterialCount,
                       &Model::setmaterialCount);
      rlModel.property("materials", &Model::getmaterials, &Model::setmaterials);
      rlModel.property("boneCount", &Model::getboneCount, &Model::setboneCount);
  
      Php::Class<ModelAnimation> rlModelAnimation("ModelAnimation");
      rlNamespace.add(rlModelAnimation);
      rlModelAnimation.property("boneCount", &ModelAnimation::getboneCount,
                                &ModelAnimation::setboneCount);
      rlModelAnimation.property("frameCount", &ModelAnimation::getframeCount,
                                &ModelAnimation::setframeCount);
  
      Php::Class<Ray> rlRay("Ray");
      rlNamespace.add(rlRay);
      rlRay.property("position", &Ray::getposition, &Ray::setposition);
      rlRay.property("direction", &Ray::getdirection, &Ray::setdirection);
  
      Php::Class<RayHitInfo> rlRayHitInfo("RayHitInfo");
      rlNamespace.add(rlRayHitInfo);
  
      Php::Class<BoundingBox> rlBoundingBox("BoundingBox");
      rlNamespace.add(rlBoundingBox);
      rlBoundingBox.property("min", &BoundingBox::getmin, &BoundingBox::setmin);
      rlBoundingBox.property("max", &BoundingBox::getmax, &BoundingBox::setmax);
  
      Php::Class<Wave> rlWave("Wave");
      rlNamespace.add(rlWave);
      rlWave.property("sampleCount", &Wave::getsampleCount,
                      &Wave::setsampleCount);
      rlWave.property("sampleRate", &Wave::getsampleRate, &Wave::setsampleRate);
      rlWave.property("sampleSize", &Wave::getsampleSize, &Wave::setsampleSize);
      rlWave.property("channels", &Wave::getchannels, &Wave::setchannels);
  
      // Php::Class<rAudioBuffer> rlrAudioBuffer("rAudioBuffer");
      // rlNamespace.add(rlrAudioBuffer);
  
      Php::Class<AudioStream> rlAudioStream("AudioStream");
      rlNamespace.add(rlAudioStream);
      rlAudioStream.property("sampleRate", &AudioStream::getsampleRate,
                             &AudioStream::setsampleRate);
      rlAudioStream.property("sampleSize", &AudioStream::getsampleSize,
                             &AudioStream::setsampleSize);
      rlAudioStream.property("channels", &AudioStream::getchannels,
                             &AudioStream::setchannels);
  
      Php::Class<Sound> rlSound("Sound");
      rlNamespace.add(rlSound);
      rlSound.property("sampleCount", &Sound::getsampleCount,
                       &Sound::setsampleCount);
      rlSound.property("stream", &Sound::getstream, &Sound::setstream);
  
      Php::Class<Music> rlMusic("Music");
      rlNamespace.add(rlMusic);
      rlMusic.property("ctxType", &Music::getctxType, &Music::setctxType);
      rlMusic.property("sampleCount", &Music::getsampleCount,
                       &Music::setsampleCount);
      rlMusic.property("stream", &Music::getstream, &Music::setstream);
  
      Php::Class<VrDeviceInfo> rlVrDeviceInfo("VrDeviceInfo");
      rlNamespace.add(rlVrDeviceInfo);
      rlVrDeviceInfo.property("hResolution", &VrDeviceInfo::gethResolution,
                              &VrDeviceInfo::sethResolution);
      rlVrDeviceInfo.property("vResolution", &VrDeviceInfo::getvResolution,
                              &VrDeviceInfo::setvResolution);
      rlVrDeviceInfo.property("hScreenSize", &VrDeviceInfo::gethScreenSize,
                              &VrDeviceInfo::sethScreenSize);
      rlVrDeviceInfo.property("vScreenSize", &VrDeviceInfo::getvScreenSize,
                              &VrDeviceInfo::setvScreenSize);
      rlVrDeviceInfo.property("vScreenCenter", &VrDeviceInfo::getvScreenCenter,
                              &VrDeviceInfo::setvScreenCenter);
      rlVrDeviceInfo.property("eyeToScreenDistance",
                              &VrDeviceInfo::geteyeToScreenDistance,
                              &VrDeviceInfo::seteyeToScreenDistance);
      rlVrDeviceInfo.property("lensSeparationDistance",
                              &VrDeviceInfo::getlensSeparationDistance,
                              &VrDeviceInfo::setlensSeparationDistance);
      rlVrDeviceInfo.property("interpupillaryDistance",
                              &VrDeviceInfo::getinterpupillaryDistance,
                              &VrDeviceInfo::setinterpupillaryDistance);
      rlVrDeviceInfo.property("lensDistortionValues",
                              &VrDeviceInfo::getlensDistortionValues,
                              &VrDeviceInfo::setlensDistortionValues);
      rlVrDeviceInfo.property("chromaAbCorrection",
                              &VrDeviceInfo::getchromaAbCorrection,
                              &VrDeviceInfo::setchromaAbCorrection);
  
      Php::Class<TraceLogCallback> rlTraceLogCallback("TraceLogCallback");
      rlNamespace.add(rlTraceLogCallback);
  
      extension.add<&RL::InitWindow>("InitWindow");
      extension.add<&RL::WindowShouldClose>("WindowShouldClose");
      extension.add<&RL::CloseWindow>("CloseWindow");
      extension.add<&RL::IsWindowReady>("IsWindowReady");
      extension.add<&RL::IsWindowMinimized>("IsWindowMinimized");
      extension.add<&RL::IsWindowResized>("IsWindowResized");
      extension.add<&RL::IsWindowHidden>("IsWindowHidden");
      extension.add<&RL::IsWindowFullscreen>("IsWindowFullscreen");
      extension.add<&RL::ToggleFullscreen>("ToggleFullscreen");
      extension.add<&RL::SetWindowIcon>("SetWindowIcon");
      extension.add<&RL::SetWindowTitle>("SetWindowTitle");
      extension.add<&RL::SetWindowPosition>("SetWindowPosition");
      extension.add<&RL::SetWindowMonitor>("SetWindowMonitor");
      extension.add<&RL::SetWindowMinSize>("SetWindowMinSize");
      extension.add<&RL::SetWindowSize>("SetWindowSize");
      // GetWindowHandle is not supported
      extension.add<&RL::GetScreenWidth>("GetScreenWidth");
      extension.add<&RL::GetScreenHeight>("GetScreenHeight");
      extension.add<&RL::GetMonitorCount>("GetMonitorCount");
      extension.add<&RL::GetMonitorWidth>("GetMonitorWidth");
      extension.add<&RL::GetMonitorHeight>("GetMonitorHeight");
      extension.add<&RL::GetMonitorPhysicalWidth>("GetMonitorPhysicalWidth");
      extension.add<&RL::GetMonitorPhysicalHeight>("GetMonitorPhysicalHeight");
      extension.add<&RL::GetWindowPosition>("GetWindowPosition");
      extension.add<&RL::GetMonitorName>("GetMonitorName");
      extension.add<&RL::GetClipboardText>("GetClipboardText");
      extension.add<&RL::SetClipboardText>("SetClipboardText");
      extension.add<&RL::ShowCursor>("ShowCursor");
      extension.add<&RL::HideCursor>("HideCursor");
      extension.add<&RL::IsCursorHidden>("IsCursorHidden");
      extension.add<&RL::EnableCursor>("EnableCursor");
      extension.add<&RL::DisableCursor>("DisableCursor");
      extension.add<&RL::ClearBackground>("ClearBackground");
      extension.add<&RL::BeginDrawing>("BeginDrawing");
      extension.add<&RL::EndDrawing>("EndDrawing");
      extension.add<&RL::BeginMode2D>("BeginMode2D");
      extension.add<&RL::EndMode2D>("EndMode2D");
      extension.add<&RL::BeginMode3D>("BeginMode3D");
      extension.add<&RL::EndMode3D>("EndMode3D");
      extension.add<&RL::BeginTextureMode>("BeginTextureMode");
      extension.add<&RL::EndTextureMode>("EndTextureMode");
      extension.add<&RL::BeginScissorMode>("BeginScissorMode");
      extension.add<&RL::EndScissorMode>("EndScissorMode");
      extension.add<&RL::GetMouseRay>("GetMouseRay");
      extension.add<&RL::GetCameraMatrix>("GetCameraMatrix");
      extension.add<&RL::GetCameraMatrix2D>("GetCameraMatrix2D");
      extension.add<&RL::GetWorldToScreen>("GetWorldToScreen");
      extension.add<&RL::GetWorldToScreenEx>("GetWorldToScreenEx");
      extension.add<&RL::GetWorldToScreen2D>("GetWorldToScreen2D");
      extension.add<&RL::GetScreenToWorld2D>("GetScreenToWorld2D");
      extension.add<&RL::SetTargetFPS>("SetTargetFPS");
      extension.add<&RL::GetFPS>("GetFPS");
      extension.add<&RL::GetFrameTime>("GetFrameTime");
      extension.add<&RL::GetTime>("GetTime");
      extension.add<&RL::ColorToInt>("ColorToInt");
      extension.add<&RL::ColorNormalize>("ColorNormalize");
      extension.add<&RL::ColorFromNormalized>("ColorFromNormalized");
      extension.add<&RL::ColorToHSV>("ColorToHSV");
      extension.add<&RL::ColorFromHSV>("ColorFromHSV");
      extension.add<&RL::GetColor>("GetColor");
      extension.add<&RL::Fade>("Fade");
      extension.add<&RL::SetConfigFlags>("SetConfigFlags");
      extension.add<&RL::SetTraceLogLevel>("SetTraceLogLevel");
      extension.add<&RL::SetTraceLogExit>("SetTraceLogExit");
      extension.add<&RL::SetTraceLogCallback>("SetTraceLogCallback");
      extension.add<&RL::TraceLog>("TraceLog");
      extension.add<&RL::TakeScreenshot>("TakeScreenshot");
      extension.add<&RL::GetRandomValue>("GetRandomValue");
      // LoadFileData is not supported
      extension.add<&RL::SaveFileData>("SaveFileData");
      extension.add<&RL::LoadFileText>("LoadFileText");
      extension.add<&RL::SaveFileText>("SaveFileText");
      extension.add<&RL::FileExists>("FileExists");
      extension.add<&RL::IsFileExtension>("IsFileExtension");
      extension.add<&RL::DirectoryExists>("DirectoryExists");
      extension.add<&RL::GetExtension>("GetExtension");
      extension.add<&RL::GetFileName>("GetFileName");
      extension.add<&RL::GetFileNameWithoutExt>("GetFileNameWithoutExt");
      extension.add<&RL::GetDirectoryPath>("GetDirectoryPath");
      extension.add<&RL::GetPrevDirectoryPath>("GetPrevDirectoryPath");
      extension.add<&RL::GetWorkingDirectory>("GetWorkingDirectory");
      // GetDirectoryFiles is not supported
      extension.add<&RL::ClearDirectoryFiles>("ClearDirectoryFiles");
      extension.add<&RL::ChangeDirectory>("ChangeDirectory");
      extension.add<&RL::IsFileDropped>("IsFileDropped");
      extension.add<&RL::GetDroppedFiles>("GetDroppedFiles");
      extension.add<&RL::ClearDroppedFiles>("ClearDroppedFiles");
      extension.add<&RL::GetFileModTime>("GetFileModTime");
      // CompressData is not supported
      // DecompressData is not supported
      extension.add<&RL::SaveStorageValue>("SaveStorageValue");
      extension.add<&RL::LoadStorageValue>("LoadStorageValue");
      extension.add<&RL::OpenURL>("OpenURL");
      extension.add<&RL::IsKeyPressed>("IsKeyPressed");
      extension.add<&RL::IsKeyDown>("IsKeyDown");
      extension.add<&RL::IsKeyReleased>("IsKeyReleased");
      extension.add<&RL::IsKeyUp>("IsKeyUp");
      extension.add<&RL::SetExitKey>("SetExitKey");
      extension.add<&RL::GetKeyPressed>("GetKeyPressed");
      extension.add<&RL::IsGamepadAvailable>("IsGamepadAvailable");
      extension.add<&RL::IsGamepadName>("IsGamepadName");
      extension.add<&RL::GetGamepadName>("GetGamepadName");
      extension.add<&RL::IsGamepadButtonPressed>("IsGamepadButtonPressed");
      extension.add<&RL::IsGamepadButtonDown>("IsGamepadButtonDown");
      extension.add<&RL::IsGamepadButtonReleased>("IsGamepadButtonReleased");
      extension.add<&RL::IsGamepadButtonUp>("IsGamepadButtonUp");
      extension.add<&RL::GetGamepadButtonPressed>("GetGamepadButtonPressed");
      extension.add<&RL::GetGamepadAxisCount>("GetGamepadAxisCount");
      extension.add<&RL::GetGamepadAxisMovement>("GetGamepadAxisMovement");
      extension.add<&RL::IsMouseButtonPressed>("IsMouseButtonPressed");
      extension.add<&RL::IsMouseButtonDown>("IsMouseButtonDown");
      extension.add<&RL::IsMouseButtonReleased>("IsMouseButtonReleased");
      extension.add<&RL::IsMouseButtonUp>("IsMouseButtonUp");
      extension.add<&RL::GetMouseX>("GetMouseX");
      extension.add<&RL::GetMouseY>("GetMouseY");
      extension.add<&RL::GetMousePosition>("GetMousePosition");
      extension.add<&RL::SetMousePosition>("SetMousePosition");
      extension.add<&RL::SetMouseOffset>("SetMouseOffset");
      extension.add<&RL::SetMouseScale>("SetMouseScale");
      extension.add<&RL::GetMouseWheelMove>("GetMouseWheelMove");
      extension.add<&RL::GetTouchX>("GetTouchX");
      extension.add<&RL::GetTouchY>("GetTouchY");
      extension.add<&RL::GetTouchPosition>("GetTouchPosition");
      extension.add<&RL::SetGesturesEnabled>("SetGesturesEnabled");
      extension.add<&RL::IsGestureDetected>("IsGestureDetected");
      extension.add<&RL::GetGestureDetected>("GetGestureDetected");
      extension.add<&RL::GetTouchPointsCount>("GetTouchPointsCount");
      extension.add<&RL::GetGestureHoldDuration>("GetGestureHoldDuration");
      extension.add<&RL::GetGestureDragVector>("GetGestureDragVector");
      extension.add<&RL::GetGestureDragAngle>("GetGestureDragAngle");
      extension.add<&RL::GetGesturePinchVector>("GetGesturePinchVector");
      extension.add<&RL::GetGesturePinchAngle>("GetGesturePinchAngle");
      extension.add<&RL::SetCameraMode>("SetCameraMode");
      extension.add<&RL::UpdateCamera>("UpdateCamera");
      extension.add<&RL::SetCameraPanControl>("SetCameraPanControl");
      extension.add<&RL::SetCameraAltControl>("SetCameraAltControl");
      extension.add<&RL::SetCameraSmoothZoomControl>(
          "SetCameraSmoothZoomControl");
      extension.add<&RL::SetCameraMoveControls>("SetCameraMoveControls");
      extension.add<&RL::DrawPixel>("DrawPixel");
      extension.add<&RL::DrawPixelV>("DrawPixelV");
      extension.add<&RL::DrawLine>("DrawLine");
      extension.add<&RL::DrawLineV>("DrawLineV");
      extension.add<&RL::DrawLineEx>("DrawLineEx");
      extension.add<&RL::DrawLineBezier>("DrawLineBezier");
      extension.add<&RL::DrawLineStrip>("DrawLineStrip");
      extension.add<&RL::DrawCircle>("DrawCircle");
      extension.add<&RL::DrawCircleSector>("DrawCircleSector");
      extension.add<&RL::DrawCircleSectorLines>("DrawCircleSectorLines");
      extension.add<&RL::DrawCircleGradient>("DrawCircleGradient");
      extension.add<&RL::DrawCircleV>("DrawCircleV");
      extension.add<&RL::DrawCircleLines>("DrawCircleLines");
      extension.add<&RL::DrawEllipse>("DrawEllipse");
      extension.add<&RL::DrawEllipseLines>("DrawEllipseLines");
      extension.add<&RL::DrawRing>("DrawRing");
      extension.add<&RL::DrawRingLines>("DrawRingLines");
      extension.add<&RL::DrawRectangle>("DrawRectangle");
      extension.add<&RL::DrawRectangleV>("DrawRectangleV");
      extension.add<&RL::DrawRectangleRec>("DrawRectangleRec");
      extension.add<&RL::DrawRectanglePro>("DrawRectanglePro");
      extension.add<&RL::DrawRectangleGradientV>("DrawRectangleGradientV");
      extension.add<&RL::DrawRectangleGradientH>("DrawRectangleGradientH");
      extension.add<&RL::DrawRectangleGradientEx>("DrawRectangleGradientEx");
      extension.add<&RL::DrawRectangleLines>("DrawRectangleLines");
      extension.add<&RL::DrawRectangleLinesEx>("DrawRectangleLinesEx");
      extension.add<&RL::DrawRectangleRounded>("DrawRectangleRounded");
      extension.add<&RL::DrawRectangleRoundedLines>("DrawRectangleRoundedLines");
      extension.add<&RL::DrawTriangle>("DrawTriangle");
      extension.add<&RL::DrawTriangleLines>("DrawTriangleLines");
      extension.add<&RL::DrawTriangleFan>("DrawTriangleFan");
      extension.add<&RL::DrawTriangleStrip>("DrawTriangleStrip");
      extension.add<&RL::DrawPoly>("DrawPoly");
      extension.add<&RL::DrawPolyLines>("DrawPolyLines");
      extension.add<&RL::CheckCollisionRecs>("CheckCollisionRecs");
      extension.add<&RL::CheckCollisionCircles>("CheckCollisionCircles");
      extension.add<&RL::CheckCollisionCircleRec>("CheckCollisionCircleRec");
      extension.add<&RL::GetCollisionRec>("GetCollisionRec");
      extension.add<&RL::CheckCollisionPointRec>("CheckCollisionPointRec");
      extension.add<&RL::CheckCollisionPointCircle>("CheckCollisionPointCircle");
      extension.add<&RL::CheckCollisionPointTriangle>(
          "CheckCollisionPointTriangle");
      extension.add<&RL::LoadImage>("LoadImage");
      extension.add<&RL::LoadImageRaw>("LoadImageRaw");
      extension.add<&RL::UnloadImage>("UnloadImage");
      extension.add<&RL::ExportImage>("ExportImage");
      extension.add<&RL::ExportImageAsCode>("ExportImageAsCode");
      extension.add<&RL::GetImageData>("GetImageData");
      extension.add<&RL::GenImageColor>("GenImageColor");
      extension.add<&RL::GenImageGradientV>("GenImageGradientV");
      extension.add<&RL::GenImageGradientH>("GenImageGradientH");
      extension.add<&RL::GenImageGradientRadial>("GenImageGradientRadial");
      extension.add<&RL::GenImageChecked>("GenImageChecked");
      extension.add<&RL::GenImageWhiteNoise>("GenImageWhiteNoise");
      extension.add<&RL::GenImagePerlinNoise>("GenImagePerlinNoise");
      extension.add<&RL::GenImageCellular>("GenImageCellular");
      extension.add<&RL::ImageCopy>("ImageCopy");
      extension.add<&RL::ImageFromImage>("ImageFromImage");
      extension.add<&RL::ImageText>("ImageText");
      extension.add<&RL::ImageTextEx>("ImageTextEx");
      extension.add<&RL::ImageToPOT>("ImageToPOT");
      extension.add<&RL::ImageFormat>("ImageFormat");
      extension.add<&RL::ImageAlphaMask>("ImageAlphaMask");
      extension.add<&RL::ImageAlphaClear>("ImageAlphaClear");
      extension.add<&RL::ImageAlphaCrop>("ImageAlphaCrop");
      extension.add<&RL::ImageAlphaPremultiply>("ImageAlphaPremultiply");
      extension.add<&RL::ImageCrop>("ImageCrop");
      extension.add<&RL::ImageResize>("ImageResize");
      extension.add<&RL::ImageResizeNN>("ImageResizeNN");
      extension.add<&RL::ImageResizeCanvas>("ImageResizeCanvas");
      extension.add<&RL::ImageMipmaps>("ImageMipmaps");
      extension.add<&RL::ImageDither>("ImageDither");
      extension.add<&RL::ImageFlipVertical>("ImageFlipVertical");
      extension.add<&RL::ImageFlipHorizontal>("ImageFlipHorizontal");
      extension.add<&RL::ImageRotateCW>("ImageRotateCW");
      extension.add<&RL::ImageRotateCCW>("ImageRotateCCW");
      extension.add<&RL::ImageColorTint>("ImageColorTint");
      extension.add<&RL::ImageColorInvert>("ImageColorInvert");
      extension.add<&RL::ImageColorGrayscale>("ImageColorGrayscale");
      extension.add<&RL::ImageColorContrast>("ImageColorContrast");
      extension.add<&RL::ImageColorBrightness>("ImageColorBrightness");
      extension.add<&RL::ImageColorReplace>("ImageColorReplace");
      extension.add<&RL::GetImageAlphaBorder>("GetImageAlphaBorder");
      extension.add<&RL::ImageClearBackground>("ImageClearBackground");
      extension.add<&RL::ImageDrawPixel>("ImageDrawPixel");
      extension.add<&RL::ImageDrawPixelV>("ImageDrawPixelV");
      extension.add<&RL::ImageDrawLine>("ImageDrawLine");
      extension.add<&RL::ImageDrawLineV>("ImageDrawLineV");
      extension.add<&RL::ImageDrawCircle>("ImageDrawCircle");
      extension.add<&RL::ImageDrawCircleV>("ImageDrawCircleV");
      extension.add<&RL::ImageDrawRectangle>("ImageDrawRectangle");
      extension.add<&RL::ImageDrawRectangleV>("ImageDrawRectangleV");
      extension.add<&RL::ImageDrawRectangleRec>("ImageDrawRectangleRec");
      extension.add<&RL::ImageDrawRectangleLines>("ImageDrawRectangleLines");
      extension.add<&RL::ImageDraw>("ImageDraw");
      extension.add<&RL::ImageDrawText>("ImageDrawText");
      extension.add<&RL::ImageDrawTextEx>("ImageDrawTextEx");
      extension.add<&RL::LoadTexture>("LoadTexture");
      extension.add<&RL::LoadTextureFromImage>("LoadTextureFromImage");
      extension.add<&RL::LoadTextureCubemap>("LoadTextureCubemap");
      extension.add<&RL::LoadRenderTexture>("LoadRenderTexture");
      extension.add<&RL::UnloadTexture>("UnloadTexture");
      extension.add<&RL::UnloadRenderTexture>("UnloadRenderTexture");
      extension.add<&RL::UpdateTexture>("UpdateTexture");
      extension.add<&RL::GetTextureData>("GetTextureData");
      extension.add<&RL::GetScreenData>("GetScreenData");
      extension.add<&RL::GenTextureMipmaps>("GenTextureMipmaps");
      extension.add<&RL::SetTextureFilter>("SetTextureFilter");
      extension.add<&RL::SetTextureWrap>("SetTextureWrap");
      extension.add<&RL::DrawTexture>("DrawTexture");
      extension.add<&RL::DrawTextureV>("DrawTextureV");
      extension.add<&RL::DrawTextureEx>("DrawTextureEx");
      extension.add<&RL::DrawTextureRec>("DrawTextureRec");
      extension.add<&RL::DrawTextureQuad>("DrawTextureQuad");
      extension.add<&RL::DrawTexturePro>("DrawTexturePro");
      extension.add<&RL::DrawTextureNPatch>("DrawTextureNPatch");
      extension.add<&RL::GetPixelDataSize>("GetPixelDataSize");
      extension.add<&RL::GetFontDefault>("GetFontDefault");
      extension.add<&RL::LoadFont>("LoadFont");
      // extension.add<&RL::LoadFontEx>("LoadFontEx");
      extension.add<&RL::LoadFontFromImage>("LoadFontFromImage");
      // LoadFontData is not supported
      // extension.add<&RL::GenImageFontAtlas>("GenImageFontAtlas");
      extension.add<&RL::UnloadFont>("UnloadFont");
      extension.add<&RL::DrawFPS>("DrawFPS");
      extension.add<&RL::DrawText>("DrawText");
      extension.add<&RL::DrawTextEx>("DrawTextEx");
      extension.add<&RL::DrawTextRec>("DrawTextRec");
      extension.add<&RL::DrawTextRecEx>("DrawTextRecEx");
      extension.add<&RL::DrawTextCodepoint>("DrawTextCodepoint");
      extension.add<&RL::MeasureText>("MeasureText");
      extension.add<&RL::MeasureTextEx>("MeasureTextEx");
      extension.add<&RL::GetGlyphIndex>("GetGlyphIndex");
      // extension.add<&RL::TextCopy>("TextCopy");
      // extension.add<&RL::TextIsEqual>("TextIsEqual");
      extension.add<&RL::TextLength>("TextLength");
      extension.add<&RL::TextFormat>("TextFormat");
      extension.add<&RL::TextSubtext>("TextSubtext");
      // extension.add<&RL::TextReplace>("TextReplace");
      extension.add<&RL::TextInsert>("TextInsert");
      // extension.add<&RL::TextJoin>("TextJoin");
      // TextSplit is not supported
      // extension.add<&RL::TextAppend>("TextAppend");
      extension.add<&RL::TextFindIndex>("TextFindIndex");
      extension.add<&RL::TextToUpper>("TextToUpper");
      extension.add<&RL::TextToLower>("TextToLower");
      extension.add<&RL::TextToPascal>("TextToPascal");
      extension.add<&RL::TextToInteger>("TextToInteger");
      // extension.add<&RL::TextToUtf8>("TextToUtf8");
      // GetCodepoints is not supported
      extension.add<&RL::GetCodepointsCount>("GetCodepointsCount");
      // extension.add<&RL::GetNextCodepoint>("GetNextCodepoint");
      // extension.add<&RL::CodepointToUtf8>("CodepointToUtf8");
      extension.add<&RL::DrawLine3D>("DrawLine3D");
      extension.add<&RL::DrawPoint3D>("DrawPoint3D");
      extension.add<&RL::DrawCircle3D>("DrawCircle3D");
      extension.add<&RL::DrawCube>("DrawCube");
      extension.add<&RL::DrawCubeV>("DrawCubeV");
      extension.add<&RL::DrawCubeWires>("DrawCubeWires");
      extension.add<&RL::DrawCubeWiresV>("DrawCubeWiresV");
      extension.add<&RL::DrawCubeTexture>("DrawCubeTexture");
      extension.add<&RL::DrawSphere>("DrawSphere");
      extension.add<&RL::DrawSphereEx>("DrawSphereEx");
      extension.add<&RL::DrawSphereWires>("DrawSphereWires");
      extension.add<&RL::DrawCylinder>("DrawCylinder");
      extension.add<&RL::DrawCylinderWires>("DrawCylinderWires");
      extension.add<&RL::DrawPlane>("DrawPlane");
      extension.add<&RL::DrawRay>("DrawRay");
      extension.add<&RL::DrawGrid>("DrawGrid");
      extension.add<&RL::DrawGizmo>("DrawGizmo");
      extension.add<&RL::LoadModel>("LoadModel");
      extension.add<&RL::LoadModelFromMesh>("LoadModelFromMesh");
      extension.add<&RL::UnloadModel>("UnloadModel");
      extension.add<&RL::UnloadModel>("LoadMeshes");
      extension.add<&RL::ExportMesh>("ExportMesh");
      extension.add<&RL::UnloadMesh>("UnloadMesh");
      extension.add<&RL::UnloadMesh>("LoadMaterials");
      extension.add<&RL::LoadMaterialDefault>("LoadMaterialDefault");
      extension.add<&RL::UnloadMaterial>("UnloadMaterial");
      extension.add<&RL::SetMaterialTexture>("SetMaterialTexture");
      extension.add<&RL::SetModelMeshMaterial>("SetModelMeshMaterial");
      extension.add<&RL::SetModelMeshMaterial>("LoadModelAnimations");
      extension.add<&RL::UpdateModelAnimation>("UpdateModelAnimation");
      extension.add<&RL::UnloadModelAnimation>("UnloadModelAnimation");
      extension.add<&RL::IsModelAnimationValid>("IsModelAnimationValid");
      extension.add<&RL::GenMeshPoly>("GenMeshPoly");
      extension.add<&RL::GenMeshPlane>("GenMeshPlane");
      extension.add<&RL::GenMeshCube>("GenMeshCube");
      extension.add<&RL::GenMeshSphere>("GenMeshSphere");
      extension.add<&RL::GenMeshHemiSphere>("GenMeshHemiSphere");
      extension.add<&RL::GenMeshCylinder>("GenMeshCylinder");
      extension.add<&RL::GenMeshTorus>("GenMeshTorus");
      extension.add<&RL::GenMeshKnot>("GenMeshKnot");
      extension.add<&RL::GenMeshHeightmap>("GenMeshHeightmap");
      extension.add<&RL::GenMeshCubicmap>("GenMeshCubicmap");
      extension.add<&RL::MeshBoundingBox>("MeshBoundingBox");
      extension.add<&RL::MeshTangents>("MeshTangents");
      extension.add<&RL::MeshBinormals>("MeshBinormals");
      extension.add<&RL::DrawModel>("DrawModel");
      extension.add<&RL::DrawModelEx>("DrawModelEx");
      extension.add<&RL::DrawModelWires>("DrawModelWires");
      extension.add<&RL::DrawModelWiresEx>("DrawModelWiresEx");
      extension.add<&RL::DrawBoundingBox>("DrawBoundingBox");
      extension.add<&RL::DrawBillboard>("DrawBillboard");
      extension.add<&RL::DrawBillboardRec>("DrawBillboardRec");
      extension.add<&RL::CheckCollisionSpheres>("CheckCollisionSpheres");
      extension.add<&RL::CheckCollisionBoxes>("CheckCollisionBoxes");
      extension.add<&RL::CheckCollisionBoxSphere>("CheckCollisionBoxSphere");
      extension.add<&RL::CheckCollisionRaySphere>("CheckCollisionRaySphere");
      extension.add<&RL::CheckCollisionRaySphereEx>("CheckCollisionRaySphereEx");
      extension.add<&RL::CheckCollisionRayBox>("CheckCollisionRayBox");
      extension.add<&RL::GetCollisionRayModel>("GetCollisionRayModel");
      extension.add<&RL::GetCollisionRayTriangle>("GetCollisionRayTriangle");
      extension.add<&RL::GetCollisionRayGround>("GetCollisionRayGround");
      extension.add<&RL::LoadShader>("LoadShader");
      extension.add<&RL::LoadShaderCode>("LoadShaderCode");
      extension.add<&RL::UnloadShader>("UnloadShader");
      extension.add<&RL::GetShaderDefault>("GetShaderDefault");
      extension.add<&RL::GetTextureDefault>("GetTextureDefault");
      extension.add<&RL::GetShapesTexture>("GetShapesTexture");
      extension.add<&RL::GetShapesTextureRec>("GetShapesTextureRec");
      extension.add<&RL::SetShapesTexture>("SetShapesTexture");
      extension.add<&RL::GetShaderLocation>("GetShaderLocation");
      extension.add<&RL::SetShaderValue>("SetShaderValue");
      extension.add<&RL::SetShaderValueV>("SetShaderValueV");
      extension.add<&RL::SetShaderValueMatrix>("SetShaderValueMatrix");
      extension.add<&RL::SetShaderValueTexture>("SetShaderValueTexture");
      extension.add<&RL::SetMatrixProjection>("SetMatrixProjection");
      extension.add<&RL::SetMatrixModelview>("SetMatrixModelview");
      extension.add<&RL::GetMatrixModelview>("GetMatrixModelview");
      extension.add<&RL::GetMatrixProjection>("GetMatrixProjection");
      extension.add<&RL::GenTextureCubemap>("GenTextureCubemap");
      extension.add<&RL::GenTextureIrradiance>("GenTextureIrradiance");
      extension.add<&RL::GenTexturePrefilter>("GenTexturePrefilter");
      extension.add<&RL::GenTextureBRDF>("GenTextureBRDF");
      extension.add<&RL::BeginShaderMode>("BeginShaderMode");
      extension.add<&RL::EndShaderMode>("EndShaderMode");
      extension.add<&RL::BeginBlendMode>("BeginBlendMode");
      extension.add<&RL::EndBlendMode>("EndBlendMode");
      extension.add<&RL::InitVrSimulator>("InitVrSimulator");
      extension.add<&RL::CloseVrSimulator>("CloseVrSimulator");
      extension.add<&RL::UpdateVrTracking>("UpdateVrTracking");
      extension.add<&RL::SetVrConfiguration>("SetVrConfiguration");
      extension.add<&RL::IsVrSimulatorReady>("IsVrSimulatorReady");
      extension.add<&RL::ToggleVrMode>("ToggleVrMode");
      extension.add<&RL::BeginVrDrawing>("BeginVrDrawing");
      extension.add<&RL::EndVrDrawing>("EndVrDrawing");
      extension.add<&RL::InitAudioDevice>("InitAudioDevice");
      extension.add<&RL::CloseAudioDevice>("CloseAudioDevice");
      extension.add<&RL::IsAudioDeviceReady>("IsAudioDeviceReady");
      extension.add<&RL::SetMasterVolume>("SetMasterVolume");
      extension.add<&RL::LoadWave>("LoadWave");
      extension.add<&RL::LoadSound>("LoadSound");
      extension.add<&RL::LoadSoundFromWave>("LoadSoundFromWave");
      extension.add<&RL::UpdateSound>("UpdateSound");
      extension.add<&RL::UnloadWave>("UnloadWave");
      extension.add<&RL::UnloadSound>("UnloadSound");
      extension.add<&RL::ExportWave>("ExportWave");
      extension.add<&RL::ExportWaveAsCode>("ExportWaveAsCode");
      extension.add<&RL::PlaySound>("PlaySound");
      extension.add<&RL::StopSound>("StopSound");
      extension.add<&RL::PauseSound>("PauseSound");
      extension.add<&RL::ResumeSound>("ResumeSound");
      extension.add<&RL::PlaySoundMulti>("PlaySoundMulti");
      extension.add<&RL::StopSoundMulti>("StopSoundMulti");
      extension.add<&RL::GetSoundsPlaying>("GetSoundsPlaying");
      extension.add<&RL::IsSoundPlaying>("IsSoundPlaying");
      extension.add<&RL::SetSoundVolume>("SetSoundVolume");
      extension.add<&RL::SetSoundPitch>("SetSoundPitch");
      extension.add<&RL::WaveFormat>("WaveFormat");
      extension.add<&RL::WaveCopy>("WaveCopy");
      extension.add<&RL::WaveCrop>("WaveCrop");
      extension.add<&RL::LoadMusicStream>("LoadMusicStream");
      extension.add<&RL::UnloadMusicStream>("UnloadMusicStream");
      extension.add<&RL::PlayMusicStream>("PlayMusicStream");
      extension.add<&RL::UpdateMusicStream>("UpdateMusicStream");
      extension.add<&RL::StopMusicStream>("StopMusicStream");
      extension.add<&RL::PauseMusicStream>("PauseMusicStream");
      extension.add<&RL::ResumeMusicStream>("ResumeMusicStream");
      extension.add<&RL::IsMusicPlaying>("IsMusicPlaying");
      extension.add<&RL::SetMusicVolume>("SetMusicVolume");
      extension.add<&RL::SetMusicPitch>("SetMusicPitch");
      extension.add<&RL::GetMusicTimeLength>("GetMusicTimeLength");
      extension.add<&RL::GetMusicTimePlayed>("GetMusicTimePlayed");
      extension.add<&RL::InitAudioStream>("InitAudioStream");
      extension.add<&RL::UpdateAudioStream>("UpdateAudioStream");
      extension.add<&RL::CloseAudioStream>("CloseAudioStream");
      extension.add<&RL::IsAudioStreamProcessed>("IsAudioStreamProcessed");
      extension.add<&RL::PlayAudioStream>("PlayAudioStream");
      extension.add<&RL::PauseAudioStream>("PauseAudioStream");
      extension.add<&RL::ResumeAudioStream>("ResumeAudioStream");
      extension.add<&RL::IsAudioStreamPlaying>("IsAudioStreamPlaying");
      extension.add<&RL::StopAudioStream>("StopAudioStream");
      extension.add<&RL::SetAudioStreamVolume>("SetAudioStreamVolume");
      extension.add<&RL::SetAudioStreamPitch>("SetAudioStreamPitch");
      extension.add<&RL::SetAudioStreamBufferSizeDefault>(
          "SetAudioStreamBufferSizeDefault");
      extension.add<&RL::createVector2>("Vector2");
      extension.add<&RL::createVector3>("Vector3");
      extension.add<&RL::createVector4>("Vector4");
      extension.add<&RL::createMatrix>("Matrix");
      extension.add<&RL::createColor>("Color");
      extension.add<&RL::createRectangle>("Rectangle");
      extension.add<&RL::createTexture2D>("Texture2D");
      extension.add<&RL::createRenderTexture2D>("RenderTexture2D");
      extension.add<&RL::createNPatchInfo>("NPatchInfo");
      extension.add<&RL::createCharInfo>("CharInfo");
      extension.add<&RL::createCamera3D>("Camera3D");
      extension.add<&RL::createCamera2D>("Camera2D");
      extension.add<&RL::createMaterialMap>("MaterialMap");
      extension.add<&RL::createTransform>("Transform");
      extension.add<&RL::createRay>("Ray");
      extension.add<&RL::createRayHitInfo>("RayHitInfo");
      extension.add<&RL::createBoundingBox>("BoundingBox");
      // extension.add<&RL::createrAudioBuffer>("rAudioBuffer");
      extension.add<&RL::createSound>("Sound");
      extension.add<&RL::getColorLIGHTGRAY>("LIGHTGRAY");
      extension.add<&RL::getColorGRAY>("GRAY");
      extension.add<&RL::getColorDARKGRAY>("DARKGRAY");
      extension.add<&RL::getColorYELLOW>("YELLOW");
      extension.add<&RL::getColorGOLD>("GOLD");
      extension.add<&RL::getColorORANGE>("ORANGE");
      extension.add<&RL::getColorPINK>("PINK");
      extension.add<&RL::getColorRED>("RED");
      extension.add<&RL::getColorMAROON>("MAROON");
      extension.add<&RL::getColorGREEN>("GREEN");
      extension.add<&RL::getColorLIME>("LIME");
      extension.add<&RL::getColorDARKGREEN>("DARKGREEN");
      extension.add<&RL::getColorSKYBLUE>("SKYBLUE");
      extension.add<&RL::getColorBLUE>("BLUE");
      extension.add<&RL::getColorDARKBLUE>("DARKBLUE");
      extension.add<&RL::getColorPURPLE>("PURPLE");
      extension.add<&RL::getColorVIOLET>("VIOLET");
      extension.add<&RL::getColorDARKPURPLE>("DARKPURPLE");
      extension.add<&RL::getColorBEIGE>("BEIGE");
      extension.add<&RL::getColorBROWN>("BROWN");
      extension.add<&RL::getColorDARKBROWN>("DARKBROWN");
      extension.add<&RL::getColorWHITE>("WHITE");
      extension.add<&RL::getColorBLACK>("BLACK");
      extension.add<&RL::getColorBLANK>("BLANK");
      extension.add<&RL::getColorMAGENTA>("MAGENTA");
      extension.add<&RL::getColorRAYWHITE>("RAYWHITE");
      extension.add<&RL::Clamp>("Clamp");
      extension.add<&RL::Lerp>("Lerp");
      extension.add<&RL::Vector2Zero>("Vector2Zero");
      extension.add<&RL::Vector2One>("Vector2One");
      extension.add<&RL::Vector2Add>("Vector2Add");
      extension.add<&RL::Vector2Subtract>("Vector2Subtract");
      extension.add<&RL::Vector2Length>("Vector2Length");
      extension.add<&RL::Vector2DotProduct>("Vector2DotProduct");
      extension.add<&RL::Vector2Distance>("Vector2Distance");
      extension.add<&RL::Vector2Angle>("Vector2Angle");
      extension.add<&RL::Vector2Scale>("Vector2Scale");
      extension.add<&RL::Vector2Negate>("Vector2Negate");
      extension.add<&RL::Vector2Divide>("Vector2Divide");
      extension.add<&RL::Vector2Normalize>("Vector2Normalize");
      extension.add<&RL::Vector2Lerp>("Vector2Lerp");
      extension.add<&RL::Vector2Rotate>("Vector2Rotate");
      extension.add<&RL::Vector3Zero>("Vector3Zero");
      extension.add<&RL::Vector3One>("Vector3One");
      extension.add<&RL::Vector3Add>("Vector3Add");
      extension.add<&RL::Vector3Subtract>("Vector3Subtract");
      extension.add<&RL::Vector3Scale>("Vector3Scale");
      extension.add<&RL::Vector3Multiply>("Vector3Multiply");
      extension.add<&RL::Vector3CrossProduct>("Vector3CrossProduct");
      extension.add<&RL::Vector3Perpendicular>("Vector3Perpendicular");
      extension.add<&RL::Vector3Length>("Vector3Length");
      extension.add<&RL::Vector3DotProduct>("Vector3DotProduct");
      extension.add<&RL::Vector3Distance>("Vector3Distance");
      extension.add<&RL::Vector3Negate>("Vector3Negate");
      extension.add<&RL::Vector3Divide>("Vector3Divide");
      extension.add<&RL::Vector3Normalize>("Vector3Normalize");
      extension.add<&RL::Vector3OrthoNormalize>("Vector3OrthoNormalize");
      extension.add<&RL::Vector3Transform>("Vector3Transform");
      extension.add<&RL::Vector3RotateByQuaternion>("Vector3RotateByQuaternion");
      extension.add<&RL::Vector3Lerp>("Vector3Lerp");
      extension.add<&RL::Vector3Reflect>("Vector3Reflect");
      extension.add<&RL::Vector3Min>("Vector3Min");
      extension.add<&RL::Vector3Max>("Vector3Max");
      extension.add<&RL::Vector3Barycenter>("Vector3Barycenter");
      extension.add<&RL::Vector3ToFloatV>("Vector3ToFloatV");
      extension.add<&RL::MatrixDeterminant>("MatrixDeterminant");
      extension.add<&RL::MatrixTrace>("MatrixTrace");
      extension.add<&RL::MatrixTranspose>("MatrixTranspose");
      extension.add<&RL::MatrixInvert>("MatrixInvert");
      extension.add<&RL::MatrixNormalize>("MatrixNormalize");
      extension.add<&RL::MatrixIdentity>("MatrixIdentity");
      extension.add<&RL::MatrixAdd>("MatrixAdd");
      extension.add<&RL::MatrixSubtract>("MatrixSubtract");
      extension.add<&RL::MatrixTranslate>("MatrixTranslate");
      extension.add<&RL::MatrixRotate>("MatrixRotate");
      extension.add<&RL::MatrixRotateXYZ>("MatrixRotateXYZ");
      extension.add<&RL::MatrixRotateX>("MatrixRotateX");
      extension.add<&RL::MatrixRotateY>("MatrixRotateY");
      extension.add<&RL::MatrixRotateZ>("MatrixRotateZ");
      extension.add<&RL::MatrixScale>("MatrixScale");
      extension.add<&RL::MatrixMultiply>("MatrixMultiply");
      extension.add<&RL::MatrixFrustum>("MatrixFrustum");
      extension.add<&RL::MatrixPerspective>("MatrixPerspective");
      extension.add<&RL::MatrixOrtho>("MatrixOrtho");
      extension.add<&RL::MatrixLookAt>("MatrixLookAt");
      extension.add<&RL::MatrixToFloatV>("MatrixToFloatV");
      extension.add<&RL::QuaternionIdentity>("QuaternionIdentity");
      extension.add<&RL::QuaternionLength>("QuaternionLength");
      extension.add<&RL::QuaternionNormalize>("QuaternionNormalize");
      extension.add<&RL::QuaternionInvert>("QuaternionInvert");
      extension.add<&RL::QuaternionMultiply>("QuaternionMultiply");
      extension.add<&RL::QuaternionLerp>("QuaternionLerp");
      extension.add<&RL::QuaternionNlerp>("QuaternionNlerp");
      extension.add<&RL::QuaternionSlerp>("QuaternionSlerp");
      extension.add<&RL::QuaternionFromVector3ToVector3>(
          "QuaternionFromVector3ToVector3");
      extension.add<&RL::QuaternionFromMatrix>("QuaternionFromMatrix");
      extension.add<&RL::QuaternionToMatrix>("QuaternionToMatrix");
      extension.add<&RL::QuaternionFromAxisAngle>("QuaternionFromAxisAngle");
      extension.add<&RL::QuaternionToAxisAngle>("QuaternionToAxisAngle");
      extension.add<&RL::QuaternionFromEuler>("QuaternionFromEuler");
      extension.add<&RL::QuaternionToEuler>("QuaternionToEuler");
      extension.add<&RL::QuaternionTransform>("QuaternionTransform");
  
      extension.add(Php::Constant("RL_FLAG_RESERVED", 1));
      extension.add(Php::Constant("RL_FLAG_FULLSCREEN_MODE", 2));
      extension.add(Php::Constant("RL_FLAG_WINDOW_RESIZABLE", 4));
      extension.add(Php::Constant("RL_FLAG_WINDOW_UNDECORATED", 8));
      extension.add(Php::Constant("RL_FLAG_WINDOW_TRANSPARENT", 16));
      extension.add(Php::Constant("RL_FLAG_WINDOW_HIDDEN", 128));
      extension.add(Php::Constant("RL_FLAG_WINDOW_ALWAYS_RUN", 256));
      extension.add(Php::Constant("RL_FLAG_MSAA_4X_HINT", 32));
      extension.add(Php::Constant("RL_FLAG_VSYNC_HINT", 64));
      extension.add(Php::Constant("RL_LOG_ALL", 0));
      extension.add(Php::Constant("RL_LOG_TRACE", 1));
      extension.add(Php::Constant("RL_LOG_DEBUG", 2));
      extension.add(Php::Constant("RL_LOG_INFO", 3));
      extension.add(Php::Constant("RL_LOG_WARNING", 4));
      extension.add(Php::Constant("RL_LOG_ERROR", 5));
      extension.add(Php::Constant("RL_LOG_FATAL", 6));
      extension.add(Php::Constant("RL_LOG_NONE", 7));
      extension.add(Php::Constant("RL_KEY_APOSTROPHE", 39));
      extension.add(Php::Constant("RL_KEY_COMMA", 44));
      extension.add(Php::Constant("RL_KEY_MINUS", 45));
      extension.add(Php::Constant("RL_KEY_PERIOD", 46));
      extension.add(Php::Constant("RL_KEY_SLASH", 47));
      extension.add(Php::Constant("RL_KEY_ZERO", 48));
      extension.add(Php::Constant("RL_KEY_ONE", 49));
      extension.add(Php::Constant("RL_KEY_TWO", 50));
      extension.add(Php::Constant("RL_KEY_THREE", 51));
      extension.add(Php::Constant("RL_KEY_FOUR", 52));
      extension.add(Php::Constant("RL_KEY_FIVE", 53));
      extension.add(Php::Constant("RL_KEY_SIX", 54));
      extension.add(Php::Constant("RL_KEY_SEVEN", 55));
      extension.add(Php::Constant("RL_KEY_EIGHT", 56));
      extension.add(Php::Constant("RL_KEY_NINE", 57));
      extension.add(Php::Constant("RL_KEY_SEMICOLON", 59));
      extension.add(Php::Constant("RL_KEY_EQUAL", 61));
      extension.add(Php::Constant("RL_KEY_A", 65));
      extension.add(Php::Constant("RL_KEY_B", 66));
      extension.add(Php::Constant("RL_KEY_C", 67));
      extension.add(Php::Constant("RL_KEY_D", 68));
      extension.add(Php::Constant("RL_KEY_E", 69));
      extension.add(Php::Constant("RL_KEY_F", 70));
      extension.add(Php::Constant("RL_KEY_G", 71));
      extension.add(Php::Constant("RL_KEY_H", 72));
      extension.add(Php::Constant("RL_KEY_I", 73));
      extension.add(Php::Constant("RL_KEY_J", 74));
      extension.add(Php::Constant("RL_KEY_K", 75));
      extension.add(Php::Constant("RL_KEY_L", 76));
      extension.add(Php::Constant("RL_KEY_M", 77));
      extension.add(Php::Constant("RL_KEY_N", 78));
      extension.add(Php::Constant("RL_KEY_O", 79));
      extension.add(Php::Constant("RL_KEY_P", 80));
      extension.add(Php::Constant("RL_KEY_Q", 81));
      extension.add(Php::Constant("RL_KEY_R", 82));
      extension.add(Php::Constant("RL_KEY_S", 83));
      extension.add(Php::Constant("RL_KEY_T", 84));
      extension.add(Php::Constant("RL_KEY_U", 85));
      extension.add(Php::Constant("RL_KEY_V", 86));
      extension.add(Php::Constant("RL_KEY_W", 87));
      extension.add(Php::Constant("RL_KEY_X", 88));
      extension.add(Php::Constant("RL_KEY_Y", 89));
      extension.add(Php::Constant("RL_KEY_Z", 90));
      extension.add(Php::Constant("RL_KEY_SPACE", 32));
      extension.add(Php::Constant("RL_KEY_ESCAPE", 256));
      extension.add(Php::Constant("RL_KEY_ENTER", 257));
      extension.add(Php::Constant("RL_KEY_TAB", 258));
      extension.add(Php::Constant("RL_KEY_BACKSPACE", 259));
      extension.add(Php::Constant("RL_KEY_INSERT", 260));
      extension.add(Php::Constant("RL_KEY_DELETE", 261));
      extension.add(Php::Constant("RL_KEY_RIGHT", 262));
      extension.add(Php::Constant("RL_KEY_LEFT", 263));
      extension.add(Php::Constant("RL_KEY_DOWN", 264));
      extension.add(Php::Constant("RL_KEY_UP", 265));
      extension.add(Php::Constant("RL_KEY_PAGE_UP", 266));
      extension.add(Php::Constant("RL_KEY_PAGE_DOWN", 267));
      extension.add(Php::Constant("RL_KEY_HOME", 268));
      extension.add(Php::Constant("RL_KEY_END", 269));
      extension.add(Php::Constant("RL_KEY_CAPS_LOCK", 280));
      extension.add(Php::Constant("RL_KEY_SCROLL_LOCK", 281));
      extension.add(Php::Constant("RL_KEY_NUM_LOCK", 282));
      extension.add(Php::Constant("RL_KEY_PRINT_SCREEN", 283));
      extension.add(Php::Constant("RL_KEY_PAUSE", 284));
      extension.add(Php::Constant("RL_KEY_F1", 290));
      extension.add(Php::Constant("RL_KEY_F2", 291));
      extension.add(Php::Constant("RL_KEY_F3", 292));
      extension.add(Php::Constant("RL_KEY_F4", 293));
      extension.add(Php::Constant("RL_KEY_F5", 294));
      extension.add(Php::Constant("RL_KEY_F6", 295));
      extension.add(Php::Constant("RL_KEY_F7", 296));
      extension.add(Php::Constant("RL_KEY_F8", 297));
      extension.add(Php::Constant("RL_KEY_F9", 298));
      extension.add(Php::Constant("RL_KEY_F10", 299));
      extension.add(Php::Constant("RL_KEY_F11", 300));
      extension.add(Php::Constant("RL_KEY_F12", 301));
      extension.add(Php::Constant("RL_KEY_LEFT_SHIFT", 340));
      extension.add(Php::Constant("RL_KEY_LEFT_CONTROL", 341));
      extension.add(Php::Constant("RL_KEY_LEFT_ALT", 342));
      extension.add(Php::Constant("RL_KEY_LEFT_SUPER", 343));
      extension.add(Php::Constant("RL_KEY_RIGHT_SHIFT", 344));
      extension.add(Php::Constant("RL_KEY_RIGHT_CONTROL", 345));
      extension.add(Php::Constant("RL_KEY_RIGHT_ALT", 346));
      extension.add(Php::Constant("RL_KEY_RIGHT_SUPER", 347));
      extension.add(Php::Constant("RL_KEY_KB_MENU", 348));
      extension.add(Php::Constant("RL_KEY_LEFT_BRACKET", 91));
      extension.add(Php::Constant("RL_KEY_BACKSLASH", 92));
      extension.add(Php::Constant("RL_KEY_RIGHT_BRACKET", 93));
      extension.add(Php::Constant("RL_KEY_GRAVE", 96));
      extension.add(Php::Constant("RL_KEY_KP_0", 320));
      extension.add(Php::Constant("RL_KEY_KP_1", 321));
      extension.add(Php::Constant("RL_KEY_KP_2", 322));
      extension.add(Php::Constant("RL_KEY_KP_3", 323));
      extension.add(Php::Constant("RL_KEY_KP_4", 324));
      extension.add(Php::Constant("RL_KEY_KP_5", 325));
      extension.add(Php::Constant("RL_KEY_KP_6", 326));
      extension.add(Php::Constant("RL_KEY_KP_7", 327));
      extension.add(Php::Constant("RL_KEY_KP_8", 328));
      extension.add(Php::Constant("RL_KEY_KP_9", 329));
      extension.add(Php::Constant("RL_KEY_KP_DECIMAL", 330));
      extension.add(Php::Constant("RL_KEY_KP_DIVIDE", 331));
      extension.add(Php::Constant("RL_KEY_KP_MULTIPLY", 332));
      extension.add(Php::Constant("RL_KEY_KP_SUBTRACT", 333));
      extension.add(Php::Constant("RL_KEY_KP_ADD", 334));
      extension.add(Php::Constant("RL_KEY_KP_ENTER", 335));
      extension.add(Php::Constant("RL_KEY_KP_EQUAL", 336));
      extension.add(Php::Constant("RL_KEY_BACK", 4));
      extension.add(Php::Constant("RL_KEY_MENU", 82));
      extension.add(Php::Constant("RL_KEY_VOLUME_UP", 24));
      extension.add(Php::Constant("RL_KEY_VOLUME_DOWN", 25));
      extension.add(Php::Constant("RL_MOUSE_LEFT_BUTTON", 0));
      extension.add(Php::Constant("RL_MOUSE_RIGHT_BUTTON", 1));
      extension.add(Php::Constant("RL_MOUSE_MIDDLE_BUTTON", 2));
      extension.add(Php::Constant("RL_GAMEPAD_PLAYER1", 0));
      extension.add(Php::Constant("RL_GAMEPAD_PLAYER2", 1));
      extension.add(Php::Constant("RL_GAMEPAD_PLAYER3", 2));
      extension.add(Php::Constant("RL_GAMEPAD_PLAYER4", 3));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_UNKNOWN", 0));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_FACE_UP", 1));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_FACE_RIGHT", 2));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_FACE_DOWN", 3));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_FACE_LEFT", 4));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_FACE_UP", 5));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_FACE_RIGHT", 6));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_FACE_DOWN", 7));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_FACE_LEFT", 8));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_TRIGGER_1", 9));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_TRIGGER_2", 10));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_1", 11));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_2", 12));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_MIDDLE_LEFT", 13));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_MIDDLE", 14));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_MIDDLE_RIGHT", 15));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_LEFT_THUMB", 16));
      extension.add(Php::Constant("RL_GAMEPAD_BUTTON_RIGHT_THUMB", 17));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_UNKNOWN", 0));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_LEFT_X", 1));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_LEFT_Y", 2));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_RIGHT_X", 3));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_RIGHT_Y", 4));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_LEFT_TRIGGER", 5));
      extension.add(Php::Constant("RL_GAMEPAD_AXIS_RIGHT_TRIGGER", 6));
      extension.add(Php::Constant("RL_LOC_VERTEX_POSITION", 0));
      extension.add(Php::Constant("RL_LOC_VERTEX_TEXCOORD01", 1));
      extension.add(Php::Constant("RL_LOC_VERTEX_TEXCOORD02", 2));
      extension.add(Php::Constant("RL_LOC_VERTEX_NORMAL", 3));
      extension.add(Php::Constant("RL_LOC_VERTEX_TANGENT", 4));
      extension.add(Php::Constant("RL_LOC_VERTEX_COLOR", 5));
      extension.add(Php::Constant("RL_LOC_MATRIX_MVP", 6));
      extension.add(Php::Constant("RL_LOC_MATRIX_MODEL", 7));
      extension.add(Php::Constant("RL_LOC_MATRIX_VIEW", 8));
      extension.add(Php::Constant("RL_LOC_MATRIX_PROJECTION", 9));
      extension.add(Php::Constant("RL_LOC_VECTOR_VIEW", 10));
      extension.add(Php::Constant("RL_LOC_COLOR_DIFFUSE", 11));
      extension.add(Php::Constant("RL_LOC_COLOR_SPECULAR", 12));
      extension.add(Php::Constant("RL_LOC_COLOR_AMBIENT", 13));
      extension.add(Php::Constant("RL_LOC_MAP_ALBEDO", 14));
      extension.add(Php::Constant("RL_LOC_MAP_METALNESS", 15));
      extension.add(Php::Constant("RL_LOC_MAP_NORMAL", 16));
      extension.add(Php::Constant("RL_LOC_MAP_ROUGHNESS", 17));
      extension.add(Php::Constant("RL_LOC_MAP_OCCLUSION", 18));
      extension.add(Php::Constant("RL_LOC_MAP_EMISSION", 19));
      extension.add(Php::Constant("RL_LOC_MAP_HEIGHT", 20));
      extension.add(Php::Constant("RL_LOC_MAP_CUBEMAP", 21));
      extension.add(Php::Constant("RL_LOC_MAP_IRRADIANCE", 22));
      extension.add(Php::Constant("RL_LOC_MAP_PREFILTER", 23));
      extension.add(Php::Constant("RL_LOC_MAP_BRDF", 24));
      extension.add(Php::Constant("RL_UNIFORM_FLOAT", 0));
      extension.add(Php::Constant("RL_UNIFORM_VEC2", 1));
      extension.add(Php::Constant("RL_UNIFORM_VEC3", 2));
      extension.add(Php::Constant("RL_UNIFORM_VEC4", 3));
      extension.add(Php::Constant("RL_UNIFORM_INT", 4));
      extension.add(Php::Constant("RL_UNIFORM_IVEC2", 5));
      extension.add(Php::Constant("RL_UNIFORM_IVEC3", 6));
      extension.add(Php::Constant("RL_UNIFORM_IVEC4", 7));
      extension.add(Php::Constant("RL_UNIFORM_SAMPLER2D", 8));
      extension.add(Php::Constant("RL_MAP_ALBEDO", 0));
      extension.add(Php::Constant("RL_MAP_METALNESS", 1));
      extension.add(Php::Constant("RL_MAP_NORMAL", 2));
      extension.add(Php::Constant("RL_MAP_ROUGHNESS", 3));
      extension.add(Php::Constant("RL_MAP_OCCLUSION", 4));
      extension.add(Php::Constant("RL_MAP_EMISSION", 5));
      extension.add(Php::Constant("RL_MAP_HEIGHT", 6));
      extension.add(Php::Constant("RL_MAP_CUBEMAP", 7));
      extension.add(Php::Constant("RL_MAP_IRRADIANCE", 8));
      extension.add(Php::Constant("RL_MAP_PREFILTER", 9));
      extension.add(Php::Constant("RL_MAP_BRDF", 10));
      extension.add(Php::Constant("RL_UNCOMPRESSED_GRAYSCALE", 1));
      extension.add(Php::Constant("RL_UNCOMPRESSED_GRAY_ALPHA", 2));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R5G6B5", 3));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R8G8B8", 4));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R5G5B5A1", 5));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R4G4B4A4", 6));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R8G8B8A8", 7));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R32", 8));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R32G32B32", 9));
      extension.add(Php::Constant("RL_UNCOMPRESSED_R32G32B32A32", 10));
      extension.add(Php::Constant("RL_COMPRESSED_DXT1_RGB", 11));
      extension.add(Php::Constant("RL_COMPRESSED_DXT1_RGBA", 12));
      extension.add(Php::Constant("RL_COMPRESSED_DXT3_RGBA", 13));
      extension.add(Php::Constant("RL_COMPRESSED_DXT5_RGBA", 14));
      extension.add(Php::Constant("RL_COMPRESSED_ETC1_RGB", 15));
      extension.add(Php::Constant("RL_COMPRESSED_ETC2_RGB", 16));
      extension.add(Php::Constant("RL_COMPRESSED_ETC2_EAC_RGBA", 17));
      extension.add(Php::Constant("RL_COMPRESSED_PVRT_RGB", 18));
      extension.add(Php::Constant("RL_COMPRESSED_PVRT_RGBA", 19));
      extension.add(Php::Constant("RL_COMPRESSED_ASTC_4x4_RGBA", 20));
      extension.add(Php::Constant("RL_COMPRESSED_ASTC_8x8_RGBA", 21));
      extension.add(Php::Constant("RL_FILTER_POINT", 0));
      extension.add(Php::Constant("RL_FILTER_BILINEAR", 1));
      extension.add(Php::Constant("RL_FILTER_TRILINEAR", 2));
      extension.add(Php::Constant("RL_FILTER_ANISOTROPIC_4X", 3));
      extension.add(Php::Constant("RL_FILTER_ANISOTROPIC_8X", 4));
      extension.add(Php::Constant("RL_FILTER_ANISOTROPIC_16X", 5));
      extension.add(Php::Constant("RL_CUBEMAP_AUTO_DETECT", 0));
      extension.add(Php::Constant("RL_CUBEMAP_LINE_VERTICAL", 1));
      extension.add(Php::Constant("RL_CUBEMAP_LINE_HORIZONTAL", 2));
      extension.add(Php::Constant("RL_CUBEMAP_CROSS_THREE_BY_FOUR", 3));
      extension.add(Php::Constant("RL_CUBEMAP_CROSS_FOUR_BY_THREE", 4));
      extension.add(Php::Constant("RL_CUBEMAP_PANORAMA", 5));
      extension.add(Php::Constant("RL_WRAP_REPEAT", 0));
      extension.add(Php::Constant("RL_WRAP_CLAMP", 1));
      extension.add(Php::Constant("RL_WRAP_MIRROR_REPEAT", 2));
      extension.add(Php::Constant("RL_WRAP_MIRROR_CLAMP", 3));
      extension.add(Php::Constant("RL_FONT_DEFAULT", 0));
      extension.add(Php::Constant("RL_FONT_BITMAP", 1));
      extension.add(Php::Constant("RL_FONT_SDF", 2));
      extension.add(Php::Constant("RL_BLEND_ALPHA", 0));
      extension.add(Php::Constant("RL_BLEND_ADDITIVE", 1));
      extension.add(Php::Constant("RL_BLEND_MULTIPLIED", 2));
      extension.add(Php::Constant("RL_GESTURE_NONE", 0));
      extension.add(Php::Constant("RL_GESTURE_TAP", 1));
      extension.add(Php::Constant("RL_GESTURE_DOUBLETAP", 2));
      extension.add(Php::Constant("RL_GESTURE_HOLD", 4));
      extension.add(Php::Constant("RL_GESTURE_DRAG", 8));
      extension.add(Php::Constant("RL_GESTURE_SWIPE_RIGHT", 16));
      extension.add(Php::Constant("RL_GESTURE_SWIPE_LEFT", 32));
      extension.add(Php::Constant("RL_GESTURE_SWIPE_UP", 64));
      extension.add(Php::Constant("RL_GESTURE_SWIPE_DOWN", 128));
      extension.add(Php::Constant("RL_GESTURE_PINCH_IN", 256));
      extension.add(Php::Constant("RL_GESTURE_PINCH_OUT", 512));
      extension.add(Php::Constant("RL_CAMERA_CUSTOM", 0));
      extension.add(Php::Constant("RL_CAMERA_FREE", 1));
      extension.add(Php::Constant("RL_CAMERA_ORBITAL", 2));
      extension.add(Php::Constant("RL_CAMERA_FIRST_PERSON", 3));
      extension.add(Php::Constant("RL_CAMERA_THIRD_PERSON", 4));
      extension.add(Php::Constant("RL_CAMERA_PERSPECTIVE", 0));
      extension.add(Php::Constant("RL_CAMERA_ORTHOGRAPHIC", 1));
      extension.add(Php::Constant("RL_NPT_9PATCH", 0));
      extension.add(Php::Constant("RL_NPT_3PATCH_VERTICAL", 1));
      extension.add(Php::Constant("RL_NPT_3PATCH_HORIZONTAL", 2));
  
      Php::Class<rlPhysicsBody> rlPhysicsBody("PhysicsBody");
      rlNamespace.add(rlPhysicsBody);
      rlPhysicsBody.property("id", &rlPhysicsBody::getid, &rlPhysicsBody::setid);
      rlPhysicsBody.property("enabled", &rlPhysicsBody::getenabled,
                             &rlPhysicsBody::setenabled);
      rlPhysicsBody.property("position", &rlPhysicsBody::getposition,
                             &rlPhysicsBody::setposition);
      rlPhysicsBody.property("velocity", &rlPhysicsBody::getvelocity,
                             &rlPhysicsBody::setvelocity);
      rlPhysicsBody.property("force", &rlPhysicsBody::getforce,
                             &rlPhysicsBody::setforce);
      rlPhysicsBody.property("angularVelocity",
                             &rlPhysicsBody::getangularVelocity,
                             &rlPhysicsBody::setangularVelocity);
      rlPhysicsBody.property("torque", &rlPhysicsBody::gettorque,
                             &rlPhysicsBody::settorque);
      rlPhysicsBody.property("orient", &rlPhysicsBody::getorient,
                             &rlPhysicsBody::setorient);
      rlPhysicsBody.property("inertia", &rlPhysicsBody::getinertia,
                             &rlPhysicsBody::setinertia);
      rlPhysicsBody.property("inverseInertia", &rlPhysicsBody::getinverseInertia,
                             &rlPhysicsBody::setinverseInertia);
      rlPhysicsBody.property("mass", &rlPhysicsBody::getmass,
                             &rlPhysicsBody::setmass);
      rlPhysicsBody.property("inverseMass", &rlPhysicsBody::getinverseMass,
                             &rlPhysicsBody::setinverseMass);
      rlPhysicsBody.property("staticFriction", &rlPhysicsBody::getstaticFriction,
                             &rlPhysicsBody::setstaticFriction);
      rlPhysicsBody.property("dynamicFriction",
                             &rlPhysicsBody::getdynamicFriction,
                             &rlPhysicsBody::setdynamicFriction);
      rlPhysicsBody.property("restitution", &rlPhysicsBody::getrestitution,
                             &rlPhysicsBody::setrestitution);
      rlPhysicsBody.property("useGravity", &rlPhysicsBody::getuseGravity,
                             &rlPhysicsBody::setuseGravity);
      rlPhysicsBody.property("isGrounded", &rlPhysicsBody::getisGrounded,
                             &rlPhysicsBody::setisGrounded);
      rlPhysicsBody.property("freezeOrient", &rlPhysicsBody::getfreezeOrient,
                             &rlPhysicsBody::setfreezeOrient);
      //  rlPhysicsBody.property("shape", &rlPhysicsBody::getshape,
      //                           &rlPhysicsBody::setshape);
  
      extension.add<&RL::InitPhysics>("InitPhysics");
      extension.add<&RL::RunPhysicsStep>("RunPhysicsStep");
      extension.add<&RL::SetPhysicsTimeStep>("SetPhysicsTimeStep");
      extension.add<&RL::IsPhysicsEnabled>("IsPhysicsEnabled");
      extension.add<&RL::SetPhysicsGravity>("SetPhysicsGravity");
      extension.add<&RL::CreatePhysicsBodyCircle>("CreatePhysicsBodyCircle");
      extension.add<&RL::CreatePhysicsBodyRectangle>(
          "CreatePhysicsBodyRectangle");
      extension.add<&RL::CreatePhysicsBodyPolygon>("CreatePhysicsBodyPolygon");
      extension.add<&RL::PhysicsAddForce>("PhysicsAddForce");
      extension.add<&RL::PhysicsAddTorque>("PhysicsAddTorque");
      extension.add<&RL::PhysicsShatter>("PhysicsShatter");
      extension.add<&RL::GetPhysicsBodiesCount>("GetPhysicsBodiesCount");
      extension.add<&RL::GetPhysicsBody>("GetPhysicsBody");
      extension.add<&RL::GetPhysicsShapeType>("GetPhysicsShapeType");
      extension.add<&RL::GetPhysicsShapeVerticesCount>(
          "GetPhysicsShapeVerticesCount");
      extension.add<&RL::GetPhysicsShapeVertex>("GetPhysicsShapeVertex");
      extension.add<&RL::SetPhysicsBodyRotation>("SetPhysicsBodyRotation");
      extension.add<&RL::DestroyPhysicsBody>("DestroyPhysicsBody");
      extension.add<&RL::ResetPhysics>("ResetPhysics");
      extension.add<&RL::ClosePhysics>("ClosePhysics");
  
      extension.add(Php::Constant("RL_PHYSICS_CIRCLE", 0));
      extension.add(Php::Constant("RL_PHYSICS_POLYGON", 1));
      extension.add(Php::Constant("RL_PHYSAC_PI", 3.14159265358979323846));
      extension.add(
          Php::Constant("RL_PHYSAC_DEG2RAD", 3.14159265358979323846 / 180));
  
      extension.add<&RL::CreateLight>("CreateLight");
      extension.add<&RL::UpdateLightValues>("UpdateLightValues");
      rlNamespace.add(rlClass);
  
      extension.add(Php::Constant("RL_LIGHT_DIRECTIONAL", 0));
      extension.add(Php::Constant("RL_LIGHT_POINT", 1));
      Php::Class<Light> rlLight("Light");
      rlNamespace.add(rlLight);
      rlLight.property("type", &Light::gettype, &Light::settype);
      rlLight.property("position", &Light::getposition, &Light::setposition);
      rlLight.property("target", &Light::gettarget, &Light::settarget);
      rlLight.property("color", &Light::getcolor, &Light::setcolor);
      rlLight.property("enabled", &Light::getenabled, &Light::setenabled);
      rlLight.property("enabledLoc", &Light::getenabledLoc,
                       &Light::setenabledLoc);
      rlLight.property("typeLoc", &Light::gettypeLoc, &Light::settypeLoc);
      rlLight.property("posLoc", &Light::getposLoc, &Light::setposLoc);
      rlLight.property("targetLoc", &Light::gettargetLoc, &Light::settargetLoc);
      rlLight.property("colorLoc", &Light::getcolorLoc, &Light::setcolorLoc);
  
      // add everything to extension
      extension.add(rlNamespace);
  
      // return the module entry
      return extension.module();
  }
  }
  
  } // namespace rl
  