text: // For conditions of distribution and use, see copyright notice in LICENSE
  // This file has been autogenerated with BindingsGenerator
  
  #include "StableHeaders.h"
  #include "CoreTypes.h"
  #include "JavaScriptInstance.h"
  #include "LoggingFunctions.h"
  #include "Math/float3x3.h"
  
  #ifdef _MSC_VER
  #pragma warning(disable: 4800)
  #endif
  
  #include "Math/float3.h"
  #include "Math/Quat.h"
  #include "Math/float4.h"
  #include "Math/float3x4.h"
  #include "Math/float4x4.h"
  #include "Algorithm/Random/LCG.h"
  #include "Geometry/Plane.h"
  
  using namespace std;
  
  namespace JSBindings
  {
  
  static const char* float3_ID = "float3";
  static const char* Quat_ID = "Quat";
  static const char* float4_ID = "float4";
  static const char* float3x4_ID = "float3x4";
  static const char* float4x4_ID = "float4x4";
  static const char* LCG_ID = "LCG";
  static const char* Plane_ID = "Plane";
  
  static duk_ret_t Quat_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<Quat>(ctx, Quat_ID);
      return 0;
  }
  
  static duk_ret_t float3_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<float3>(ctx, float3_ID);
      return 0;
  }
  
  static duk_ret_t float4_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<float4>(ctx, float4_ID);
      return 0;
  }
  
  static duk_ret_t float3x4_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<float3x4>(ctx, float3x4_ID);
      return 0;
  }
  
  static duk_ret_t float4x4_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<float4x4>(ctx, float4x4_ID);
      return 0;
  }
  
  
  static const char* float3x3_ID = "float3x3";
  
  static duk_ret_t float3x3_Finalizer(duk_context* ctx)
  {
      FinalizeValueObject<float3x3>(ctx, float3x3_ID);
      return 0;
  }
  
  static duk_ret_t float3x3_Ctor(duk_context* ctx)
  {
      float3x3* newObj = new float3x3();
      PushConstructorResult<float3x3>(ctx, newObj, float3x3_ID, float3x3_Finalizer);
      return 0;
  }
  
  static duk_ret_t float3x3_Ctor_float3x3(duk_context* ctx)
  {
      float3x3& rhs = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      float3x3* newObj = new float3x3(rhs);
      PushConstructorResult<float3x3>(ctx, newObj, float3x3_ID, float3x3_Finalizer);
      return 0;
  }
  
  static duk_ret_t float3x3_Ctor_float_float_float_float_float_float_float_float_float(duk_context* ctx)
  {
      float _00 = (float)duk_require_number(ctx, 0);
      float _01 = (float)duk_require_number(ctx, 1);
      float _02 = (float)duk_require_number(ctx, 2);
      float _10 = (float)duk_require_number(ctx, 3);
      float _11 = (float)duk_require_number(ctx, 4);
      float _12 = (float)duk_require_number(ctx, 5);
      float _20 = (float)duk_require_number(ctx, 6);
      float _21 = (float)duk_require_number(ctx, 7);
      float _22 = (float)duk_require_number(ctx, 8);
      float3x3* newObj = new float3x3(_00, _01, _02, _10, _11, _12, _20, _21, _22);
      PushConstructorResult<float3x3>(ctx, newObj, float3x3_ID, float3x3_Finalizer);
      return 0;
  }
  
  static duk_ret_t float3x3_Ctor_float3_float3_float3(duk_context* ctx)
  {
      float3& col0 = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3& col1 = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      float3& col2 = *GetCheckedValueObject<float3>(ctx, 2, float3_ID);
      float3x3* newObj = new float3x3(col0, col1, col2);
      PushConstructorResult<float3x3>(ctx, newObj, float3x3_ID, float3x3_Finalizer);
      return 0;
  }
  
  static duk_ret_t float3x3_Ctor_Quat(duk_context* ctx)
  {
      Quat& orientation = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      float3x3* newObj = new float3x3(orientation);
      PushConstructorResult<float3x3>(ctx, newObj, float3x3_ID, float3x3_Finalizer);
      return 0;
  }
  
  static duk_ret_t float3x3_ToQuat(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      Quat ret = thisObj->ToQuat();
      PushValueObjectCopy<Quat>(ctx, ret, Quat_ID, Quat_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_GetScale(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->GetScale();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_At_int_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      int col = (int)duk_require_number(ctx, 1);
       float ret = thisObj->At(row, col);
      duk_push_number(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Row_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      const float3 & ret = thisObj->Row(row);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Row3_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      float3 & ret = thisObj->Row3(row);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Col_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int col = (int)duk_require_number(ctx, 0);
      float3 ret = thisObj->Col(col);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Col3_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int col = (int)duk_require_number(ctx, 0);
      float3 ret = thisObj->Col3(col);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Diagonal(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->Diagonal();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ScaleRow_int_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      float scalar = (float)duk_require_number(ctx, 1);
      thisObj->ScaleRow(row, scalar);
      return 0;
  }
  
  static duk_ret_t float3x3_ScaleCol_int_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int col = (int)duk_require_number(ctx, 0);
      float scalar = (float)duk_require_number(ctx, 1);
      thisObj->ScaleCol(col, scalar);
      return 0;
  }
  
  static duk_ret_t float3x3_WorldX(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->WorldX();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_WorldY(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->WorldY();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_WorldZ(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->WorldZ();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_SetRow_int_float_float_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      float x = (float)duk_require_number(ctx, 1);
      float y = (float)duk_require_number(ctx, 2);
      float z = (float)duk_require_number(ctx, 3);
      thisObj->SetRow(row, x, y, z);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRow_int_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      float3& rowVector = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      thisObj->SetRow(row, rowVector);
      return 0;
  }
  
  static duk_ret_t float3x3_SetCol_int_float_float_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int column = (int)duk_require_number(ctx, 0);
      float x = (float)duk_require_number(ctx, 1);
      float y = (float)duk_require_number(ctx, 2);
      float z = (float)duk_require_number(ctx, 3);
      thisObj->SetCol(column, x, y, z);
      return 0;
  }
  
  static duk_ret_t float3x3_SetCol_int_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int column = (int)duk_require_number(ctx, 0);
      float3& columnVector = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      thisObj->SetCol(column, columnVector);
      return 0;
  }
  
  static duk_ret_t float3x3_Set_float_float_float_float_float_float_float_float_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float _00 = (float)duk_require_number(ctx, 0);
      float _01 = (float)duk_require_number(ctx, 1);
      float _02 = (float)duk_require_number(ctx, 2);
      float _10 = (float)duk_require_number(ctx, 3);
      float _11 = (float)duk_require_number(ctx, 4);
      float _12 = (float)duk_require_number(ctx, 5);
      float _20 = (float)duk_require_number(ctx, 6);
      float _21 = (float)duk_require_number(ctx, 7);
      float _22 = (float)duk_require_number(ctx, 8);
      thisObj->Set(_00, _01, _02, _10, _11, _12, _20, _21, _22);
      return 0;
  }
  
  static duk_ret_t float3x3_Set_float3x3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3& rhs = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      thisObj->Set(rhs);
      return 0;
  }
  
  static duk_ret_t float3x3_Set_int_int_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row = (int)duk_require_number(ctx, 0);
      int col = (int)duk_require_number(ctx, 1);
      float value = (float)duk_require_number(ctx, 2);
      thisObj->Set(row, col, value);
      return 0;
  }
  
  static duk_ret_t float3x3_SetIdentity(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      thisObj->SetIdentity();
      return 0;
  }
  
  static duk_ret_t float3x3_SwapColumns_int_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int col1 = (int)duk_require_number(ctx, 0);
      int col2 = (int)duk_require_number(ctx, 1);
      thisObj->SwapColumns(col1, col2);
      return 0;
  }
  
  static duk_ret_t float3x3_SwapRows_int_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int row1 = (int)duk_require_number(ctx, 0);
      int row2 = (int)duk_require_number(ctx, 1);
      thisObj->SwapRows(row1, row2);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRotatePartX_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float angleRadians = (float)duk_require_number(ctx, 0);
      thisObj->SetRotatePartX(angleRadians);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRotatePartY_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float angleRadians = (float)duk_require_number(ctx, 0);
      thisObj->SetRotatePartY(angleRadians);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRotatePartZ_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float angleRadians = (float)duk_require_number(ctx, 0);
      thisObj->SetRotatePartZ(angleRadians);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRotatePart_float3_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& axisDirection = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float angleRadians = (float)duk_require_number(ctx, 1);
      thisObj->SetRotatePart(axisDirection, angleRadians);
      return 0;
  }
  
  static duk_ret_t float3x3_SetRotatePart_Quat(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      Quat& orientation = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      thisObj->SetRotatePart(orientation);
      return 0;
  }
  
  static duk_ret_t float3x3_Determinant(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float ret = thisObj->Determinant();
      duk_push_number(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_DeterminantSymmetric(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float ret = thisObj->DeterminantSymmetric();
      duk_push_number(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Inverse_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-6f;
      bool ret = thisObj->Inverse(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseFast_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-6f;
      bool ret = thisObj->InverseFast(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_SolveAxb_float3_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& b = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3& x = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      bool ret = thisObj->SolveAxb(b, x);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Inverted(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3 ret = thisObj->Inverted();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseColOrthogonal(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->InverseColOrthogonal();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseOrthogonalUniformScale(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->InverseOrthogonalUniformScale();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseOrthonormal(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      thisObj->InverseOrthonormal();
      return 0;
  }
  
  static duk_ret_t float3x3_InverseSymmetric(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->InverseSymmetric();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Transpose(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      thisObj->Transpose();
      return 0;
  }
  
  static duk_ret_t float3x3_Transposed(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3 ret = thisObj->Transposed();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseTranspose(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->InverseTranspose();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_InverseTransposed(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3 ret = thisObj->InverseTransposed();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Trace(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float ret = thisObj->Trace();
      duk_push_number(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Orthonormalize_int_int_int(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      int firstColumn = (int)duk_require_number(ctx, 0);
      int secondColumn = (int)duk_require_number(ctx, 1);
      int thirdColumn = (int)duk_require_number(ctx, 2);
      thisObj->Orthonormalize(firstColumn, secondColumn, thirdColumn);
      return 0;
  }
  
  static duk_ret_t float3x3_RemoveScale(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      thisObj->RemoveScale();
      return 0;
  }
  
  static duk_ret_t float3x3_Transform_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& vector = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3 ret = thisObj->Transform(vector);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Transform_float_float_float(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float x = (float)duk_require_number(ctx, 0);
      float y = (float)duk_require_number(ctx, 1);
      float z = (float)duk_require_number(ctx, 2);
      float3 ret = thisObj->Transform(x, y, z);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_TransformLeft_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& lhs = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3 ret = thisObj->TransformLeft(lhs);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Transform_float4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float4& vector = *GetCheckedValueObject<float4>(ctx, 0, float4_ID);
      float4 ret = thisObj->Transform(vector);
      PushValueObjectCopy<float4>(ctx, ret, float4_ID, float4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_IsFinite(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->IsFinite();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsIdentity_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsIdentity(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsLowerTriangular_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsLowerTriangular(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsUpperTriangular_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsUpperTriangular(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsInvertible_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsInvertible(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsSymmetric_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsSymmetric(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsSkewSymmetric_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsSkewSymmetric(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_HasUnitaryScale_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilonSq = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-6f;
      bool ret = thisObj->HasUnitaryScale(epsilonSq);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_HasNegativeScale(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      bool ret = thisObj->HasNegativeScale();
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_HasUniformScale_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->HasUniformScale(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsRowOrthogonal_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsRowOrthogonal(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsColOrthogonal_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsColOrthogonal(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsColOrthogonal3_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsColOrthogonal3(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_IsOrthonormal_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float epsilon = numArgs > 0 ? (float)duk_require_number(ctx, 0) : 1e-3f;
      bool ret = thisObj->IsOrthonormal(epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_Equals_float3x3_float(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3& other = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      float epsilon = numArgs > 1 ? (float)duk_require_number(ctx, 1) : 1e-3f;
      bool ret = thisObj->Equals(other, epsilon);
      duk_push_boolean(ctx, ret);
      return 1;
  }
  
  static duk_ret_t float3x3_ToString(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      string ret = thisObj->ToString();
      duk_push_string(ctx, ret.c_str());
      return 1;
  }
  
  static duk_ret_t float3x3_SerializeToString(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      string ret = thisObj->SerializeToString();
      duk_push_string(ctx, ret.c_str());
      return 1;
  }
  
  static duk_ret_t float3x3_ToString2(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      string ret = thisObj->ToString2();
      duk_push_string(ctx, ret.c_str());
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerXYX(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerXYX();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerXZX(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerXZX();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerYXY(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerYXY();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerYZY(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerYZY();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerZXZ(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerZXZ();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerZYZ(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerZYZ();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerXYZ(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerXYZ();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerXZY(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerXZY();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerYXZ(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerYXZ();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerYZX(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerYZX();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerZXY(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerZXY();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ToEulerZYX(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ToEulerZYX();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ExtractScale(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3 ret = thisObj->ExtractScale();
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Decompose_Quat_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      Quat& rotate = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      float3& scale = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      thisObj->Decompose(rotate, scale);
      return 0;
  }
  
  static duk_ret_t float3x3_Decompose_float3x3_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3& rotate = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      float3& scale = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      thisObj->Decompose(rotate, scale);
      return 0;
  }
  
  static duk_ret_t float3x3_Mul_float3x3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x3& rhs = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      float3x3 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mul_float3x4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3x4& rhs = *GetCheckedValueObject<float3x4>(ctx, 0, float3x4_ID);
      float3x4 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float3x4>(ctx, ret, float3x4_ID, float3x4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mul_float4x4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float4x4& rhs = *GetCheckedValueObject<float4x4>(ctx, 0, float4x4_ID);
      float4x4 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float4x4>(ctx, ret, float4x4_ID, float4x4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mul_Quat(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      Quat& rhs = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      float3x3 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mul_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& rhs = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mul_float4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float4& rhs = *GetCheckedValueObject<float4>(ctx, 0, float4_ID);
      float4 ret = thisObj->Mul(rhs);
      PushValueObjectCopy<float4>(ctx, ret, float4_ID, float4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_MulPos_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& rhs = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3 ret = thisObj->MulPos(rhs);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_MulPos_float4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float4& rhs = *GetCheckedValueObject<float4>(ctx, 0, float4_ID);
      float4 ret = thisObj->MulPos(rhs);
      PushValueObjectCopy<float4>(ctx, ret, float4_ID, float4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_MulDir_float3(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float3& rhs = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3 ret = thisObj->MulDir(rhs);
      PushValueObjectCopy<float3>(ctx, ret, float3_ID, float3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_MulDir_float4(duk_context* ctx)
  {
      float3x3* thisObj = GetThisValueObject<float3x3>(ctx, float3x3_ID);
      float4& rhs = *GetCheckedValueObject<float4>(ctx, 0, float4_ID);
      float4 ret = thisObj->MulDir(rhs);
      PushValueObjectCopy<float4>(ctx, ret, float4_ID, float4_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Ctor_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 9 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2) && duk_is_number(ctx, 3) && duk_is_number(ctx, 4) && duk_is_number(ctx, 5) && duk_is_number(ctx, 6) && duk_is_number(ctx, 7) && duk_is_number(ctx, 8))
          return float3x3_Ctor_float_float_float_float_float_float_float_float_float(ctx);
      if (numArgs == 3 && GetValueObject<float3>(ctx, 0, float3_ID) && GetValueObject<float3>(ctx, 1, float3_ID) && GetValueObject<float3>(ctx, 2, float3_ID))
          return float3x3_Ctor_float3_float3_float3(ctx);
      if (numArgs == 1 && GetValueObject<Quat>(ctx, 0, Quat_ID))
          return float3x3_Ctor_Quat(ctx);
      if (numArgs == 1 && GetValueObject<float3x3>(ctx, 0, float3x3_ID))
          return float3x3_Ctor_float3x3(ctx);
      if (numArgs == 0)
          return float3x3_Ctor(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_SetRow_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 4 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2) && duk_is_number(ctx, 3))
          return float3x3_SetRow_int_float_float_float(ctx);
      if (numArgs == 2 && duk_is_number(ctx, 0) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_SetRow_int_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_SetCol_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 4 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2) && duk_is_number(ctx, 3))
          return float3x3_SetCol_int_float_float_float(ctx);
      if (numArgs == 2 && duk_is_number(ctx, 0) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_SetCol_int_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_Set_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 9 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2) && duk_is_number(ctx, 3) && duk_is_number(ctx, 4) && duk_is_number(ctx, 5) && duk_is_number(ctx, 6) && duk_is_number(ctx, 7) && duk_is_number(ctx, 8))
          return float3x3_Set_float_float_float_float_float_float_float_float_float(ctx);
      if (numArgs == 3 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
          return float3x3_Set_int_int_float(ctx);
      if (numArgs == 1 && GetValueObject<float3x3>(ctx, 0, float3x3_ID))
          return float3x3_Set_float3x3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_SetRotatePart_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 2 && GetValueObject<float3>(ctx, 0, float3_ID) && duk_is_number(ctx, 1))
          return float3x3_SetRotatePart_float3_float(ctx);
      if (numArgs == 1 && GetValueObject<Quat>(ctx, 0, Quat_ID))
          return float3x3_SetRotatePart_Quat(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_Transform_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 3 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
          return float3x3_Transform_float_float_float(ctx);
      if (numArgs == 1 && GetValueObject<float4>(ctx, 0, float4_ID))
          return float3x3_Transform_float4(ctx);
      if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
          return float3x3_Transform_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_Decompose_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 2 && GetValueObject<float3x3>(ctx, 0, float3x3_ID) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_Decompose_float3x3_float3(ctx);
      if (numArgs == 2 && GetValueObject<Quat>(ctx, 0, Quat_ID) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_Decompose_Quat_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_Mul_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 1 && GetValueObject<Quat>(ctx, 0, Quat_ID))
          return float3x3_Mul_Quat(ctx);
      if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
          return float3x3_Mul_float3(ctx);
      if (numArgs == 1 && GetValueObject<float4>(ctx, 0, float4_ID))
          return float3x3_Mul_float4(ctx);
      if (numArgs == 1 && GetValueObject<float3x3>(ctx, 0, float3x3_ID))
          return float3x3_Mul_float3x3(ctx);
      if (numArgs == 1 && GetValueObject<float3x4>(ctx, 0, float3x4_ID))
          return float3x3_Mul_float3x4(ctx);
      if (numArgs == 1 && GetValueObject<float4x4>(ctx, 0, float4x4_ID))
          return float3x3_Mul_float4x4(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_MulPos_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 1 && GetValueObject<float4>(ctx, 0, float4_ID))
          return float3x3_MulPos_float4(ctx);
      if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
          return float3x3_MulPos_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_MulDir_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 1 && GetValueObject<float4>(ctx, 0, float4_ID))
          return float3x3_MulDir_float4(ctx);
      if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
          return float3x3_MulDir_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static duk_ret_t float3x3_RotateX_Static_float(duk_context* ctx)
  {
      float angleRadians = (float)duk_require_number(ctx, 0);
      float3x3 ret = float3x3::RotateX(angleRadians);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RotateY_Static_float(duk_context* ctx)
  {
      float angleRadians = (float)duk_require_number(ctx, 0);
      float3x3 ret = float3x3::RotateY(angleRadians);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RotateZ_Static_float(duk_context* ctx)
  {
      float angleRadians = (float)duk_require_number(ctx, 0);
      float3x3 ret = float3x3::RotateZ(angleRadians);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RotateAxisAngle_Static_float3_float(duk_context* ctx)
  {
      float3& axisDirection = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float angleRadians = (float)duk_require_number(ctx, 1);
      float3x3 ret = float3x3::RotateAxisAngle(axisDirection, angleRadians);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RotateFromTo_Static_float3_float3(duk_context* ctx)
  {
      float3& sourceDirection = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3& targetDirection = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      float3x3 ret = float3x3::RotateFromTo(sourceDirection, targetDirection);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_LookAt_Static_float3_float3_float3_float3(duk_context* ctx)
  {
      float3& localForward = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float3& targetDirection = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      float3& localUp = *GetCheckedValueObject<float3>(ctx, 2, float3_ID);
      float3& worldUp = *GetCheckedValueObject<float3>(ctx, 3, float3_ID);
      float3x3 ret = float3x3::LookAt(localForward, targetDirection, localUp, worldUp);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RandomRotation_Static_LCG(duk_context* ctx)
  {
      LCG& lcg = *GetCheckedValueObject<LCG>(ctx, 0, LCG_ID);
      float3x3 ret = float3x3::RandomRotation(lcg);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_RandomGeneral_Static_LCG_float_float(duk_context* ctx)
  {
      LCG& lcg = *GetCheckedValueObject<LCG>(ctx, 0, LCG_ID);
      float minElem = (float)duk_require_number(ctx, 1);
      float maxElem = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::RandomGeneral(lcg, minElem, maxElem);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromQuat_Static_Quat(duk_context* ctx)
  {
      Quat& orientation = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      float3x3 ret = float3x3::FromQuat(orientation);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromRS_Static_Quat_float3(duk_context* ctx)
  {
      Quat& rotate = *GetCheckedValueObject<Quat>(ctx, 0, Quat_ID);
      float3& scale = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      float3x3 ret = float3x3::FromRS(rotate, scale);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromRS_Static_float3x3_float3(duk_context* ctx)
  {
      float3x3& rotate = *GetCheckedValueObject<float3x3>(ctx, 0, float3x3_ID);
      float3& scale = *GetCheckedValueObject<float3>(ctx, 1, float3_ID);
      float3x3 ret = float3x3::FromRS(rotate, scale);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerXYX_Static_float_float_float(duk_context* ctx)
  {
      float ex = (float)duk_require_number(ctx, 0);
      float ey = (float)duk_require_number(ctx, 1);
      float ex2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerXYX(ex, ey, ex2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerXZX_Static_float_float_float(duk_context* ctx)
  {
      float ex = (float)duk_require_number(ctx, 0);
      float ez = (float)duk_require_number(ctx, 1);
      float ex2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerXZX(ex, ez, ex2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerYXY_Static_float_float_float(duk_context* ctx)
  {
      float ey = (float)duk_require_number(ctx, 0);
      float ex = (float)duk_require_number(ctx, 1);
      float ey2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerYXY(ey, ex, ey2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerYZY_Static_float_float_float(duk_context* ctx)
  {
      float ey = (float)duk_require_number(ctx, 0);
      float ez = (float)duk_require_number(ctx, 1);
      float ey2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerYZY(ey, ez, ey2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerZXZ_Static_float_float_float(duk_context* ctx)
  {
      float ez = (float)duk_require_number(ctx, 0);
      float ex = (float)duk_require_number(ctx, 1);
      float ez2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerZXZ(ez, ex, ez2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerZYZ_Static_float_float_float(duk_context* ctx)
  {
      float ez = (float)duk_require_number(ctx, 0);
      float ey = (float)duk_require_number(ctx, 1);
      float ez2 = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerZYZ(ez, ey, ez2);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerXYZ_Static_float_float_float(duk_context* ctx)
  {
      float ex = (float)duk_require_number(ctx, 0);
      float ey = (float)duk_require_number(ctx, 1);
      float ez = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerXYZ(ex, ey, ez);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerXZY_Static_float_float_float(duk_context* ctx)
  {
      float ex = (float)duk_require_number(ctx, 0);
      float ez = (float)duk_require_number(ctx, 1);
      float ey = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerXZY(ex, ez, ey);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerYXZ_Static_float_float_float(duk_context* ctx)
  {
      float ey = (float)duk_require_number(ctx, 0);
      float ex = (float)duk_require_number(ctx, 1);
      float ez = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerYXZ(ey, ex, ez);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerYZX_Static_float_float_float(duk_context* ctx)
  {
      float ey = (float)duk_require_number(ctx, 0);
      float ez = (float)duk_require_number(ctx, 1);
      float ex = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerYZX(ey, ez, ex);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerZXY_Static_float_float_float(duk_context* ctx)
  {
      float ez = (float)duk_require_number(ctx, 0);
      float ex = (float)duk_require_number(ctx, 1);
      float ey = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerZXY(ez, ex, ey);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromEulerZYX_Static_float_float_float(duk_context* ctx)
  {
      float ez = (float)duk_require_number(ctx, 0);
      float ey = (float)duk_require_number(ctx, 1);
      float ex = (float)duk_require_number(ctx, 2);
      float3x3 ret = float3x3::FromEulerZYX(ez, ey, ex);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ScaleAlongAxis_Static_float3_float(duk_context* ctx)
  {
      float3& axis = *GetCheckedValueObject<float3>(ctx, 0, float3_ID);
      float scalingFactor = (float)duk_require_number(ctx, 1);
      float3x3 ret = float3x3::ScaleAlongAxis(axis, scalingFactor);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ShearX_Static_float_float(duk_context* ctx)
  {
      float yFactor = (float)duk_require_number(ctx, 0);
      float zFactor = (float)duk_require_number(ctx, 1);
      float3x3 ret = float3x3::ShearX(yFactor, zFactor);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ShearY_Static_float_float(duk_context* ctx)
  {
      float xFactor = (float)duk_require_number(ctx, 0);
      float zFactor = (float)duk_require_number(ctx, 1);
      float3x3 ret = float3x3::ShearY(xFactor, zFactor);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_ShearZ_Static_float_float(duk_context* ctx)
  {
      float xFactor = (float)duk_require_number(ctx, 0);
      float yFactor = (float)duk_require_number(ctx, 1);
      float3x3 ret = float3x3::ShearZ(xFactor, yFactor);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_Mirror_Static_Plane(duk_context* ctx)
  {
      Plane& p = *GetCheckedValueObject<Plane>(ctx, 0, Plane_ID);
      float3x3 ret = float3x3::Mirror(p);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_OrthographicProjection_Static_Plane(duk_context* ctx)
  {
      Plane& target = *GetCheckedValueObject<Plane>(ctx, 0, Plane_ID);
      float3x3 ret = float3x3::OrthographicProjection(target);
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_OrthographicProjectionYZ_Static(duk_context* ctx)
  {
      float3x3 ret = float3x3::OrthographicProjectionYZ();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_OrthographicProjectionXZ_Static(duk_context* ctx)
  {
      float3x3 ret = float3x3::OrthographicProjectionXZ();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_OrthographicProjectionXY_Static(duk_context* ctx)
  {
      float3x3 ret = float3x3::OrthographicProjectionXY();
      PushValueObjectCopy<float3x3>(ctx, ret, float3x3_ID, float3x3_Finalizer);
      return 1;
  }
  
  static duk_ret_t float3x3_FromRS_Static_Selector(duk_context* ctx)
  {
      int numArgs = duk_get_top(ctx);
      if (numArgs == 2 && GetValueObject<float3x3>(ctx, 0, float3x3_ID) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_FromRS_Static_float3x3_float3(ctx);
      if (numArgs == 2 && GetValueObject<Quat>(ctx, 0, Quat_ID) && GetValueObject<float3>(ctx, 1, float3_ID))
          return float3x3_FromRS_Static_Quat_float3(ctx);
      duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
  }
  
  static const duk_function_list_entry float3x3_Functions[] = {
      {"ToQuat", float3x3_ToQuat, 0}
      ,{"GetScale", float3x3_GetScale, 0}
      ,{"At", float3x3_At_int_int, 2}
      ,{"Row", float3x3_Row_int, 1}
      ,{"Row3", float3x3_Row3_int, 1}
      ,{"Col", float3x3_Col_int, 1}
      ,{"Col3", float3x3_Col3_int, 1}
      ,{"Diagonal", float3x3_Diagonal, 0}
      ,{"ScaleRow", float3x3_ScaleRow_int_float, 2}
      ,{"ScaleCol", float3x3_ScaleCol_int_float, 2}
      ,{"WorldX", float3x3_WorldX, 0}
      ,{"WorldY", float3x3_WorldY, 0}
      ,{"WorldZ", float3x3_WorldZ, 0}
      ,{"SetRow", float3x3_SetRow_Selector, DUK_VARARGS}
      ,{"SetCol", float3x3_SetCol_Selector, DUK_VARARGS}
      ,{"Set", float3x3_Set_Selector, DUK_VARARGS}
      ,{"SetIdentity", float3x3_SetIdentity, 0}
      ,{"SwapColumns", float3x3_SwapColumns_int_int, 2}
      ,{"SwapRows", float3x3_SwapRows_int_int, 2}
      ,{"SetRotatePartX", float3x3_SetRotatePartX_float, 1}
      ,{"SetRotatePartY", float3x3_SetRotatePartY_float, 1}
      ,{"SetRotatePartZ", float3x3_SetRotatePartZ_float, 1}
      ,{"SetRotatePart", float3x3_SetRotatePart_Selector, DUK_VARARGS}
      ,{"Determinant", float3x3_Determinant, 0}
      ,{"DeterminantSymmetric", float3x3_DeterminantSymmetric, 0}
      ,{"Inverse", float3x3_Inverse_float, DUK_VARARGS}
      ,{"InverseFast", float3x3_InverseFast_float, DUK_VARARGS}
      ,{"SolveAxb", float3x3_SolveAxb_float3_float3, 2}
      ,{"Inverted", float3x3_Inverted, 0}
      ,{"InverseColOrthogonal", float3x3_InverseColOrthogonal, 0}
      ,{"InverseOrthogonalUniformScale", float3x3_InverseOrthogonalUniformScale, 0}
      ,{"InverseOrthonormal", float3x3_InverseOrthonormal, 0}
      ,{"InverseSymmetric", float3x3_InverseSymmetric, 0}
      ,{"Transpose", float3x3_Transpose, 0}
      ,{"Transposed", float3x3_Transposed, 0}
      ,{"InverseTranspose", float3x3_InverseTranspose, 0}
      ,{"InverseTransposed", float3x3_InverseTransposed, 0}
      ,{"Trace", float3x3_Trace, 0}
      ,{"Orthonormalize", float3x3_Orthonormalize_int_int_int, 3}
      ,{"RemoveScale", float3x3_RemoveScale, 0}
      ,{"Transform", float3x3_Transform_Selector, DUK_VARARGS}
      ,{"TransformLeft", float3x3_TransformLeft_float3, 1}
      ,{"IsFinite", float3x3_IsFinite, 0}
      ,{"IsIdentity", float3x3_IsIdentity_float, DUK_VARARGS}
      ,{"IsLowerTriangular", float3x3_IsLowerTriangular_float, DUK_VARARGS}
      ,{"IsUpperTriangular", float3x3_IsUpperTriangular_float, DUK_VARARGS}
      ,{"IsInvertible", float3x3_IsInvertible_float, DUK_VARARGS}
      ,{"IsSymmetric", float3x3_IsSymmetric_float, DUK_VARARGS}
      ,{"IsSkewSymmetric", float3x3_IsSkewSymmetric_float, DUK_VARARGS}
      ,{"HasUnitaryScale", float3x3_HasUnitaryScale_float, DUK_VARARGS}
      ,{"HasNegativeScale", float3x3_HasNegativeScale, 0}
      ,{"HasUniformScale", float3x3_HasUniformScale_float, DUK_VARARGS}
      ,{"IsRowOrthogonal", float3x3_IsRowOrthogonal_float, DUK_VARARGS}
      ,{"IsColOrthogonal", float3x3_IsColOrthogonal_float, DUK_VARARGS}
      ,{"IsColOrthogonal3", float3x3_IsColOrthogonal3_float, DUK_VARARGS}
      ,{"IsOrthonormal", float3x3_IsOrthonormal_float, DUK_VARARGS}
      ,{"Equals", float3x3_Equals_float3x3_float, DUK_VARARGS}
      ,{"ToString", float3x3_ToString, 0}
      ,{"SerializeToString", float3x3_SerializeToString, 0}
      ,{"ToString2", float3x3_ToString2, 0}
      ,{"ToEulerXYX", float3x3_ToEulerXYX, 0}
      ,{"ToEulerXZX", float3x3_ToEulerXZX, 0}
      ,{"ToEulerYXY", float3x3_ToEulerYXY, 0}
      ,{"ToEulerYZY", float3x3_ToEulerYZY, 0}
      ,{"ToEulerZXZ", float3x3_ToEulerZXZ, 0}
      ,{"ToEulerZYZ", float3x3_ToEulerZYZ, 0}
      ,{"ToEulerXYZ", float3x3_ToEulerXYZ, 0}
      ,{"ToEulerXZY", float3x3_ToEulerXZY, 0}
      ,{"ToEulerYXZ", float3x3_ToEulerYXZ, 0}
      ,{"ToEulerYZX", float3x3_ToEulerYZX, 0}
      ,{"ToEulerZXY", float3x3_ToEulerZXY, 0}
      ,{"ToEulerZYX", float3x3_ToEulerZYX, 0}
      ,{"ExtractScale", float3x3_ExtractScale, 0}
      ,{"Decompose", float3x3_Decompose_Selector, DUK_VARARGS}
      ,{"Mul", float3x3_Mul_Selector, DUK_VARARGS}
      ,{"MulPos", float3x3_MulPos_Selector, DUK_VARARGS}
      ,{"MulDir", float3x3_MulDir_Selector, DUK_VARARGS}
      ,{nullptr, nullptr, 0}
  };
  
  static const duk_function_list_entry float3x3_StaticFunctions[] = {
      {"RotateX", float3x3_RotateX_Static_float, 1}
      ,{"RotateY", float3x3_RotateY_Static_float, 1}
      ,{"RotateZ", float3x3_RotateZ_Static_float, 1}
      ,{"RotateAxisAngle", float3x3_RotateAxisAngle_Static_float3_float, 2}
      ,{"RotateFromTo", float3x3_RotateFromTo_Static_float3_float3, 2}
      ,{"LookAt", float3x3_LookAt_Static_float3_float3_float3_float3, 4}
      ,{"RandomRotation", float3x3_RandomRotation_Static_LCG, 1}
      ,{"RandomGeneral", float3x3_RandomGeneral_Static_LCG_float_float, 3}
      ,{"FromQuat", float3x3_FromQuat_Static_Quat, 1}
      ,{"FromRS", float3x3_FromRS_Static_Selector, DUK_VARARGS}
      ,{"FromEulerXYX", float3x3_FromEulerXYX_Static_float_float_float, 3}
      ,{"FromEulerXZX", float3x3_FromEulerXZX_Static_float_float_float, 3}
      ,{"FromEulerYXY", float3x3_FromEulerYXY_Static_float_float_float, 3}
      ,{"FromEulerYZY", float3x3_FromEulerYZY_Static_float_float_float, 3}
      ,{"FromEulerZXZ", float3x3_FromEulerZXZ_Static_float_float_float, 3}
      ,{"FromEulerZYZ", float3x3_FromEulerZYZ_Static_float_float_float, 3}
      ,{"FromEulerXYZ", float3x3_FromEulerXYZ_Static_float_float_float, 3}
      ,{"FromEulerXZY", float3x3_FromEulerXZY_Static_float_float_float, 3}
      ,{"FromEulerYXZ", float3x3_FromEulerYXZ_Static_float_float_float, 3}
      ,{"FromEulerYZX", float3x3_FromEulerYZX_Static_float_float_float, 3}
      ,{"FromEulerZXY", float3x3_FromEulerZXY_Static_float_float_float, 3}
      ,{"FromEulerZYX", float3x3_FromEulerZYX_Static_float_float_float, 3}
      ,{"ScaleAlongAxis", float3x3_ScaleAlongAxis_Static_float3_float, 2}
      ,{"ShearX", float3x3_ShearX_Static_float_float, 2}
      ,{"ShearY", float3x3_ShearY_Static_float_float, 2}
      ,{"ShearZ", float3x3_ShearZ_Static_float_float, 2}
      ,{"Mirror", float3x3_Mirror_Static_Plane, 1}
      ,{"OrthographicProjection", float3x3_OrthographicProjection_Static_Plane, 1}
      ,{"OrthographicProjectionYZ", float3x3_OrthographicProjectionYZ_Static, 0}
      ,{"OrthographicProjectionXZ", float3x3_OrthographicProjectionXZ_Static, 0}
      ,{"OrthographicProjectionXY", float3x3_OrthographicProjectionXY_Static, 0}
      ,{nullptr, nullptr, 0}
  };
  
  void Expose_float3x3(duk_context* ctx)
  {
      duk_push_c_function(ctx, float3x3_Ctor_Selector, DUK_VARARGS);
      duk_put_function_list(ctx, -1, float3x3_StaticFunctions);
      duk_push_object(ctx);
      duk_put_function_list(ctx, -1, float3x3_Functions);
      duk_put_prop_string(ctx, -2, "prototype");
      duk_put_global_string(ctx, float3x3_ID);
      duk_get_global_string(ctx, float3x3_ID);
      PushValueObjectCopy<float3x3>(ctx, float3x3::zero, float3x3_ID, float3x3_Finalizer);
      duk_put_prop_string(ctx, -2, "zero");
      PushValueObjectCopy<float3x3>(ctx, float3x3::identity, float3x3_ID, float3x3_Finalizer);
      duk_put_prop_string(ctx, -2, "identity");
      PushValueObjectCopy<float3x3>(ctx, float3x3::nan, float3x3_ID, float3x3_Finalizer);
      duk_put_prop_string(ctx, -2, "nan");
      duk_pop(ctx);
  }
  
  }
  