/// matrix4f.h
///
/// (c) 2008-2018 by Carsten Busse <carsten.busse@googlemail.com>
///                  Bastian Spiegel <bs@tkscript.de>
///     - Distributed under terms of the Lesser GNU General Public License (LGPL).
///       See COPYING and <http://www.gnu.org/licenses/licenses.html#LGPL> for further information.
///
///

#ifndef __MATRIX4F_H_
#define __MATRIX4F_H_


YG("Math");


/* @class Matrix4f,Matrix
This class represents a single precision 4x4 square matrix.
 */
YC class _Matrix4f : public _Matrix {
  public:
   sF32 floats[16];

  public:
   _Matrix4f(void);
   ~_Matrix4f();

   YAC_POOLED(_Matrix4f, YAC_POOL_PRIORITY_HIGH);

   sUI   YAC_VCALL yacArrayGetNumElements      (void);
   sUI   YAC_VCALL yacArrayGetMaxElements      (void);
   sUI   YAC_VCALL yacArrayGetElementType      (void);
   sUI   YAC_VCALL yacArrayGetElementByteSize  (void);
   void  YAC_VCALL yacArraySet                 (YAC_ContextHandle, sUI, YAC_Value *);
   void  YAC_VCALL yacArrayGet                 (YAC_ContextHandle, sUI, YAC_Value *);
   void *YAC_VCALL yacArrayGetPointer          (void);
   sUI   YAC_VCALL yacArrayGetWidth            (void);
   sUI   YAC_VCALL yacArrayGetHeight           (void);
   sUI   YAC_VCALL yacArrayGetStride           (void);
   sSI   YAC_VCALL yacTensorRank               (void);
   void  YAC_VCALL yacSerialize                (YAC_Object *, sUI);
   sUI   YAC_VCALL yacDeserialize              (YAC_Object *, sUI);
   void  YAC_VCALL yacOperatorClamp            (YAC_Object *, YAC_Object *);
   void  YAC_VCALL yacOperatorWrap             (YAC_Object *, YAC_Object *);
//YAC_OP_CEQ, YAC_OP_CNE, YAC_OP_ASSIGN, YAC_OP_ADD = _add,
//YAC_OP_SUB = _sub, YAC_OP_MUL = _mul, YAC_OP_NEG, YAC_OP_INIT
   void  YAC_VCALL yacOperator                 (sSI, YAC_Object *, YAC_Value *);
   void  YAC_VCALL yacOperatorI                (sSI, sSI, YAC_Value *);
   void  YAC_VCALL yacOperatorF32              (sSI, sF32, YAC_Value *);
   sBool YAC_VCALL yacToString                 (YAC_String*) const;

   // Helper methods
   void assignFloats     (sF32 *_fv, sUI _ne);
   void assignFloatArray (YAC_FloatArray *_fa);
   void assignGeneric    (YAC_ContextHandle _ctx, YAC_Object *_o);
   void invertHelper     (_Matrix4f *t);

   //void _setColumnMajor (sSI _bEnabled);
   //sSI  _getColumnMajor (void);


   /* @method setRC,int row,int col,float v
      Set element at (row, column) to v
      @arg row Row number (0..3)
      @arg col Column number (0..3)
      @arg v new value for a
    */
   YM void _set(sSI _row, sSI _col, sF32 _v);


   /* @method getRC,int row,int col
      Get element at (row, column)
      @arg row Row number (0..3)
      @arg col Column number (0..3)
      @return Element value
    */
   YM sF32 _get(sSI _row, sSI _col);


   /* @method setA,float v
      Set a element to v
      @arg v new value for a
    */
   YM void _setA(sF32);


   /* @method setB,float v
      Set b element to v
      @arg v new value for b
    */
   YM void _setB(sF32);


   /* @method setC,float v
      Set c element to v
      @arg v new value for c
    */
   YM void _setC(sF32);


   /* @method setD,float v
      Set d element to v
      @arg v new value for d
    */
   YM void _setD(sF32);


   /* @method setE,float v
      Set e element to v
      @arg v new value for e
    */
   YM void _setE(sF32);


   /* @method setF,float v
      Set f element to v
      @arg v new value for f
    */
   YM void _setF(sF32);


   /* @method setG,float v
      Set g element to v
      @arg v new value for g
    */
   YM void _setG(sF32);
   /* @method setH,float v
      Set h element to v
      @arg v new value for h
    */
   YM void _setH(sF32);


   /* @method setI,float v
      Set i element to v
      @arg v new value for i
    */
   YM void _setI(sF32);


   /* @method setJ,float v
      Set j element to v
      @arg v new value for j
    */
   YM void _setJ(sF32);


   /* @method setK,float v
      Set k element to v
      @arg v new value for k
    */
   YM void _setK(sF32);


   /* @method setL,float v
      Set l element to v
      @arg v new value for l
    */
   YM void _setL(sF32);


   /* @method setM,float v
      Set m element to v
      @arg v new value for m
    */
   YM void _setM(sF32);


   /* @method setN,float v
      Set n element to v
      @arg v new value for n
    */
   YM void _setN(sF32);


   /* @method setO,float v
      Set o element to v
      @arg v new value for o
    */
   YM void _setO(sF32);


   /* @method setP,float v
      Set p element to v
      @arg v new value for p
    */
   YM void _setP(sF32);


   /* @method getA:float
      Get value of a element
      @return value of a element
    */
   YM sF32 _getA(void);


   /* @method getB:float
      Get value of b element
      @return value of b element
    */
   YM sF32 _getB(void);


   /* @method getC:float
      Get value of c element
      @return value of c element
    */
   YM sF32 _getC(void);


   /* @method getD:float
      Get value of d element
      @return value of d element
    */
   YM sF32 _getD(void);


   /* @method getE:float
      Get value of e element
      @return value of e element
    */
   YM sF32 _getE(void);


   /* @method getF:float
      Get value of f element
      @return value of f element
    */
   YM sF32 _getF(void);


   /* @method getG:float
      Get value of g element
      @return value of g element
    */
   YM sF32 _getG(void);


   /* @method getH:float
      Get value of h element
      @return value of h element
    */
   YM sF32 _getH(void);


   /* @method getI:float
      Get value of i element
      @return value of i element
    */
   YM sF32 _getI(void);


   /* @method getJ:float
      Get value of j element
      @return value of j element
    */
   YM sF32 _getJ(void);


   /* @method getK:float
      Get value of k element
      @return value of k element
    */
   YM sF32 _getK(void);


   /* @method getL:float
      Get value of l element
      @return value of l element
    */
   YM sF32 _getL(void);


   /* @method getM:float
      Get value of m element
      @return value of m element
    */
   YM sF32 _getM(void);


   /* @method getN:float
      Get value of n element
      @return value of n element
    */
   YM sF32 _getN(void);


   /* @method getO:float
      Get value of o element
      @return value of o element
    */
   YM sF32 _getO(void);


   /* @method getP:float
      Get value of p element
      @return value of p element
    */
   YM sF32 _getP(void);


//produce string representation
   /* @method getString:String
      Get string representation of matrix ((a, b, c, d), (e, f, g, h), (i, j, k, l), (m, n, o, p))
      @return string representation of matrix
    */
   YM void _getString(YAC_Value *) const;


//arithmetics
   /* @method add,Matrix4f m
      Add another matrix m to this instance
      @arg m matrix to add
    */
   YM void _add_YAC_RSELF(YAC_Object *);
   YM void _add_YAC_RVAL(YAC_Object *, YAC_Value *);
   YM void _add_YAC_RARG(YAC_Object *, YAC_Object *);


   /* @method sub,Matrix4f m
      Substract another matrix m from this instance
      @arg m matrix to substract
    */
   YM void _sub_YAC_RSELF(YAC_Object *);
   YM void _sub_YAC_RVAL(YAC_Object *, YAC_Value *);
   YM void _sub_YAC_RARG(YAC_Object *, YAC_Object *);


   /* @method mulf,float v
      Multiply this instance with scalar value v
      @arg v value to multiply
    */
   YM void _mulf_YAC_RSELF(sF32);
   YM void _mulf_YAC_RVAL(sF32, YAC_Value *);
   YM void _mulf_YAC_RARG(sF32, YAC_Object *);


   /* @method mul,Matrix4f m
      Multiply this instance with matrix m
      @arg m matrix to multiply
    */
   YM void _mul_YAC_RSELF(YAC_Object *);
   YM void _mul_YAC_RVAL(YAC_Object *, YAC_Value *);
   YM void _mul_YAC_RARG(YAC_Object *, YAC_Object *);


   /* @method mulv,Vector4f v:Vector4f
      Multiply this instance with a 4dim vector
      @arg v vector to multiply
      @return resulting vector
    */
   YM void _mulv_YAC_RVAL(YAC_Object *, YAC_Value *);
   YM void _mulv_YAC_RARG(YAC_Object *, YAC_Object *);


   /* @method getAbs:float
      Calculate the Hilbert-Schmidt norm of the matrix
      @return scalar matrix norm value
    */
   YM sF32 _getAbs(void);


   /* @method getAbsSqr:float
      Calculate the squared Hilbert-Schmidt norm of the matrix
      @return scalar matrix norm value
    */
   YM sF32 _getAbsSqr(void);


   /* @method unit
      Normalise matrix with Hilbert-Schmidt norm
    */
   YM void _unit_YAC_RSELF(void); /* unit */
   YM void _unit_YAC_RVAL(YAC_Value *);
   YM void _unit_YAC_RARG(YAC_Object *);


   /* @method unitScale,float v
      Normalise matrix with Hilbert-Schmidt norm and scale by v afterwards
      @arg v value to scale matrix
    */
   YM void _unitScale_YAC_RSELF(sF32);
   YM void _unitScale_YAC_RVAL(sF32, YAC_Value *);
   YM void _unitScale_YAC_RARG(sF32, YAC_Object *);


   /* @method det:float
      Calculate determinant of matrix
      @return value of determinant
    */
   YM sF32 _det(void);


   /* @method invert
      Calculate inversion of matrix, so that A*A<sup>-1</sup>=U
    */
   YM void _invert_YAC_RSELF(void);
   YM void _invert_YAC_RVAL(YAC_Value *);
   YM void _invert_YAC_RARG(YAC_Object *);

//   YM void _invert2_YAC_RSELF(void);
//   YM void _invert2_YAC_RVAL(YAC_Value *);
//   YM void _invert2_YAC_RARG(YAC_Object *);


   /* @method transpose
      Transpose matrix
    */
   YM void _transpose_YAC_RSELF(void);
   YM void _transpose_YAC_RVAL(YAC_Value *);
   YM void _transpose_YAC_RARG(YAC_Object *);


   /* @method setRow,int r,Vector4f v
      Set row r with values from v
      @arg r row number
      @arg v Vector4f instance
    */
   YM void _setRow(sUI, YAC_Object*);


   /* @method getRow,int r:Vector4f
      Get row r values
      @arg r row number
      @return vector with values from row r
    */
   YM void _getRow_YAC_RVAL(sUI, YAC_Value*);
   YM void _getRow_YAC_RARG(sUI, YAC_Object*);


   /* @method setCol,int c,Vector4f v
      Set column c with values from v
      @arg c column number
      @arg v Vector4f instance
    */
   YM void _setCol(sUI, YAC_Object*);


   /* @method getCol,int c:Vector4f
      Get column c values
      @arg c column number
      @return vector with values from column c
    */
   YM void _getCol_YAC_RVAL(sUI, YAC_Value*);
   YM void _getCol_YAC_RARG(sUI, YAC_Object*);


   /* @method getQuaternionf:Quaternionf
      Tries to find a Quaternion representation of the matrix if possible
      @return Quaternion representation of matrix (or zero quaternion if not possible)
    */
   YM void _getQuaternionf_YAC_RVAL(YAC_Value*);
   YM void _getQuaternionf_YAC_RARG(YAC_Object*);


   /* @method init,float va,float vb,float vc,float vd,float ve,float vf,float vg,float vh,float vi,float vj,float vk,float vl,float vm,float vn,float vo,float vp
      Initialise matrix
      @arg va value for a
      @arg vb value for b
      @arg vc value for c
      @arg vd value for d
      @arg ve value for e
      @arg vf value for f
      @arg vg value for g
      @arg vh value for h
      @arg vi value for i
      @arg vj value for j
      @arg vk value for k
      @arg vl value for l
      @arg vm value for m
      @arg vn value for n
      @arg vo value for o
      @arg vp value for p
    */
   YM void _init(sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32);


   /* @method initRow,int r,float va,float vb,float vc,float vd
      Initialise row r of matrix
      @arg r row number
      @arg va value for first element
      @arg vb value for second element
      @arg vc value for third element
      @arg vd value for fourth element
    */
   YM void _initRow(sUI,sF32,sF32,sF32,sF32);


   /* @method initCol,int c,float va,float vb,float vc,float vd
      Initialise column c of matrix
      @arg c column number
      @arg va value for first element
      @arg vb value for second element
      @arg vc value for third element
      @arg vd value for fourth element
    */
   YM void _initCol(sUI,sF32,sF32,sF32,sF32);


   /* @method initRowV,int r,Vector4f v
      Initialise row r of matrix
      @arg r row number
      @arg v vector with values
    */
   YM void _initRowV(sUI,YAC_Object*);


   /* @method initColV,int c,Vector4f v
      Initialise column c of matrix
      @arg c column number
      @arg v vector with values
    */
   YM void _initColV(sUI,YAC_Object*);


   /* @method initRotate,float angle,Vector3f dir
      Initialize with rotation matrix for rotation of angle around vector dir.
      @arg angle Rotation angle (0..2PI)
      @arg dir Vector to rotate around
   */
   YM void _initRotate(sF32 _angle, YAC_Object *_dir);

   /* @method initEulerXYX,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerXYX(sF32, sF32, sF32);


   /* @method initEulerXZX,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerXZX(sF32, sF32, sF32);


   /* @method initEulerYXY,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerYXY(sF32, sF32, sF32);


   /* @method initEulerYZY,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerYZY(sF32, sF32, sF32);


   /* @method initEulerZXZ,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerZXZ(sF32, sF32, sF32);


   /* @method initEulerZYZ,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerZYZ(sF32, sF32, sF32);


   /* @method initEulerXYZ,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerXYZ(sF32, sF32, sF32);


   /* @method initEulerXZY,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerXZY(sF32, sF32, sF32);


   /* @method initEulerYXZ,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerYXZ(sF32, sF32, sF32);


   /* @method initEulerYZX,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerYZX(sF32, sF32, sF32);


   /* @method initEulerZXY,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerZXY(sF32, sF32, sF32);


   /* @method initEulerZYX,float a,float b,float c
      Initialise with euler rotation matrix
      @arg a first rotation
      @arg b second rotation
      @arg c third rotation
    */
   YM void _initEulerZYX(sF32, sF32, sF32);


   /* @method New,Object o:Matrix4f
      Initialise from an array and return new instance of Matrix4f
      @arg o array with values
      @return new instance of Matrix4f
    */
   YM void _New(YAC_Object *, YAC_Value *);
//   YM void _New(sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,YAC_Value*);


   /* @method BuildPerspectiveMatrix4f,float fov,float aspect,float zNear,float zFar:Matrix4f
      Builds a perspective matrix
      @arg fov field of view in degrees
      @arg aspect aspect ratio
      @arg zNear zNear value
      @arg zFar zFar value
      @return generated matrix
    */
   YM void _BuildPerspectiveMatrix4f_YAC_RVAL(sF32, sF32, sF32, sF32, YAC_Value*);
   YM void _BuildPerspectiveMatrix4f_YAC_RARG(sF32, sF32, sF32, sF32, YAC_Object*);


   /* @method BuildLookAtMatrix4f,Vector3f eye,Vector3f center,Vector3f up:Matrix4f
      Build a look at matrix
      @arg eye eye direction vector
      @arg center center of camera vector
      @arg up vector for up direction
      @return generated matrix
    */
   YM void _BuildLookAtMatrix4f_YAC_RVAL(YAC_Object*, YAC_Object*, YAC_Object*, YAC_Value*);
   YM void _BuildLookAtMatrix4f_YAC_RARG(YAC_Object*, YAC_Object*, YAC_Object*, YAC_Object*);


   /* @method BuildRotateMatrix4f,float angle,Vector3f axis:Matrix4f
      Build a rotation matrix
      @arg angle rotation angle
      @arg axis rotation axis
      @return generated matrix
    */
   YM void _BuildRotateMatrix4f_YAC_RVAL(sF32, YAC_Object*, YAC_Value*);
   YM void _BuildRotateMatrix4f_YAC_RARG(sF32, YAC_Object*, YAC_Object*);


   /* @method BuildTranslateMatrix4f,Vector3f move:Matrix4f
      Build a translation matrix
      @arg move movement vector
      @return generated matrix
    */
   YM void _BuildTranslateMatrix4f_YAC_RVAL(YAC_Object*, YAC_Value*);
   YM void _BuildTranslateMatrix4f_YAC_RARG(YAC_Object*, YAC_Object*);


   /* @method BuildScaleMatrix4f,Vector3f scale:Matrix4f
      Build a scale matrix
      @arg scale vector
      @return generated matrix
    */
   YM void _BuildScaleMatrix4f_YAC_RVAL(YAC_Object*, YAC_Value*);
   YM void _BuildScaleMatrix4f_YAC_RARG(YAC_Object*, YAC_Object*);


   /* @method BuildEulerXZX4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with XZX convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerXZX4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerXZX4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerXYX4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with XYX convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerXYX4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerXYX4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerYXY4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with YXY convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerYXY4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerYXY4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerYZY4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with YZY convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerYZY4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerYZY4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerZYZ4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with ZYZ convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerZYZ4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerZYZ4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerZXZ4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with ZXZ convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerZXZ4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerZXZ4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerXZY4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with XZY convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerXZY4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerXZY4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerXYZ4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with XYZ convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerXYZ4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerXYZ4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerYXZ4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with YXZ convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerYXZ4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerYXZ4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerYZX4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with YZX convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerYZX4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerYZX4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerZYX4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with ZYX convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerZYX4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerZYX4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method BuildEulerZXY4f,float a,float b,float c:Matrix4f
      Build an euler rotation matrix with ZXY convention
      @arg a first angle in radians
      @arg b second angle in radians
      @arg c third angle in radians
      @return generated matrix
    */
   YM void _BuildEulerZXY4f_YAC_RVAL(sF32, sF32, sF32, YAC_Value*);
   YM void _BuildEulerZXY4f_YAC_RARG(sF32, sF32, sF32, YAC_Object *);


   /* @method initIdentity
      Initialize with identity matrix.
   */
   YM void _initIdentity(void);
};


   /* @function matrix4f,Object o:Matrix4f
      Initialise from an array and return new instance of Matrix4f
      @arg o array with values
      @return new instance of Matrix4f
    */
YF void YAC_CALL _matrix4f(YAC_Object *, YAC_Value *);
//void YAC_CALL _matrix4f(sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,sF32,YAC_Value*);


#endif // __MATRIX4F_H_
