Sorry your browser is not supported!

// Project: Physic Examples 
// Created: 19.11.2017

// show all errors
SetErrorMode(2)
#include "ExtendedMath.agc"
// set window properties
SetWindowTitle( "Physic Examples" )
SetWindowSize( 1024, 768, 0 )
SetWindowAllowResize( 1 ) // allow the user to resize the window

// set display properties
SetVirtualResolution( 1024, 768 ) // doesn't have to match the window
SetOrientationAllowed( 1, 1, 1, 1 ) // allow both portrait and landscape on mobile devices
SetSyncRate( 30, 0 ) // 30fps instead of 60 to save battery
SetScissor( 0,0,0,0 ) // use the maximum available screen space, no black borders
UseNewDefaultFonts( 1 ) // since version 2.0.22 we can use nicer default fonts


Create3DPhysicsWorld()
GravityVector = CreateVector3(0.0, -10.0, 0.0)


Set3DPhysicsGravity( GravityVector ) 

CreateObjectBox( 1, 1000,0.1,1000 )
Create3DPhysicsStaticBody( 1 )
SetObjectShapeBox(1)
SetObject3DPhysicsFriction(1,0.5)

CreateObjectBox( 2, 5,5,5 )
SetObjectPosition( 2, 5.1,30,0 )
Create3DPhysicsDynamicBody( 2 )
SetObjectShapeBox(2)
SetObject3DPhysicsFriction(2,0.5)
SetObject3DPhysicsMaxLinearVelocity( 2, 20.0 )
SetObject3DPhysicsCanSleep(2,0)

SetCameraPosition( 1, 0,30,-80 )
SetCameraLookAt( 1, 0,10,0, 0 )
global player as integer
player = 2




// velocity
LinearVector = CreateVector3()
AngularVector = CreateVector3()

// direction
UpVector = CreateVector3()
ForwardVector = CreateVector3()
LeftVector = CreateVector3()

// quats
LookQuat = CreateQuaternion()



do
print("Math Library example with 3d physics - display vectors and forces")
print("Press '1' or '2' to add linear/angular forces")

	if GetRawKeyPressed(49) 
		SetObject3DPhysicsLinearVelocity(2,GetObject3DPhysicsLinearVelocityX(2)+1.0,100.0,GetObject3DPhysicsLinearVelocityZ(2),200.0) 
	endif
	
	if GetRawKeyPressed(50)
		SetObject3DPhysicsAngularVelocity( 2,GetObject3DPhysicsAngularVelocityX(2),100.0,GetObject3DPhysicsAngularVelocityZ(2),200.0 ) 
	endif
	
	
	

// get values
	px# = getobjectx(2)
	py# = getobjecty(2)
	pz# = getobjectz(2)
	
	qw# = GetObjectQuatW(2)
	qx# = GetObjectQuatX(2)
	qy# = GetObjectQuatY(2)
	qz# = GetObjectQuatZ(2)

// write vectors
	SetVector3(LinearVector, GetObject3DPhysicsLinearVelocityX(2), GetObject3DPhysicsLinearVelocityY(2), GetObject3DPhysicsLinearVelocityZ(2) )
	SetVector3(AngularVector, GetObject3DPhysicsAngularVelocityX(2), GetObject3DPhysicsAngularVelocityY(2), GetObject3DPhysicsAngularVelocityZ(2) )

// write quat
	SetQuaternion(LookQuat,qx#,qy#,qz#,qw#)

	InverseQuaternion(LookQuat)
	LookQuatW# = GetQuaternionW(LookQuat)
	LookQuatX# = GetQuaternionX(LookQuat)
	LookQuatY# = GetQuaternionY(LookQuat)
	LookQuatZ# = GetQuaternionZ(LookQuat)

	GetForwardVector3FromQuat(ForwardVector, LookQuatW#,LookQuatX#,LookQuatY#,LookQuatZ#)
	GetUpwardVector3FromQuat(UpVector, qw#,qx#,qy#,qz#)
	GetLeftVector3FromQuat(LeftVector, qw#,qx#,qy#,qz#)

	ScaleVector3(ForwardVector,ForwardVector,10.0)
	ScaleVector3(UpVector,UpVector,10.0)
	ScaleVector3(LeftVector,LeftVector,10.0)

	DrawVector3( px#, py#, pz#, ForwardVector, 255, 0, 0 ) 			// ForwardVector
	DrawVector3( px#, py#, pz#, UpVector, 0, 255, 255 ) 			// UpVector
	DrawVector3( px#, py#, pz#, LeftVector, 0, 255, 0 ) 			// LeftVector

	DrawVector3(px#, py#, pz#, GravityVector, 0, 0, 255) 			// gravity vector
	DrawVector3(px#, py#, pz#, LinearVector, 255, 0, 0) 			// linear speed
	DrawVector3(px#, py#, pz#, AngularVector, 0, 255, 0) 			// angular speed
	
	
	
	
	
	
	Print( ScreenFPS() )


	Sync()
	Step3DPhysicsWorld()
loop

    	    X Rotation Matrix
     ----------------------------
	1	0	0	0
	0     cos(rx) sin(rx)	0
	0    -sin(rx) cos(rx)	0
	0	0	0	1
     ----------------------------

    	    Y Rotation Matrix
     ----------------------------
      cos(ry)	0    -sin(ry)	0
	0	1	0	0
      sin(ry)	0     cos(ry)	0
	0	0	0	1
     ----------------------------


          Z Rotation Matrix
     ----------------------------
      cos(rz) sin(rz)	0	0
     -sin(rz) cos(rz)	0	0
	0	0	1	0
	0	0	0	1
     ----------------------------

		      Matrix Multiplication
-------------------------------------------------------------------------
   a	e	i	0		m	q	u	0
   b	f	j	0     times	n	r	v	0
   c	g	k	0		o	s	w	0
   d	h	l	1		p	t	x	1

			      equals

a*m+e*n+i*o		a*q+e*r+i*s		a*u+e*v+i*w		0
b*m+f*n+j*o		b*q+f*r+j*s		b*u+f*v+j*w		0
c*m+g*n+k*o		c*q+g*r+k*s		c*u+g*v+k*w		0

	The last row multiplies the translation aspect of the matrix
      for rotations only this will not be needed but here it is anyway

d*m+h*n+l*o+p		d*q+h*r+l*h+t		d*u+h*v+l*w+x		1
-------------------------------------------------------------------------

Matrix multiplication looks difficult but is easy to implement in code
using a 2-diminsional array or indexing a 1-diminsional array 2-diminsionally.

for i=0 to 3
	MatResult(i,0) = MatA(0, 0)*MatB(i, 0)+MatA(1, 0)*MatB(i, 1)+MatA(2, 0)*MatB(i, 2)
	MatResult(i,1) = MatA(0, 1)*MatB(i, 0)+MatA(1, 1)*MatB(i, 1)+MatA(2, 1)*MatB(i, 2)
	MatResult(i,2) = MatA(0, 2)*MatB(i, 0)+MatA(1, 2)*MatB(i, 1)+MatA(2, 2)*MatB(i, 2)
	MatResult(i,3) = MatA(0, 3)*MatB(i, 0)+MatA(1, 3)*MatB(i, 1)+MatA(2, 3)*MatB(i, 2)+MatB(i, 3)
next I

1		0		0		0
up.x		up.y		up.z		0
at.x		at.y		at.z		0
0		0		0		1

#constant xAxis         1
#constant yAxis         2
#constant zAxis         3
#constant posVec        4
#constant matRot        5
#constant matView       6
#constant matTempRot    7

null as float

null = make vector3(xAxis)
null = make vector3(yAxis)
null = make vector3(zAxis)
null = make vector3(posVec)
null = make matrix4(matRot)
null = make matrix4(matView)
null = make matrix4(matTempRot)

sync on
sync rate 60

backdrop on
color backdrop 0

autocam off
position camera 0.0, 0.0, 0.0
point camera 0.0, 0.0, 0.0

MakeViewMatrix4(xAxis, yAxis, zAxis, posVec, matRot, matView, matTempRot)

do
   set cursor 0, 0
   PrintMatrix4(matView)

   sync
loop

end

function MakeViewMatrix4(xVecID as integer, yVecID as integer, zVecID as integer,posVecID as integer, matRotID as integer, matViewID as integer, matTempRotID as integer)
   set identity matrix4 matViewID

   set vector3 posVecID, camera position x(), camera position y(), camera position z()

   rotate z matrix4 matRotID, radian(camera angle z())
   rotate y matrix4 matTempRotID, radian(camera angle y())
   multiply matrix4 matRotID, matRotID, matTempRotID
   rotate x matrix4 matTempRotID, radian(camera angle x())
   multiply matrix4 matRotID, matRotID, matTempRotID

   set vector3 xVecID, 1.0, 0.0, 0.0
   set vector3 yVecID , 0.0, 1.0, 0.0
   set vector3 zVecID, 0.0, 0.0, 1.0

   TransformCoords(xVecID, matRotID)
   TransformCoords(yVecID, matRotID)
   TransformCoords(zVecID, matRotID)

   set matrix4 element matViewID, 0, x vector3(xVecID)
   set matrix4 element matViewID, 1, x vector3(yVecID)
   set matrix4 element matViewID, 2, x vector3(zVecID)

   set matrix4 element matViewID, 4, y vector3(xVecID)
   set matrix4 element matViewID, 5, y vector3(yVecID)
   set matrix4 element matViewID, 6, y vector3(zVecID)

   set matrix4 element matViewID, 8, z vector3(xVecID)
   set matrix4 element matViewID, 9, z vector3(yVecID)
   set matrix4 element matViewID, 10, z vector3(zVecID)

   set matrix4 element matViewID, 12, -dot product vector3(posVecID, xVecID)
   set matrix4 element matViewID, 13, -dot product vector3(posVecID, yVecID)
   set matrix4 element matViewID, 14, -dot product vector3(posVecID, zVecID)
endfunction

function PrintMatrix4(matID as integer)
   element = 0
   for i = 0 to 3
      for j = 0 to 3
         print str$(get matrix4 element(matID, element));" ";
         inc element
      next j
   print
   next i
endfunction

function TransformCoords(VecID as integer, MatID as integer)
   norm as float
   x as float
   y as float
   z as float

   norm = get matrix4 element(MatID, 3)*x vector3(VecID)+get matrix4 element(MatID, 7)*y vector3(VecID)+get matrix4 element(MatID, 11)+get matrix4 element(MatID, 15)

   if (norm)
      x = (get matrix4 element(MatID, 0)*x vector3(VecID)+get matrix4 element(MatID, 4)*y vector3(VecID)+get matrix4 element(MatID, 8)*z vector3(VecID)+get matrix4 element(MatID, 12))/norm
      y = (get matrix4 element(MatID, 1)*x vector3(VecID)+get matrix4 element(MatID, 5)*y vector3(VecID)+get matrix4 element(MatID, 9)*z vector3(VecID)+get matrix4 element(MatID, 13))/norm
      z = (get matrix4 element(MatID, 2)*x vector3(VecID)+get matrix4 element(MatID, 6)*y vector3(VecID)+get matrix4 element(MatID, 10)*z vector3(VecID)+get matrix4 element(MatID, 14))/norm
   else
      x = 0.0
      y = 0.0
      z = 0.0
   endif

   set vector3 VecID, x, y, z
endfunction

1	0	0	0
0	1	0	0
0	0	1	0
0	0	0	1

#constant vecEye     1
#constant vecAt      2
#constant vecUp      3
#constant vecXAxis   4
#constant vecYAxis   5
#constant vecZAxis   6
#constant matView    7

null as integer

null = make vector3(vecEye)
null = make vector3(vecAt)
null = make vector3(vecUp)
null = make vector3(vecXAxis)
null = make vector3(vecYAxis)
null = make vector3(vecZAxis)
null = make matrix4(matView)

set vector3 vecEye, 0, 0, 0
set vector3 vecAt, 0, 0, 1
set vector3 vecUp, 0, 1, 0

subtract vector3 vecZAxis, vecAt, vecEye
normalize vector3 vecZAxis, vecZAxis

cross product vector3 vecXAxis, vecUp, vecZAxis
normalize vector3 vecXAxis, vecXAxis

cross product vector3 vecYAxis, vecZAxis, vecXAxis

set matrix4 element matView, 0, x vector3(vecXAxis)
set matrix4 element matView, 1, x vector3(vecYAxis)
set matrix4 element matView, 2, x vector3(vecZAxis)
set matrix4 element matView, 3, 0.0

set matrix4 element matView, 4, y vector3(vecXAxis)
set matrix4 element matView, 5, y vector3(vecYAxis)
set matrix4 element matView, 6, y vector3(vecZAxis)
set matrix4 element matView, 7, 0.0

set matrix4 element matView, 8, z vector3(vecXAxis)
set matrix4 element matView, 9, z vector3(vecYAxis)
set matrix4 element matView, 10, z vector3(vecZAxis)
set matrix4 element matView, 11, 0.0

set matrix4 element matView, 12, -dot product vector3(vecXAxis, vecEye)
set matrix4 element matView, 13, -dot product vector3(vecYAxis, vecEye)
set matrix4 element matView, 14, -dot product vector3(vecZAxis, vecEye)
set matrix4 element matView, 15, 1.0

sync on
sync rate 60

backdrop on
color backdrop 0

do
   set cursor 0, 0
   PrintMatrix4(matView)

   sync
loop

end

function PrintMatrix4(matID as integer)
   element = 0
   for i = 0 to 3
      for j = 0 to 3
         print str$(get matrix4 element(matID, element));" ";
         inc element
      next j
   print
   next i
endfunction

// ==================================================================================
// ======    Extended math function for AGK    ======================================
// ========================================= 2016================  0.14  ============
// ==================================================================================
// ==== Jack('the baby stuff), WickedX('the hard stuff) =============================
// ==================================================================================


/*	Changelog
	
	Version 0.1
	===========
	
	
		Vector 3 (already existing, but incomplete commandset)
			- added normalize vector 3 command
		
			
		Vector 4 (new command set)
			- added vector4 create command
			- added vector4 delete command
			- added vector4 add command
			- added vector4 substract command
			- added vector4 set command
			- added vector4 get x,y,z,w commands
		
			
		Matrix 4 (new command set)
			- added matrix 4 create command
			- added matrix 4 delete command
			- added matrix 4 add command
			- added matrix 4 multiply command
			- added matrix 4 divide command
			- added matrix 4 get element command
			- added matrix 4 set command
	
	
	
	Version 0.12
	============
	
		Bug Fixes
			- Fixed a major bug at deleting matrix4 and vector4 arrays (deleting caused missing links)
			
	
		Matrix 4
			- added matrix 4 Projection Matrix 4 command
			- added matrix 4 Translate Matrix 4 command
			


	Version 0.14
	============

		Bug Fixes
			- Matrix multiplication is corrected (was wronger than wrong)
			
	
	
		Vector 3
			- added TransformCoordsVector3 command 
			
		Matrix 4
			- added matrix 4 rotation Matrix 4 commands (x,y,z)
			- added Set Matrix 4 Element command (0 - 15)
			
			
			
			
			
		Work in Progress (Not finished, but have to be done to get really serious with 3d math):
			- transform normals vector3 command
			- Inverse Matrix4 command		
			- Build Look At LhMatrix4 command
			- set identity matrix4 comnmand [?]	
			- Intense debugging
				
			

Forum thread: https://forum.thegamecreators.com/thread/217064#msg2582798		
	
========================================================================		
*/




// types

/*

type Vec4_def

	x as float
	y as float
	z as float
	w as float
endtype

type Vector4_def
	used as integer
	x as float
	y as float
	z as float
	w as float
endtype




type Matrix4_def
	used as integer
	x as Vec4_def
	y as Vec4_def
	z as Vec4_def
	w as Vec4_def
endtype

*/


// Math Constants
// ==============

#constant Math_PI	3.14159







// extended vector3 commands Library
// =================================


// normalize vector (from source to result)
function normalizeVector3(vsource)
	
    d# = getVector3Length(vsource)
    
     x# = GetVector3X(vsource) / d#
     y# = GetVector3Y(vsource) / d#
     z# = GetVector3Z(vsource) / d#
    
	SetVector3(vsource,x#,y#,z#) // update source vector
    
endfunction 

// Transform Coords Vector 3
function TransformCoordsVector3(VecID, MatID)
   norm as float
   x as float
   y as float
   z as float
 

 
   norm = GetMatrix4Element(MatID, 3)*GetVector3X(VecID)+GetMatrix4Element(MatID, 7)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 11)+GetMatrix4Element(MatID, 15)
 
   if (norm)>0.0
      x = (GetMatrix4Element(MatID, 0)*GetVector3X(VecID)+GetMatrix4Element(MatID, 4)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 8)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 12))/norm
      y = (GetMatrix4Element(MatID, 1)*GetVector3X(VecID)+GetMatrix4Element(MatID, 5)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 9)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 13))/norm
      z = (GetMatrix4Element(MatID, 2)*GetVector3X(VecID)+GetMatrix4Element(MatID, 6)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 10)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 14))/norm
   else
      x = 0.0
      y = 0.0
      z = 0.0
   endif
 
   setvector3(VecID, x, y, z)
endfunction


remstart this should be a good feature : 

// transform normals vector3
function TransformNormalsVector3(vsource, msource)

endfunction


remend



// vector4 commands Library
// ========================


// create vector4
function CreateVector4()

			if Vector4.length=-1
			
				dim Vector4[] as Vector4_def
			
			endif

		// find free slot
		x = -1 
		repeat
		inc x
		if x>Vector4.length // if no slot exists, create a new one
			Vector4.length=Vector4.length+1	
			exit
		endif

		until Vector4[x].used=0
			
				out=x

			Vector4[out].used=1 // set used to 1

endfunction out

// delete vector4 (in1)
	function DeleteVector4(num)

		// Vector4.remove(num)
		Vector4[num].used=0
		Vector4[num].x=0.0
		Vector4[num].y=0.0
		Vector4[num].z=0.0
		Vector4[num].w=0.0
		
		

	endfunction

// Vector4 add (result,in1,in2)
	function AddVector4(resultvec,vec1,vec2)
	
		Vector4[resultvec].x=Vector4[vec1].x + Vector4[vec2].x
		Vector4[resultvec].y=Vector4[vec1].y + Vector4[vec2].y
		Vector4[resultvec].z=Vector4[vec1].z + Vector4[vec2].z
		Vector4[resultvec].w=Vector4[vec1].w + Vector4[vec2].w

	endfunction

// Vector4 substract substract vec2 from vec1 into resultvec
	function SubstractVector4(resultvec,vec1,vec2)
	
		Vector4[resultvec].x=Vector4[vec1].x - Vector4[vec2].x
		Vector4[resultvec].y=Vector4[vec1].y - Vector4[vec2].y
		Vector4[resultvec].z=Vector4[vec1].z - Vector4[vec2].z
		Vector4[resultvec].w=Vector4[vec1].w - Vector4[vec2].w

	endfunction

// Vector4 set (vec,x,y,z,w)
	function SetVector4(resultvec,x as float,y as float,z as float,w as float)
	
		Vector4[resultvec].x=x
		Vector4[resultvec].y=y
		Vector4[resultvec].z=z
		Vector4[resultvec].w=w

	endfunction

// get vector4 x
	function GetVector4X(vec)
		out# = Vector4[vec].x
	endfunction out#

// get vector4 y
	function GetVector4Y(vec)
		out# = Vector4[vec].y
	endfunction out#	

// get vector4 z
	function GetVector4Z(vec)
		out# = Vector4[vec].z
	endfunction out#

// get vector4 w
	function GetVector4W(vec)
		out# = Vector4[vec].w
	endfunction out#


// matrix4 commands Library
// ========================


// create matrix4 (creates a new slot in the matrix4 4x4 array)
	function CreateMatrix4()

		if Matrix4.length=-1	// if the matrix4 array is empty, create a new one

			dim Matrix4[] as Matrix4_def

		endif

	
		// find free slot
			x = -1 
			repeat
			inc x
			if x>Matrix4.length // if no slot exists, create a new one
				Matrix4.length=Matrix4.length+1	
				exit
			endif

			until Matrix4[x].used=0
	
		out=x

	Matrix4[out].used=1 // set used to 1
		


	endfunction out
	
// deletes matrix4 from the matrix4 array
	function DeleteMatrix4(num)

				// Vector4.remove(num)
		Matrix4[num].used=0
		
		Matrix4[num].x.x=0.0 : Matrix4[num].y.x=0.0 : Matrix4[num].z.x=0.0 : Matrix4[num].w.x=0.0
		Matrix4[num].x.y=0.0 : Matrix4[num].y.y=0.0 : Matrix4[num].z.y=0.0 : Matrix4[num].w.y=0.0
		Matrix4[num].x.z=0.0 : Matrix4[num].y.z=0.0 : Matrix4[num].z.z=0.0 : Matrix4[num].w.z=0.0
		Matrix4[num].x.w=0.0 : Matrix4[num].y.w=0.0 : Matrix4[num].z.w=0.0 : Matrix4[num].w.w=0.0
		
			
		
		
			

	endfunction
	
// add matrix4 1 and matrix4 2 to resultmatrix4
	function AddMatrix4(resultmat,mat1,mat2)
	
		// x
		Matrix4[resultmat].x.x=Matrix4[mat1].x.x + Matrix4[mat2].x.x
		Matrix4[resultmat].x.y=Matrix4[mat1].x.y + Matrix4[mat2].x.y
		Matrix4[resultmat].x.z=Matrix4[mat1].x.z + Matrix4[mat2].x.z
		Matrix4[resultmat].x.w=Matrix4[mat1].x.w + Matrix4[mat2].x.w

		// y
		Matrix4[resultmat].y.x=Matrix4[mat1].y.x + Matrix4[mat2].y.x
		Matrix4[resultmat].y.y=Matrix4[mat1].y.y + Matrix4[mat2].y.y
		Matrix4[resultmat].y.z=Matrix4[mat1].y.z + Matrix4[mat2].y.z
		Matrix4[resultmat].y.w=Matrix4[mat1].y.w + Matrix4[mat2].y.w	

		// z
		Matrix4[resultmat].z.x=Matrix4[mat1].z.x + Matrix4[mat2].z.x
		Matrix4[resultmat].z.y=Matrix4[mat1].z.y + Matrix4[mat2].z.y
		Matrix4[resultmat].z.z=Matrix4[mat1].z.z + Matrix4[mat2].z.z
		Matrix4[resultmat].z.w=Matrix4[mat1].z.w + Matrix4[mat2].z.w		

		// w
		Matrix4[resultmat].w.x=Matrix4[mat1].w.x + Matrix4[mat2].w.x
		Matrix4[resultmat].w.y=Matrix4[mat1].w.y + Matrix4[mat2].w.y
		Matrix4[resultmat].w.z=Matrix4[mat1].w.z + Matrix4[mat2].w.z
		Matrix4[resultmat].w.w=Matrix4[mat1].w.w + Matrix4[mat2].w.w
	
	endfunction

// substract matrix4 2 from matrix4 1 to resultmatrix4
	function SubstractMatrix4(resultmat,mat1,mat2)
	
		// x
		Matrix4[resultmat].x.x=Matrix4[mat1].x.x - Matrix4[mat2].x.x
		Matrix4[resultmat].x.y=Matrix4[mat1].x.y - Matrix4[mat2].x.y
		Matrix4[resultmat].x.z=Matrix4[mat1].x.z - Matrix4[mat2].x.z
		Matrix4[resultmat].x.w=Matrix4[mat1].x.w - Matrix4[mat2].x.w

		// y
		Matrix4[resultmat].y.x=Matrix4[mat1].y.x - Matrix4[mat2].y.x
		Matrix4[resultmat].y.y=Matrix4[mat1].y.y - Matrix4[mat2].y.y
		Matrix4[resultmat].y.z=Matrix4[mat1].y.z - Matrix4[mat2].y.z
		Matrix4[resultmat].y.w=Matrix4[mat1].y.w - Matrix4[mat2].y.w	

		// z
		Matrix4[resultmat].z.x=Matrix4[mat1].z.x - Matrix4[mat2].z.x
		Matrix4[resultmat].z.y=Matrix4[mat1].z.y - Matrix4[mat2].z.y
		Matrix4[resultmat].z.z=Matrix4[mat1].z.z - Matrix4[mat2].z.z
		Matrix4[resultmat].z.w=Matrix4[mat1].z.w - Matrix4[mat2].z.w		

		// w
		Matrix4[resultmat].w.x=Matrix4[mat1].w.x - Matrix4[mat2].w.x
		Matrix4[resultmat].w.y=Matrix4[mat1].w.y - Matrix4[mat2].w.y
		Matrix4[resultmat].w.z=Matrix4[mat1].w.z - Matrix4[mat2].w.z
		Matrix4[resultmat].w.w=Matrix4[mat1].w.w - Matrix4[mat2].w.w
	
	endfunction	

// multiply matrix4 2 from matrix4 1 to resultmatrix4 or multiply resultmatrix4 with mat1 value
	function MultiplyMatrix4(resultmat,mat1 as float,mat2)
	
	
	if mat2=-1 // if mat2 is entered with -1, mat1 will become the multiply value
		
		
		// multiply matrix by value
			// x
			Matrix4[resultmat].x.x=Matrix4[resultmat].x.x * mat1
			Matrix4[resultmat].x.y=Matrix4[resultmat].x.y * mat1
			Matrix4[resultmat].x.z=Matrix4[resultmat].x.z * mat1
			Matrix4[resultmat].x.w=Matrix4[resultmat].x.w * mat1

			// y
			Matrix4[resultmat].y.x=Matrix4[resultmat].y.x * mat1
			Matrix4[resultmat].y.y=Matrix4[resultmat].y.y * mat1
			Matrix4[resultmat].y.z=Matrix4[resultmat].y.z * mat1
			Matrix4[resultmat].y.w=Matrix4[resultmat].y.w * mat1	

			// z
			Matrix4[resultmat].z.x=Matrix4[resultmat].z.x * mat1
			Matrix4[resultmat].z.y=Matrix4[resultmat].z.y * mat1
			Matrix4[resultmat].z.z=Matrix4[resultmat].z.z * mat1
			Matrix4[resultmat].z.w=Matrix4[resultmat].z.w * mat1		

			// w
			Matrix4[resultmat].w.x=Matrix4[resultmat].w.x * mat1
			Matrix4[resultmat].w.y=Matrix4[resultmat].w.y * mat1
			Matrix4[resultmat].w.z=Matrix4[resultmat].w.z * mat1
			Matrix4[resultmat].w.w=Matrix4[resultmat].w.w * mat1	
		
	else
			
		// multiply 2 matrices
			// x
			Matrix4[resultmat].x.x=Matrix4[val(str(mat1))].x.x * Matrix4[mat2].x.x
			Matrix4[resultmat].x.y=Matrix4[val(str(mat1))].x.y * Matrix4[mat2].x.y
			Matrix4[resultmat].x.z=Matrix4[val(str(mat1))].x.z * Matrix4[mat2].x.z
			Matrix4[resultmat].x.w=Matrix4[val(str(mat1))].x.w * Matrix4[mat2].x.w

			// y
			Matrix4[resultmat].y.x=Matrix4[val(str(mat1))].y.x * Matrix4[mat2].y.x
			Matrix4[resultmat].y.y=Matrix4[val(str(mat1))].y.y * Matrix4[mat2].y.y
			Matrix4[resultmat].y.z=Matrix4[val(str(mat1))].y.z * Matrix4[mat2].y.z
			Matrix4[resultmat].y.w=Matrix4[val(str(mat1))].y.w * Matrix4[mat2].y.w	

			// z
			Matrix4[resultmat].z.x=Matrix4[val(str(mat1))].z.x * Matrix4[mat2].z.x
			Matrix4[resultmat].z.y=Matrix4[val(str(mat1))].z.y * Matrix4[mat2].z.y
			Matrix4[resultmat].z.z=Matrix4[val(str(mat1))].z.z * Matrix4[mat2].z.z
			Matrix4[resultmat].z.w=Matrix4[val(str(mat1))].z.w * Matrix4[mat2].z.w		

			// w
			Matrix4[resultmat].w.x=Matrix4[val(str(mat1))].w.x * Matrix4[mat2].w.x
			Matrix4[resultmat].w.y=Matrix4[val(str(mat1))].w.y * Matrix4[mat2].w.y
			Matrix4[resultmat].w.z=Matrix4[val(str(mat1))].w.z * Matrix4[mat2].w.z
			Matrix4[resultmat].w.w=Matrix4[val(str(mat1))].w.w * Matrix4[mat2].w.w

	endif

	endfunction	
	
// divide matrix4 2 from matrix4 1 to resultmatrix4 or divide matrix4 1 by the mat1 value
	function DivideMatrix4(resultmat,mat1 as float,mat2)
	
	
	if mat2=-1 // if mat2 is entered with -1, mat1 will become the multiply value
		
		
		// multiply matrix by value
			// x
			Matrix4[resultmat].x.x=Matrix4[resultmat].x.x / mat1
			Matrix4[resultmat].x.y=Matrix4[resultmat].x.y / mat1
			Matrix4[resultmat].x.z=Matrix4[resultmat].x.z / mat1
			Matrix4[resultmat].x.w=Matrix4[resultmat].x.w / mat1

			// y
			Matrix4[resultmat].y.x=Matrix4[resultmat].y.x / mat1
			Matrix4[resultmat].y.y=Matrix4[resultmat].y.y / mat1
			Matrix4[resultmat].y.z=Matrix4[resultmat].y.z / mat1
			Matrix4[resultmat].y.w=Matrix4[resultmat].y.w / mat1	

			// z
			Matrix4[resultmat].z.x=Matrix4[resultmat].z.x / mat1
			Matrix4[resultmat].z.y=Matrix4[resultmat].z.y / mat1
			Matrix4[resultmat].z.z=Matrix4[resultmat].z.z / mat1
			Matrix4[resultmat].z.w=Matrix4[resultmat].z.w / mat1		

			// w
			Matrix4[resultmat].w.x=Matrix4[resultmat].w.x / mat1
			Matrix4[resultmat].w.y=Matrix4[resultmat].w.y / mat1
			Matrix4[resultmat].w.z=Matrix4[resultmat].w.z / mat1
			Matrix4[resultmat].w.w=Matrix4[resultmat].w.w / mat1	
		
	else
			
		// multiply 2 matrices
			// x
			Matrix4[resultmat].x.x=Matrix4[val(str(mat1))].x.x / Matrix4[mat2].x.x
			Matrix4[resultmat].x.y=Matrix4[val(str(mat1))].x.y / Matrix4[mat2].x.y
			Matrix4[resultmat].x.z=Matrix4[val(str(mat1))].x.z / Matrix4[mat2].x.z
			Matrix4[resultmat].x.w=Matrix4[val(str(mat1))].x.w / Matrix4[mat2].x.w

			// y
			Matrix4[resultmat].y.x=Matrix4[val(str(mat1))].y.x / Matrix4[mat2].y.x
			Matrix4[resultmat].y.y=Matrix4[val(str(mat1))].y.y / Matrix4[mat2].y.y
			Matrix4[resultmat].y.z=Matrix4[val(str(mat1))].y.z / Matrix4[mat2].y.z
			Matrix4[resultmat].y.w=Matrix4[val(str(mat1))].y.w / Matrix4[mat2].y.w	

			// z
			Matrix4[resultmat].z.x=Matrix4[val(str(mat1))].z.x / Matrix4[mat2].z.x
			Matrix4[resultmat].z.y=Matrix4[val(str(mat1))].z.y / Matrix4[mat2].z.y
			Matrix4[resultmat].z.z=Matrix4[val(str(mat1))].z.z / Matrix4[mat2].z.z
			Matrix4[resultmat].z.w=Matrix4[val(str(mat1))].z.w / Matrix4[mat2].z.w		

			// w
			Matrix4[resultmat].w.x=Matrix4[val(str(mat1))].w.x / Matrix4[mat2].w.x
			Matrix4[resultmat].w.y=Matrix4[val(str(mat1))].w.y / Matrix4[mat2].w.y
			Matrix4[resultmat].w.z=Matrix4[val(str(mat1))].w.z / Matrix4[mat2].w.z
			Matrix4[resultmat].w.w=Matrix4[val(str(mat1))].w.w / Matrix4[mat2].w.w

	endif

	endfunction		

// set matrix4 element (ele = 0 to 15)
	function SetMatrix4Element(mat,ele,value#)
		
		select ele
			
// x 
			case 0:
				Matrix4[mat].x.x = value#
			endcase

			case 1:
				Matrix4[mat].x.y = value#
			endcase

			case 2:
				Matrix4[mat].x.z = value#
			endcase			

			case 3:
				Matrix4[mat].x.w = value#
			endcase

// y 
			case 4:
				Matrix4[mat].y.x = value#
			endcase

			case 5:
				Matrix4[mat].y.y = value#
			endcase

			case 6:
				Matrix4[mat].y.z = value#
			endcase			

			case 7:
				Matrix4[mat].y.w = value#
			endcase

// z 
			case 8:
				Matrix4[mat].z.x = value#
			endcase

			case 9:
				Matrix4[mat].z.y = value#
			endcase

			case 10:
				Matrix4[mat].z.z = value#
			endcase			

			case 11:
				Matrix4[mat].z.w = value#
			endcase

// z 
			case 12:
				Matrix4[mat].w.x = value#
			endcase

			case 13:
				Matrix4[mat].w.y = value#
			endcase

			case 14:
				Matrix4[mat].w.z = value#
			endcase			

			case 15:
				Matrix4[mat].w.w = value#
			endcase
		
		endselect
		
	
	endfunction

// get matrix4 element (ele = 0 to 15)
	function GetMatrix4Element(mat,ele)
		
		select ele
			
// x 
			case 0:
				result# = Matrix4[mat].x.x
			endcase

			case 1:
				result# = Matrix4[mat].x.y
			endcase

			case 2:
				result# = Matrix4[mat].x.z
			endcase			

			case 3:
				result# = Matrix4[mat].x.w
			endcase

// y 
			case 4:
				result# = Matrix4[mat].y.x
			endcase

			case 5:
				result# = Matrix4[mat].y.y
			endcase

			case 6:
				result# = Matrix4[mat].y.z
			endcase			

			case 7:
				result# = Matrix4[mat].y.w
			endcase

// z 
			case 8:
				result# = Matrix4[mat].z.x
			endcase

			case 9:
				result# = Matrix4[mat].z.y
			endcase

			case 10:
				result# = Matrix4[mat].z.z
			endcase			

			case 11:
				result# = Matrix4[mat].z.w
			endcase

// z 
			case 12:
				result# = Matrix4[mat].w.x
			endcase

			case 13:
				result# = Matrix4[mat].w.y
			endcase

			case 14:
				result# = Matrix4[mat].w.z
			endcase			

			case 15:
				result# = Matrix4[mat].w.w
			endcase
		
		endselect
		
	
	endfunction result#
	
// set matrix4 (matrix4, 16 floats)
	function SetMatrix4(mat, f0 as float, f1 as float, f2 as float, f3 as float, f4 as float, f5 as float, f6 as float, f7 as float, f8 as float, f9 as float, f10 as float, f11 as float, f12 as float, f13 as float, f14 as float, f15 as float)
		
	// x
		Matrix4[mat].x.x = f0
		Matrix4[mat].x.y = f1
		Matrix4[mat].x.z = f2
		Matrix4[mat].x.w = f3

	// y
		Matrix4[mat].y.x = f4
		Matrix4[mat].y.y = f5
		Matrix4[mat].y.z = f6
		Matrix4[mat].y.w = f7
		
	// z
		Matrix4[mat].z.x = f8
		Matrix4[mat].z.y = f9
		Matrix4[mat].z.z = f10
		Matrix4[mat].z.w = f11
		
	// w
		Matrix4[mat].w.x = f12
		Matrix4[mat].w.y = f13
		Matrix4[mat].w.z = f14
		Matrix4[mat].w.w = f15				
		 
	endfunction

// projection matrix
	function ProjectionMatrix4(mat, fov as float, aspect as float, nearDist as float, farDist)

	frustumDepth as float
	oneOverDepth as float
		


	frustumDepth = farDist - nearDist
	oneOverDepth = 1 / frustumDepth


		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1/tan(fov*0.5)   : Matrix4[mat].y.x = 0	 					: 	Matrix4[mat].z.x = 0										: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0				: Matrix4[mat].y.y = farDist * oneOverDepth : 	Matrix4[mat].z.y = 0										: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0				: Matrix4[mat].y.z = 0	 					: 	Matrix4[mat].z.z = farDist * oneOverDepth					: Matrix4[mat].w.z = 1
			Matrix4[mat].x.w = 0				: Matrix4[mat].y.w = 0	 					: 	Matrix4[mat].z.w = (-farDist * nearDist) * oneOverDepth		: Matrix4[mat].w.w = 0
			

	endfunction

// translate Matrix 4
	function TranslateMatrix4(mat, x as float, y as float, z as float)


		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1 : Matrix4[mat].y.x = 0 : 	Matrix4[mat].z.x = 0 : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0 : Matrix4[mat].y.y = 1 : 	Matrix4[mat].z.y = 0 : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0 : Matrix4[mat].y.z = 0 : 	Matrix4[mat].z.z = 1 : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = x : Matrix4[mat].y.w = y : 	Matrix4[mat].z.w = z : Matrix4[mat].w.w = 1

	endfunction

// X Rotate Matrix 4
	function RotateXMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1 : Matrix4[mat].y.x = 0 		 : 	Matrix4[mat].z.x = 0 		  : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0 : Matrix4[mat].y.y = cos(angle) : 	Matrix4[mat].z.y = sin(angle) : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0 : Matrix4[mat].y.z = -sin(angle): 	Matrix4[mat].z.z = cos(angle) : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 : Matrix4[mat].y.w = 0 		 : 	Matrix4[mat].z.w = 0 		  : Matrix4[mat].w.w = 1
		
	endfunction

// Y Rotate Matrix 4
	function RotateYMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = cos(angle) : Matrix4[mat].y.x = 0 		 : 	Matrix4[mat].z.x = -sin(angle) : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0		  : Matrix4[mat].y.y = 1		 : 	Matrix4[mat].z.y = 0		   : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = sin(angle) : Matrix4[mat].y.z = 0		 : 	Matrix4[mat].z.z = cos(angle)  : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 		  : Matrix4[mat].y.w = 0 		 : 	Matrix4[mat].z.w = 0 		   : Matrix4[mat].w.w = 1
					
	endfunction

// Z Rotate Matrix 4
	function RotateZMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = cos(angle)  : Matrix4[mat].y.x = sin(angle) 	: 	Matrix4[mat].z.x = 0	: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = -sin(angle) : Matrix4[mat].y.y = cos(angle)	: 	Matrix4[mat].z.y = 0	: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0		   : Matrix4[mat].y.z = 0			: 	Matrix4[mat].z.z = 1	: Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 		   : Matrix4[mat].y.w = 0 		 	: 	Matrix4[mat].z.w = 0	: Matrix4[mat].w.w = 1		
		
	endfunction
           
// View Matrix 4    
function ViewMatrix4(xVecID, yVecID, zVecID, posVecID, matRotID, matViewID, matTempRotID)
   SetIdentityMatrix4(matViewID)
 
   setvector3(posVecID, getcamerax(1), getcameray(1), getcameraz(1) )

 
   RotateZMatrix4( matRotID, radian(cameraAngleZ(1)) )
   RotateYMatrix4( matTempRotID, radian(cameraAngleY(1)) )
   MultiplyMatrix4(matRotID, matRotID, matTempRotID)
   RotateXMatrix4( matTempRotID, radian(cameraAngleX(1)) )
   MultiplyMatrix4(matRotID, matRotID, matTempRotID)
 
   setvector3(xVecID, 1.0, 0.0, 0.0 )
   setvector3(yVecID, 0.0, 1.0, 0.0 )
   setvector3(zVecID, 0.0, 0.0, 1.0 )
 
   TransformCoordsVector3(xVecID, matRotID)
   TransformCoordsVector3(yVecID, matRotID)
   TransformCoordsVector3(zVecID, matRotID)
 
   SetMatrix4Element(matViewID, 0, GetVector3X(xVecID) )
   SetMatrix4Element(matViewID, 1, GetVector3X(yVecID) )
   SetMatrix4Element(matViewID, 2, GetVector3X(zVecID) )
 
   SetMatrix4Element(matViewID, 4, GetVector3Y(xVecID) )
   SetMatrix4Element(matViewID, 5, GetVector3Y(yVecID) )
   SetMatrix4Element(matViewID, 6, GetVector3Y(zVecID) )
 
   SetMatrix4Element(matViewID, 8, GetVector3Z(xVecID) )
   SetMatrix4Element(matViewID, 9, GetVector3Z(yVecID) )
   SetMatrix4Element(matViewID, 10,GetVector3Z(zVecID) )
 
   SetMatrix4Element(matViewID, 12, -GetVector3Dot(posVecID, xVecID) )
   SetMatrix4Element(matViewID, 13, -GetVector3Dot(posVecID, yVecID) )
   SetMatrix4Element(matViewID, 14, -GetVector3Dot(posVecID, zVecID) )
endfunction



// Not finished commands:

// Identity Matrix 4
	function SetIdentityMatrix4(mat)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1  : Matrix4[mat].y.x = 0 	: 	Matrix4[mat].z.x = 0	: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0  : Matrix4[mat].y.y = 1	: 	Matrix4[mat].z.y = 0	: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0  : Matrix4[mat].y.z = 0	: 	Matrix4[mat].z.z = 1	: Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0  : Matrix4[mat].y.w = 0 	: 	Matrix4[mat].z.w = 0	: Matrix4[mat].w.w = 1			
		
	endfunction 

// Inverse Matrix 4
	function InverseMatrix4(mresult, msource)
	endfunction
					
// Build Look at lh matrix	
	function BuildLookAtLhMatrix4()
	endfunction


// various math commands
// ==================

// this function will convert an euler angle to a radian angle
function radian(eul#)

	out# = eul# * 180 / Math_PI // conversion to degrees
	if( out# < 0 ) then out# = out# + 360.0 // convert negative to positive angles
	
endfunction out#

// ==================================================================================
// ======    Extended math function for AGK    ======================================
// ========================================= 2016================  0.20  ============
// ==================================================================================
// ==== Jack('the baby stuff), WickedX('the hard stuff) =============================
// ==================================================================================


/*	Changelog
	
	Version 0.1
	===========
	
	
		Vector 3 (already existing, but incomplete commandset)
			- added normalize vector 3 command
		
			
		Vector 4 (new command set)
			- added vector4 create command
			- added vector4 delete command
			- added vector4 add command
			- added vector4 substract command
			- added vector4 set command
			- added vector4 get x,y,z,w commands
		
			
		Matrix 4 (new command set)
			- added matrix 4 create command
			- added matrix 4 delete command
			- added matrix 4 add command
			- added matrix 4 multiply command
			- added matrix 4 divide command
			- added matrix 4 get element command
			- added matrix 4 set command
	
	
	
	Version 0.12
	============
	
		Bug Fixes
			- Fixed a major bug at deleting matrix4 and vector4 arrays (deleting caused missing links)
			
	
		Matrix 4
			- added matrix 4 Projection Matrix 4 command
			- added matrix 4 Translate Matrix 4 command
			


	Version 0.14
	============

		Bug Fixes
			- Matrix multiplication is corrected (was wronger than wrong)
			
	
	
		Vector 3
			- added TransformCoordsVector3 command 
			
		Matrix 4
			- added matrix 4 rotation Matrix 4 commands (x,y,z)
			- added Set Matrix 4 Element command (0 - 15)
			- set identity matrix4 comnmand 
			
			
			

	
				
	Version 0.2:
	============
	
		Vector 3
			- added SubstractVector3 command
			- Build Look At LhMatrix4 command
	






			
		Work in Progress (Not finished, but have to be done to get really serious with 3d math):
			- transform normals vector3 command
			- Inverse Matrix4 command		
			- Intense debugging



			

Forum thread: https://forum.thegamecreators.com/thread/217064#msg2582798		
	
========================================================================		
*/






/*


// types
type Vec4_def

	x as float
	y as float
	z as float
	w as float
endtype

type Vector4_def
	used as integer
	x as float
	y as float
	z as float
	w as float
endtype




type Matrix4_def
	used as integer
	x as Vec4_def
	y as Vec4_def
	z as Vec4_def
	w as Vec4_def
endtype

*/


// Math Constants
// ==============

#constant Math_PI	3.14159







// extended vector3 commands Library
// =================================

// Vector3 substract substract vec2 from vec1 into resultvec
	function SubstractVector3(resultvec,vec1,vec2)
	
		Vector4[resultvec].x=Vector4[vec1].x - Vector4[vec2].x
		Vector4[resultvec].y=Vector4[vec1].y - Vector4[vec2].y
		Vector4[resultvec].z=Vector4[vec1].z - Vector4[vec2].z

	endfunction

// normalize vector (from source to result)
	function normalizeVector3(vsource)
		
		d# = getVector3Length(vsource)
		
		 x# = GetVector3X(vsource) / d#
		 y# = GetVector3Y(vsource) / d#
		 z# = GetVector3Z(vsource) / d#
		
		SetVector3(vsource,x#,y#,z#) // update source vector
		
	endfunction 

// Transform Coords Vector 3
	function TransformCoordsVector3(VecID, MatID)
	   norm as float
	   x as float
	   y as float
	   z as float
	 

	 
	   norm = GetMatrix4Element(MatID, 3)*GetVector3X(VecID)+GetMatrix4Element(MatID, 7)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 11)+GetMatrix4Element(MatID, 15)
	 
	   if (norm)>0.0
		  x = (GetMatrix4Element(MatID, 0)*GetVector3X(VecID)+GetMatrix4Element(MatID, 4)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 8)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 12))/norm
		  y = (GetMatrix4Element(MatID, 1)*GetVector3X(VecID)+GetMatrix4Element(MatID, 5)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 9)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 13))/norm
		  z = (GetMatrix4Element(MatID, 2)*GetVector3X(VecID)+GetMatrix4Element(MatID, 6)*GetVector3Y(VecID)+GetMatrix4Element(MatID, 10)*GetVector3Z(VecID)+GetMatrix4Element(MatID, 14))/norm
	   else
		  x = 0.0
		  y = 0.0
		  z = 0.0
	   endif
	 
	   setvector3(VecID, x, y, z)
	endfunction


// this should be a good feature : 

// transform normals vector3
	function TransformNormalsVector3(vsource, msource)
	endfunction






// vector4 commands Library
// ========================


// create vector4
function CreateVector4()

			if Vector4.length=-1
			
				dim Vector4[] as Vector4_def
			
			endif

		// find free slot
		x = -1 
		repeat
		inc x
		if x>Vector4.length // if no slot exists, create a new one
			Vector4.length=Vector4.length+1	
			exit
		endif

		until Vector4[x].used=0
			
				out=x

			Vector4[out].used=1 // set used to 1

endfunction out

// delete vector4 (in1)
	function DeleteVector4(num)

		// Vector4.remove(num)
		Vector4[num].used=0
		Vector4[num].x=0.0
		Vector4[num].y=0.0
		Vector4[num].z=0.0
		Vector4[num].w=0.0
		
		

	endfunction

// Vector4 add (result,in1,in2)
	function AddVector4(resultvec,vec1,vec2)
	
		Vector4[resultvec].x=Vector4[vec1].x + Vector4[vec2].x
		Vector4[resultvec].y=Vector4[vec1].y + Vector4[vec2].y
		Vector4[resultvec].z=Vector4[vec1].z + Vector4[vec2].z
		Vector4[resultvec].w=Vector4[vec1].w + Vector4[vec2].w

	endfunction

// Vector4 substract substract vec2 from vec1 into resultvec
	function SubstractVector4(resultvec,vec1,vec2)
	
		Vector4[resultvec].x=Vector4[vec1].x - Vector4[vec2].x
		Vector4[resultvec].y=Vector4[vec1].y - Vector4[vec2].y
		Vector4[resultvec].z=Vector4[vec1].z - Vector4[vec2].z
		Vector4[resultvec].w=Vector4[vec1].w - Vector4[vec2].w

	endfunction

// Vector4 set (vec,x,y,z,w)
	function SetVector4(resultvec,x as float,y as float,z as float,w as float)
	
		Vector4[resultvec].x=x
		Vector4[resultvec].y=y
		Vector4[resultvec].z=z
		Vector4[resultvec].w=w

	endfunction

// get vector4 x
	function GetVector4X(vec)
		out# = Vector4[vec].x
	endfunction out#

// get vector4 y
	function GetVector4Y(vec)
		out# = Vector4[vec].y
	endfunction out#	

// get vector4 z
	function GetVector4Z(vec)
		out# = Vector4[vec].z
	endfunction out#

// get vector4 w
	function GetVector4W(vec)
		out# = Vector4[vec].w
	endfunction out#


// matrix4 commands Library
// ========================


// create matrix4 (creates a new slot in the matrix4 4x4 array)
	function CreateMatrix4()

		if Matrix4.length=-1	// if the matrix4 array is empty, create a new one

			dim Matrix4[] as Matrix4_def

		endif

	
		// find free slot
			x = -1 
			repeat
			inc x
			if x>Matrix4.length // if no slot exists, create a new one
				Matrix4.length=Matrix4.length+1	
				exit
			endif

			until Matrix4[x].used=0
	
		out=x

	Matrix4[out].used=1 // set used to 1
		


	endfunction out
	
// deletes matrix4 from the matrix4 array
	function DeleteMatrix4(num)

				// Vector4.remove(num)
		Matrix4[num].used=0
		
		Matrix4[num].x.x=0.0 : Matrix4[num].y.x=0.0 : Matrix4[num].z.x=0.0 : Matrix4[num].w.x=0.0
		Matrix4[num].x.y=0.0 : Matrix4[num].y.y=0.0 : Matrix4[num].z.y=0.0 : Matrix4[num].w.y=0.0
		Matrix4[num].x.z=0.0 : Matrix4[num].y.z=0.0 : Matrix4[num].z.z=0.0 : Matrix4[num].w.z=0.0
		Matrix4[num].x.w=0.0 : Matrix4[num].y.w=0.0 : Matrix4[num].z.w=0.0 : Matrix4[num].w.w=0.0
		
			
		
		
			

	endfunction
	
// add matrix4 1 and matrix4 2 to resultmatrix4
	function AddMatrix4(resultmat,mat1,mat2)
	
		// x
		Matrix4[resultmat].x.x=Matrix4[mat1].x.x + Matrix4[mat2].x.x
		Matrix4[resultmat].x.y=Matrix4[mat1].x.y + Matrix4[mat2].x.y
		Matrix4[resultmat].x.z=Matrix4[mat1].x.z + Matrix4[mat2].x.z
		Matrix4[resultmat].x.w=Matrix4[mat1].x.w + Matrix4[mat2].x.w

		// y
		Matrix4[resultmat].y.x=Matrix4[mat1].y.x + Matrix4[mat2].y.x
		Matrix4[resultmat].y.y=Matrix4[mat1].y.y + Matrix4[mat2].y.y
		Matrix4[resultmat].y.z=Matrix4[mat1].y.z + Matrix4[mat2].y.z
		Matrix4[resultmat].y.w=Matrix4[mat1].y.w + Matrix4[mat2].y.w	

		// z
		Matrix4[resultmat].z.x=Matrix4[mat1].z.x + Matrix4[mat2].z.x
		Matrix4[resultmat].z.y=Matrix4[mat1].z.y + Matrix4[mat2].z.y
		Matrix4[resultmat].z.z=Matrix4[mat1].z.z + Matrix4[mat2].z.z
		Matrix4[resultmat].z.w=Matrix4[mat1].z.w + Matrix4[mat2].z.w		

		// w
		Matrix4[resultmat].w.x=Matrix4[mat1].w.x + Matrix4[mat2].w.x
		Matrix4[resultmat].w.y=Matrix4[mat1].w.y + Matrix4[mat2].w.y
		Matrix4[resultmat].w.z=Matrix4[mat1].w.z + Matrix4[mat2].w.z
		Matrix4[resultmat].w.w=Matrix4[mat1].w.w + Matrix4[mat2].w.w
	
	endfunction

// substract matrix4 2 from matrix4 1 to resultmatrix4
	function SubstractMatrix4(resultmat,mat1,mat2)
	
		// x
		Matrix4[resultmat].x.x=Matrix4[mat1].x.x - Matrix4[mat2].x.x
		Matrix4[resultmat].x.y=Matrix4[mat1].x.y - Matrix4[mat2].x.y
		Matrix4[resultmat].x.z=Matrix4[mat1].x.z - Matrix4[mat2].x.z
		Matrix4[resultmat].x.w=Matrix4[mat1].x.w - Matrix4[mat2].x.w

		// y
		Matrix4[resultmat].y.x=Matrix4[mat1].y.x - Matrix4[mat2].y.x
		Matrix4[resultmat].y.y=Matrix4[mat1].y.y - Matrix4[mat2].y.y
		Matrix4[resultmat].y.z=Matrix4[mat1].y.z - Matrix4[mat2].y.z
		Matrix4[resultmat].y.w=Matrix4[mat1].y.w - Matrix4[mat2].y.w	

		// z
		Matrix4[resultmat].z.x=Matrix4[mat1].z.x - Matrix4[mat2].z.x
		Matrix4[resultmat].z.y=Matrix4[mat1].z.y - Matrix4[mat2].z.y
		Matrix4[resultmat].z.z=Matrix4[mat1].z.z - Matrix4[mat2].z.z
		Matrix4[resultmat].z.w=Matrix4[mat1].z.w - Matrix4[mat2].z.w		

		// w
		Matrix4[resultmat].w.x=Matrix4[mat1].w.x - Matrix4[mat2].w.x
		Matrix4[resultmat].w.y=Matrix4[mat1].w.y - Matrix4[mat2].w.y
		Matrix4[resultmat].w.z=Matrix4[mat1].w.z - Matrix4[mat2].w.z
		Matrix4[resultmat].w.w=Matrix4[mat1].w.w - Matrix4[mat2].w.w
	
	endfunction	

// multiply matrix4 2 from matrix4 1 to resultmatrix4 or multiply resultmatrix4 with mat1 value
	function MultiplyMatrix4(resultmat,mat1 as float,mat2)
	
	
	if mat2=-1 // if mat2 is entered with -1, mat1 will become the multiply value
		
		
		// multiply matrix by value
			// x
			Matrix4[resultmat].x.x=Matrix4[resultmat].x.x * mat1
			Matrix4[resultmat].x.y=Matrix4[resultmat].x.y * mat1
			Matrix4[resultmat].x.z=Matrix4[resultmat].x.z * mat1
			Matrix4[resultmat].x.w=Matrix4[resultmat].x.w * mat1

			// y
			Matrix4[resultmat].y.x=Matrix4[resultmat].y.x * mat1
			Matrix4[resultmat].y.y=Matrix4[resultmat].y.y * mat1
			Matrix4[resultmat].y.z=Matrix4[resultmat].y.z * mat1
			Matrix4[resultmat].y.w=Matrix4[resultmat].y.w * mat1	

			// z
			Matrix4[resultmat].z.x=Matrix4[resultmat].z.x * mat1
			Matrix4[resultmat].z.y=Matrix4[resultmat].z.y * mat1
			Matrix4[resultmat].z.z=Matrix4[resultmat].z.z * mat1
			Matrix4[resultmat].z.w=Matrix4[resultmat].z.w * mat1		

			// w
			Matrix4[resultmat].w.x=Matrix4[resultmat].w.x * mat1
			Matrix4[resultmat].w.y=Matrix4[resultmat].w.y * mat1
			Matrix4[resultmat].w.z=Matrix4[resultmat].w.z * mat1
			Matrix4[resultmat].w.w=Matrix4[resultmat].w.w * mat1	
		
	else
			
		// multiply 2 matrices
			// x
			Matrix4[resultmat].x.x=Matrix4[val(str(mat1))].x.x * Matrix4[mat2].x.x
			Matrix4[resultmat].x.y=Matrix4[val(str(mat1))].x.y * Matrix4[mat2].x.y
			Matrix4[resultmat].x.z=Matrix4[val(str(mat1))].x.z * Matrix4[mat2].x.z
			Matrix4[resultmat].x.w=Matrix4[val(str(mat1))].x.w * Matrix4[mat2].x.w

			// y
			Matrix4[resultmat].y.x=Matrix4[val(str(mat1))].y.x * Matrix4[mat2].y.x
			Matrix4[resultmat].y.y=Matrix4[val(str(mat1))].y.y * Matrix4[mat2].y.y
			Matrix4[resultmat].y.z=Matrix4[val(str(mat1))].y.z * Matrix4[mat2].y.z
			Matrix4[resultmat].y.w=Matrix4[val(str(mat1))].y.w * Matrix4[mat2].y.w	

			// z
			Matrix4[resultmat].z.x=Matrix4[val(str(mat1))].z.x * Matrix4[mat2].z.x
			Matrix4[resultmat].z.y=Matrix4[val(str(mat1))].z.y * Matrix4[mat2].z.y
			Matrix4[resultmat].z.z=Matrix4[val(str(mat1))].z.z * Matrix4[mat2].z.z
			Matrix4[resultmat].z.w=Matrix4[val(str(mat1))].z.w * Matrix4[mat2].z.w		

			// w
			Matrix4[resultmat].w.x=Matrix4[val(str(mat1))].w.x * Matrix4[mat2].w.x
			Matrix4[resultmat].w.y=Matrix4[val(str(mat1))].w.y * Matrix4[mat2].w.y
			Matrix4[resultmat].w.z=Matrix4[val(str(mat1))].w.z * Matrix4[mat2].w.z
			Matrix4[resultmat].w.w=Matrix4[val(str(mat1))].w.w * Matrix4[mat2].w.w

	endif

	endfunction	
	
// divide matrix4 2 from matrix4 1 to resultmatrix4 or divide matrix4 1 by the mat1 value
	function DivideMatrix4(resultmat,mat1 as float,mat2)
	
	
	if mat2=-1 // if mat2 is entered with -1, mat1 will become the multiply value
		
		
		// multiply matrix by value
			// x
			Matrix4[resultmat].x.x=Matrix4[resultmat].x.x / mat1
			Matrix4[resultmat].x.y=Matrix4[resultmat].x.y / mat1
			Matrix4[resultmat].x.z=Matrix4[resultmat].x.z / mat1
			Matrix4[resultmat].x.w=Matrix4[resultmat].x.w / mat1

			// y
			Matrix4[resultmat].y.x=Matrix4[resultmat].y.x / mat1
			Matrix4[resultmat].y.y=Matrix4[resultmat].y.y / mat1
			Matrix4[resultmat].y.z=Matrix4[resultmat].y.z / mat1
			Matrix4[resultmat].y.w=Matrix4[resultmat].y.w / mat1	

			// z
			Matrix4[resultmat].z.x=Matrix4[resultmat].z.x / mat1
			Matrix4[resultmat].z.y=Matrix4[resultmat].z.y / mat1
			Matrix4[resultmat].z.z=Matrix4[resultmat].z.z / mat1
			Matrix4[resultmat].z.w=Matrix4[resultmat].z.w / mat1		

			// w
			Matrix4[resultmat].w.x=Matrix4[resultmat].w.x / mat1
			Matrix4[resultmat].w.y=Matrix4[resultmat].w.y / mat1
			Matrix4[resultmat].w.z=Matrix4[resultmat].w.z / mat1
			Matrix4[resultmat].w.w=Matrix4[resultmat].w.w / mat1	
		
	else
			
		// multiply 2 matrices
			// x
			Matrix4[resultmat].x.x=Matrix4[val(str(mat1))].x.x / Matrix4[mat2].x.x
			Matrix4[resultmat].x.y=Matrix4[val(str(mat1))].x.y / Matrix4[mat2].x.y
			Matrix4[resultmat].x.z=Matrix4[val(str(mat1))].x.z / Matrix4[mat2].x.z
			Matrix4[resultmat].x.w=Matrix4[val(str(mat1))].x.w / Matrix4[mat2].x.w

			// y
			Matrix4[resultmat].y.x=Matrix4[val(str(mat1))].y.x / Matrix4[mat2].y.x
			Matrix4[resultmat].y.y=Matrix4[val(str(mat1))].y.y / Matrix4[mat2].y.y
			Matrix4[resultmat].y.z=Matrix4[val(str(mat1))].y.z / Matrix4[mat2].y.z
			Matrix4[resultmat].y.w=Matrix4[val(str(mat1))].y.w / Matrix4[mat2].y.w	

			// z
			Matrix4[resultmat].z.x=Matrix4[val(str(mat1))].z.x / Matrix4[mat2].z.x
			Matrix4[resultmat].z.y=Matrix4[val(str(mat1))].z.y / Matrix4[mat2].z.y
			Matrix4[resultmat].z.z=Matrix4[val(str(mat1))].z.z / Matrix4[mat2].z.z
			Matrix4[resultmat].z.w=Matrix4[val(str(mat1))].z.w / Matrix4[mat2].z.w		

			// w
			Matrix4[resultmat].w.x=Matrix4[val(str(mat1))].w.x / Matrix4[mat2].w.x
			Matrix4[resultmat].w.y=Matrix4[val(str(mat1))].w.y / Matrix4[mat2].w.y
			Matrix4[resultmat].w.z=Matrix4[val(str(mat1))].w.z / Matrix4[mat2].w.z
			Matrix4[resultmat].w.w=Matrix4[val(str(mat1))].w.w / Matrix4[mat2].w.w

	endif

	endfunction		

// set matrix4 element (ele = 0 to 15)
	function SetMatrix4Element(mat,ele,value#)
		
		select ele
			
// x 
			case 0:
				Matrix4[mat].x.x = value#
			endcase

			case 1:
				Matrix4[mat].x.y = value#
			endcase

			case 2:
				Matrix4[mat].x.z = value#
			endcase			

			case 3:
				Matrix4[mat].x.w = value#
			endcase

// y 
			case 4:
				Matrix4[mat].y.x = value#
			endcase

			case 5:
				Matrix4[mat].y.y = value#
			endcase

			case 6:
				Matrix4[mat].y.z = value#
			endcase			

			case 7:
				Matrix4[mat].y.w = value#
			endcase

// z 
			case 8:
				Matrix4[mat].z.x = value#
			endcase

			case 9:
				Matrix4[mat].z.y = value#
			endcase

			case 10:
				Matrix4[mat].z.z = value#
			endcase			

			case 11:
				Matrix4[mat].z.w = value#
			endcase

// z 
			case 12:
				Matrix4[mat].w.x = value#
			endcase

			case 13:
				Matrix4[mat].w.y = value#
			endcase

			case 14:
				Matrix4[mat].w.z = value#
			endcase			

			case 15:
				Matrix4[mat].w.w = value#
			endcase
		
		endselect
		
	
	endfunction

// get matrix4 element (ele = 0 to 15)
	function GetMatrix4Element(mat,ele)
		
		select ele
			
// x 
			case 0:
				result# = Matrix4[mat].x.x
			endcase

			case 1:
				result# = Matrix4[mat].x.y
			endcase

			case 2:
				result# = Matrix4[mat].x.z
			endcase			

			case 3:
				result# = Matrix4[mat].x.w
			endcase

// y 
			case 4:
				result# = Matrix4[mat].y.x
			endcase

			case 5:
				result# = Matrix4[mat].y.y
			endcase

			case 6:
				result# = Matrix4[mat].y.z
			endcase			

			case 7:
				result# = Matrix4[mat].y.w
			endcase

// z 
			case 8:
				result# = Matrix4[mat].z.x
			endcase

			case 9:
				result# = Matrix4[mat].z.y
			endcase

			case 10:
				result# = Matrix4[mat].z.z
			endcase			

			case 11:
				result# = Matrix4[mat].z.w
			endcase

// z 
			case 12:
				result# = Matrix4[mat].w.x
			endcase

			case 13:
				result# = Matrix4[mat].w.y
			endcase

			case 14:
				result# = Matrix4[mat].w.z
			endcase			

			case 15:
				result# = Matrix4[mat].w.w
			endcase
		
		endselect
		
	
	endfunction result#
	
// set matrix4 (matrix4, 16 floats)
	function SetMatrix4(mat, f0 as float, f1 as float, f2 as float, f3 as float, f4 as float, f5 as float, f6 as float, f7 as float, f8 as float, f9 as float, f10 as float, f11 as float, f12 as float, f13 as float, f14 as float, f15 as float)
		
	// x
		Matrix4[mat].x.x = f0
		Matrix4[mat].x.y = f1
		Matrix4[mat].x.z = f2
		Matrix4[mat].x.w = f3

	// y
		Matrix4[mat].y.x = f4
		Matrix4[mat].y.y = f5
		Matrix4[mat].y.z = f6
		Matrix4[mat].y.w = f7
		
	// z
		Matrix4[mat].z.x = f8
		Matrix4[mat].z.y = f9
		Matrix4[mat].z.z = f10
		Matrix4[mat].z.w = f11
		
	// w
		Matrix4[mat].w.x = f12
		Matrix4[mat].w.y = f13
		Matrix4[mat].w.z = f14
		Matrix4[mat].w.w = f15				
		 
	endfunction

// projection matrix
	function ProjectionMatrix4(mat, fov as float, aspect as float, nearDist as float, farDist)

	frustumDepth as float
	oneOverDepth as float
		


	frustumDepth = farDist - nearDist
	oneOverDepth = 1 / frustumDepth


		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1/tan(fov*0.5)   : Matrix4[mat].y.x = 0	 					: 	Matrix4[mat].z.x = 0										: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0				: Matrix4[mat].y.y = farDist * oneOverDepth : 	Matrix4[mat].z.y = 0										: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0				: Matrix4[mat].y.z = 0	 					: 	Matrix4[mat].z.z = farDist * oneOverDepth					: Matrix4[mat].w.z = 1
			Matrix4[mat].x.w = 0				: Matrix4[mat].y.w = 0	 					: 	Matrix4[mat].z.w = (-farDist * nearDist) * oneOverDepth		: Matrix4[mat].w.w = 0
			

	endfunction

// translate Matrix 4
	function TranslateMatrix4(mat, x as float, y as float, z as float)


		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1 : Matrix4[mat].y.x = 0 : 	Matrix4[mat].z.x = 0 : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0 : Matrix4[mat].y.y = 1 : 	Matrix4[mat].z.y = 0 : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0 : Matrix4[mat].y.z = 0 : 	Matrix4[mat].z.z = 1 : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = x : Matrix4[mat].y.w = y : 	Matrix4[mat].z.w = z : Matrix4[mat].w.w = 1

	endfunction

// X Rotate Matrix 4
	function RotateXMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1 : Matrix4[mat].y.x = 0 		 : 	Matrix4[mat].z.x = 0 		  : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0 : Matrix4[mat].y.y = cos(angle) : 	Matrix4[mat].z.y = sin(angle) : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0 : Matrix4[mat].y.z = -sin(angle): 	Matrix4[mat].z.z = cos(angle) : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 : Matrix4[mat].y.w = 0 		 : 	Matrix4[mat].z.w = 0 		  : Matrix4[mat].w.w = 1
		
	endfunction

// Y Rotate Matrix 4
	function RotateYMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = cos(angle) : Matrix4[mat].y.x = 0 		 : 	Matrix4[mat].z.x = -sin(angle) : Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0		  : Matrix4[mat].y.y = 1		 : 	Matrix4[mat].z.y = 0		   : Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = sin(angle) : Matrix4[mat].y.z = 0		 : 	Matrix4[mat].z.z = cos(angle)  : Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 		  : Matrix4[mat].y.w = 0 		 : 	Matrix4[mat].z.w = 0 		   : Matrix4[mat].w.w = 1
					
	endfunction

// Z Rotate Matrix 4
	function RotateZMatrix4(mat, angle as float)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = cos(angle)  : Matrix4[mat].y.x = sin(angle) 	: 	Matrix4[mat].z.x = 0	: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = -sin(angle) : Matrix4[mat].y.y = cos(angle)	: 	Matrix4[mat].z.y = 0	: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0		   : Matrix4[mat].y.z = 0			: 	Matrix4[mat].z.z = 1	: Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0 		   : Matrix4[mat].y.w = 0 		 	: 	Matrix4[mat].z.w = 0	: Matrix4[mat].w.w = 1		
		
	endfunction
           
// View Matrix 4    
	function ViewMatrix4(xVecID, yVecID, zVecID, posVecID, matRotID, matViewID, matTempRotID)
	   SetIdentityMatrix4(matViewID)
	 
	   setvector3(posVecID, getcamerax(1), getcameray(1), getcameraz(1) )

	 
	   RotateZMatrix4( matRotID, radian(cameraAngleZ(1)) )
	   RotateYMatrix4( matTempRotID, radian(cameraAngleY(1)) )
	   MultiplyMatrix4(matRotID, matRotID, matTempRotID)
	   RotateXMatrix4( matTempRotID, radian(cameraAngleX(1)) )
	   MultiplyMatrix4(matRotID, matRotID, matTempRotID)
	 
	   setvector3(xVecID, 1.0, 0.0, 0.0 )
	   setvector3(yVecID, 0.0, 1.0, 0.0 )
	   setvector3(zVecID, 0.0, 0.0, 1.0 )
	 
	   TransformCoordsVector3(xVecID, matRotID)
	   TransformCoordsVector3(yVecID, matRotID)
	   TransformCoordsVector3(zVecID, matRotID)
	 
	   SetMatrix4Element(matViewID, 0, GetVector3X(xVecID) )
	   SetMatrix4Element(matViewID, 1, GetVector3X(yVecID) )
	   SetMatrix4Element(matViewID, 2, GetVector3X(zVecID) )
	 
	   SetMatrix4Element(matViewID, 4, GetVector3Y(xVecID) )
	   SetMatrix4Element(matViewID, 5, GetVector3Y(yVecID) )
	   SetMatrix4Element(matViewID, 6, GetVector3Y(zVecID) )
	 
	   SetMatrix4Element(matViewID, 8, GetVector3Z(xVecID) )
	   SetMatrix4Element(matViewID, 9, GetVector3Z(yVecID) )
	   SetMatrix4Element(matViewID, 10,GetVector3Z(zVecID) )
	 
	   SetMatrix4Element(matViewID, 12, -GetVector3Dot(posVecID, xVecID) )
	   SetMatrix4Element(matViewID, 13, -GetVector3Dot(posVecID, yVecID) )
	   SetMatrix4Element(matViewID, 14, -GetVector3Dot(posVecID, zVecID) )
	endfunction



// Not finished commands:

// Inverse Matrix 4
	function InverseMatrix4(mresult, msource)
	endfunction
	
	
	

// Identity Matrix 4
	function SetIdentityMatrix4(mat)
		
		// write informations into the 4x4 matrix
			Matrix4[mat].x.x = 1  : Matrix4[mat].y.x = 0 	: 	Matrix4[mat].z.x = 0	: Matrix4[mat].w.x = 0
			Matrix4[mat].x.y = 0  : Matrix4[mat].y.y = 1	: 	Matrix4[mat].z.y = 0	: Matrix4[mat].w.y = 0
			Matrix4[mat].x.z = 0  : Matrix4[mat].y.z = 0	: 	Matrix4[mat].z.z = 1	: Matrix4[mat].w.z = 0
			Matrix4[mat].x.w = 0  : Matrix4[mat].y.w = 0 	: 	Matrix4[mat].z.w = 0	: Matrix4[mat].w.w = 1			
		
	endfunction 


					
// Build Look at lh matrix	
	function BuildLookAtLhMatrix4()


 
		vecEye = createvector3()
		vecAt = createvector3()
		vecUp = createvector3()
		vecXAxis = createvector3()
		vecYAxis = createvector3()
		vecZAxis = createvector3()
		matView = creatematrix4()
		 
		setvector3(vecEye, 0, 0, 0)
		setvector3(vecAt, 0, 0, 1)
		setvector3(vecUp, 0, 1, 0)
		 
		
		SubstractVector3(vecZAxis, vecAt, vecEye)
		
		normalizeVector3(vecZAxis) // normalize vector3 vecZAxis, vecZAxis
		GetVector3Cross( vecXAxis, vecUp, vecZAxis ) // cross product vector3 vecXAxis, vecUp, vecZAxis
		normalizeVector3(vecXAxis) // normalize vector3 vecXAxis, vecXAxis
		GetVector3Cross( vecYAxis, vecZAxis, vecXAxis ) // cross product vector3 vecYAxis, vecZAxis, vecXAxis

		SetMatrix4Element(matView, 0, getvector3x(vecXAxis) )
		SetMatrix4Element(matView, 1, getvector3x(vecYAxis) )
		SetMatrix4Element(matView, 2, getvector3x(vecZAxis) )
		SetMatrix4Element(matView, 3, 0.0 )
		 
		SetMatrix4Element(matView, 4, getvector3y(vecXAxis) )
		SetMatrix4Element(matView, 5, getvector3y(vecYAxis) )
		SetMatrix4Element(matView, 6, getvector3y(vecZAxis) )
		SetMatrix4Element(matView, 7, 0.0 )
		 
		SetMatrix4Element(matView, 8, getvector3z(vecXAxis) )
		SetMatrix4Element(matView, 9, getvector3z(vecYAxis) )
		SetMatrix4Element(matView, 10, getvector3z(vecZAxis) )
		SetMatrix4Element(matView, 11, 0.0 )
		 
		SetMatrix4Element(matView, 12, -GetVector3Dot( vecXAxis, vecEye ) )
		SetMatrix4Element(matView, 13, -GetVector3Dot( vecYAxis, vecEye ) )
		SetMatrix4Element(matView, 14, -GetVector3Dot( vecZAxis, vecEye ) )
		SetMatrix4Element(matView, 15, 1.0 )

				
				// is this a good idea?:
				DeleteVector3(vecEye)
				DeleteVector3(vecAt)
				DeleteVector3(vecUp)
				DeleteVector3(vecXAxis)
				DeleteVector3(vecYAxis)
				DeleteVector3(vecZAxis)
		
	endfunction matView


// various math commands
// ==================

// this function will convert an euler angle to a radian angle
	function radian(eul#)

		out# = eul# * 180 / Math_PI // conversion to degrees
		if( out# < 0 ) then out# = out# + 360.0 // convert negative to positive angles
		
	endfunction out#

//This command will return a value that does not exceed the range of 0 to 360. 
function WrapAngle( angle as float) 
	local iChunkOut as integer
	local breakout as integer
	iChunkOut = angle
	iChunkOut = iChunkOut - mod( iChunkOut, 360 )
	angle = angle - iChunkOut
	breakout = 10000
	while angle < 0.0 or angle >= 360.0 
		if angle < 0.0 then angle = angle + 360.0
		if angle >= 360.0 then angle = angle - 360.0
		dec breakout  
		if  breakout = 0  then exit
	endwhile
	if  breakout = 0  then angle = 0.0
endfunction angle

//This command will return an auto-interpolated angle based on a given speed. 
function CurveAngle( destination as float, current as float,  speed as float)
	local diff as float
	if speed < 1.0 then speed = 1.0
	destination = WrapAngle( destination )
	current = WrapAngle( current )
	diff = destination - current
	if diff <- 180.0 then diff = ( destination + 360.0 ) - current
	if diff > 180.0 then diff = destination - ( current + 360.0 )
	current = current + ( diff / speed )
	current = WrapAngle( current )
endfunction current

//This command will return an auto-interpolated value based on a given speed. 
function CurveValue( destination as float, current as float,  speed as float)
	local diff as float
	if  speed < 1.0  then speed = 1.0
	diff = destination - current
	current = current + ( diff / speed )
endfunction current

//This command will return a value that represents the new X position of a point in 3D space
// currentXValue -- current value to calculate the new value from.
// angleValue -- angle value in degrees 0 to 360
// stepValue -- specifies how far in the specified direction you would like to calculate
function CalculateNewXValue( currentXValue as float, angleValue as float, stepValue as float ) 
	result# = currentXValue + ( sin( angleValue ) * stepValue )
endfunction result#

//This command will return a value that represents the new Y position of a point in 3D space
// currentXValue -- current value to calculate the new value from.
// angleValue -- angle value in degrees 0 to 360
// stepValue -- specifies how far in the specified direction you would like to calculate
function CalculateNewYValue( currentYValue as float, angleValue as float, stepValue as float ) 
	result# = currentYValue - ( sin( angleValue ) * stepValue )
endfunction result#

//This command will return a value that represents the new Z position of a point in 3D space
// currentXValue -- current value to calculate the new value from.
// angleValue -- angle value in degrees 0 to 360
// stepValue -- specifies how far in the specified direction you would like to calculate
function CalculateNewZValue( currentZValue as float, angleValue as float, stepValue as float ) 
	result# = currentZValue + ( cos( angleValue ) * stepValue )
endfunction result#

// orthographic projection matrix
function OrthographicProjectionMatrix4(mat, camWidth as float, camHeight as float, nearDist as float, farDist)

	// write informations into the 4x4 matrix
		Matrix4[mat].x.x = 1 / camWidth	    : Matrix4[mat].y.x = 0                      :   Matrix4[mat].z.x = 0                                        : Matrix4[mat].w.x = 0
		Matrix4[mat].x.y = 0                : Matrix4[mat].y.y = 1 / camHeight		    :   Matrix4[mat].z.y = 0                                        : Matrix4[mat].w.y = 0
		Matrix4[mat].x.z = 0                : Matrix4[mat].y.z = 0                      :   Matrix4[mat].z.z = -2 / (farDist-nearDist)                  : Matrix4[mat].w.z = 0
		Matrix4[mat].x.w = 0                : Matrix4[mat].y.w = 0                      :   Matrix4[mat].z.w = -(farDist+nearDist) / (farDist-nearDist) : Matrix4[mat].w.w = 1
		
endfunction

// multiply matrix4 x matrix4
function Multiply2Matrix4(resultmat, mat1, mat2)
	for i=0 to 3
		SetMatrix4Element(resultmat,i+(0*4),GetMatrix4Element(mat1,0+(0*4))*GetMatrix4Element(mat2,i+(0*4))+GetMatrix4Element(mat1,1+(0*4))*GetMatrix4Element(mat2,i+(1*4))+GetMatrix4Element(mat1,2+(0*4))*GetMatrix4Element(mat2,i+(2*4)))
		SetMatrix4Element(resultmat,i+(1*4),GetMatrix4Element(mat1,0+(1*4))*GetMatrix4Element(mat2,i+(0*4))+GetMatrix4Element(mat1,1+(1*4))*GetMatrix4Element(mat2,i+(1*4))+GetMatrix4Element(mat1,2+(1*4))*GetMatrix4Element(mat2,i+(2*4)))
		SetMatrix4Element(resultmat,i+(2*4),GetMatrix4Element(mat1,0+(2*4))*GetMatrix4Element(mat2,i+(0*4))+GetMatrix4Element(mat1,1+(2*4))*GetMatrix4Element(mat2,i+(1*4))+GetMatrix4Element(mat1,2+(2*4))*GetMatrix4Element(mat2,i+(2*4)))
		SetMatrix4Element(resultmat,i+(3*4),GetMatrix4Element(mat1,0+(3*4))*GetMatrix4Element(mat2,i+(0*4))+GetMatrix4Element(mat1,1+(3*4))*GetMatrix4Element(mat2,i+(1*4))+GetMatrix4Element(mat1,2+(3*4))*GetMatrix4Element(mat2,i+(2*4))+GetMatrix4Element(mat2,i+(3*4)))
	next i
endfunction 

// Vector3 substract substract vec2 from vec1 into resultvec
function Substract2Vector3(resultvec,vec1,vec2)
	
	SetVector3(resultvec,GetVector3X(vec1)-GetVector3X(vec2),GetVector3Y(vec1)-GetVector3Y(vec2),GetVector3Z(vec1)-GetVector3Z(vec2))

endfunction

function BuildLookAtMatrix4(atVecID, eyeVecID)
	vecXAxis = createvector3()			// Right Vector
	vecYAxis = createvector3(0, 1, 0)	// Up Vector
	vecZAxis = createvector3()			// Forward Vector
	matView = creatematrix4()
	
	SubstractVector3(vecZAxis, eyeVecID, atVecID)
	normalizeVector3(vecZAxis) // normalize vector3 vecZAxis, vecZAxis
	GetVector3Cross(vecXAxis, vecZAxis, vecYAxis) // cross product vector3 vecXAxis, vecUp, vecZAxis
	normalizeVector3(vecXAxis) // normalize vector3 vecXAxis, vecXAxis
	GetVector3Cross(vecYAxis, vecXAxis, vecZAxis) // cross product vector3 vecYAxis, vecZAxis, vecXAxis

	SetMatrix4Element(matView, 0, getvector3x(vecXAxis))
	SetMatrix4Element(matView, 1, getvector3y(vecXAxis))
	SetMatrix4Element(matView, 2, getvector3z(vecXAxis))
	SetMatrix4Element(matView, 3, -GetVector3Dot(vecXAxis, eyeVecID))
	
	SetMatrix4Element(matView, 4, getvector3x(vecYAxis))
	SetMatrix4Element(matView, 5, getvector3y(vecYAxis))
	SetMatrix4Element(matView, 6, getvector3z(vecYAxis))
	SetMatrix4Element(matView, 7, -GetVector3Dot(vecYAxis, eyeVecID))
	
	SetMatrix4Element(matView, 8, getvector3x(vecZAxis))
	SetMatrix4Element(matView, 9, getvector3y(vecZAxis))
	SetMatrix4Element(matView, 10, getvector3z(vecZAxis))
	SetMatrix4Element(matView, 11, -GetVector3Dot(vecZAxis, eyeVecID))
	
	SetMatrix4Element(matView, 12, 0)
	SetMatrix4Element(matView, 13, 0)
	SetMatrix4Element(matView, 14, 0)
	SetMatrix4Element(matView, 15, 1)

	DeleteVector3(vecXAxis)
	DeleteVector3(vecYAxis)
	DeleteVector3(vecZAxis)
endfunction matView

// THIS PSEUDO-CODE HAS NOT BEEN COMPILED OR TESTED
// THE FORMULAE WERE DERIVED FROM EDUCATIONAL MATERIALS POSTED BY: Martin John Baker at...
// http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
//
// Pseudo-code to determine the inverse of a 4x4 matrix
// Note that a matrix does not have an inverse if its Determinant is zero (0).
// The pseudo-code has a check for this case, but needs to be integrated into the calling protocol.
// Enjoy.  - Uncle Martin
//
// Add declaration, calling protocol & housekeeping code for compatibility with your compiler/tools
//----------------------------------------------------------------------------

// Get matrix elements into short names for readability
m00 = Matrix4[mat].x.x
m01 = Matrix4[mat].x.y
m02 = Matrix4[mat].x.z
m03 = Matrix4[mat].x.w
m10 = Matrix4[mat].y.x
m11 = Matrix4[mat].y.y
m12 = Matrix4[mat].y.z
m13 = Matrix4[mat].y.w
m20 = Matrix4[mat].z.x
m21 = Matrix4[mat].z.y
m22 = Matrix4[mat].z.z
m23 = Matrix4[mat].z.w
m30 = Matrix4[mat].w.x
m31 = Matrix4[mat].w.y
m32 = Matrix4[mat].w.z
m33 = Matrix4[mat].w.w
 
// Get determinant
d1 = m03*m12*m21*m30 - m02*m13*m21*m30 - m03*m11*m22*m30 + m01*m13*m22*m30
d2 = m02*m11*m23*m30 - m01*m12*m23*m30 - m03*m12*m20*m31 + m02*m13*m20*m31
d3 = m03*m10*m22*m31 - m00*m13*m22*m31 - m02*m10*m23*m31 + m00*m12*m23*m31
d4 = m03*m11*m20*m32 - m01*m13*m20*m32 - m03*m10*m21*m32 + m00*m13*m21*m32
d5 = m01*m10*m23*m32 - m00*m11*m23*m32 - m02*m11*m20*m33 + m01*m12*m20*m33
d6 = m02*m10*m21*m33 - m00*m12*m21*m33 - m01*m10*m22*m33 + m00*m11*m22*m33
det = d1 + d2 + d3 + d4 + d5 + d6

// If determinant is zero, then there is no inverse; return indicating failure
if det = 0.0 then
   fail = TRUE
   return
// else continue on with no failure
else
   fail = FALSE
endif

// Get inverse by dividing Adjugate matrix elements by determinant
Matrix4[mat].x.x = (m12*m23*m31 - m13*m22*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33 + m11*m22*m33) / det
Matrix4[mat].x.y = (m03*m22*m31 - m02*m23*m31 - m03*m21*m32 + m01*m23*m32 + m02*m21*m33 - m01*m22*m33) / det
Matrix4[mat].x.z = (m02*m13*m31 - m03*m12*m31 + m03*m11*m32 - m01*m13*m32 - m02*m11*m33 + m01*m12*m33) / det
Matrix4[mat].x.w = (m03*m12*m21 - m02*m13*m21 - m03*m11*m22 + m01*m13*m22 + m02*m11*m23 - m01*m12*m23) / det
Matrix4[mat].y.x = (m13*m22*m30 - m12*m23*m30 - m13*m20*m32 + m10*m23*m32 + m12*m20*m33 - m10*m22*m33) / det
Matrix4[mat].y.y = (m02*m23*m30 - m03*m22*m30 + m03*m20*m32 - m00*m23*m32 - m02*m20*m33 + m00*m22*m33) / det
Matrix4[mat].y.z = (m03*m12*m30 - m02*m13*m30 - m03*m10*m32 + m00*m13*m32 + m02*m10*m33 - m00*m12*m33) / det
Matrix4[mat].y.w = (m02*m13*m20 - m03*m12*m20 + m03*m10*m22 - m00*m13*m22 - m02*m10*m23 + m00*m12*m23) / det
Matrix4[mat].z.x = (m11*m23*m30 - m13*m21*m30 + m13*m20*m31 - m10*m23*m31 - m11*m20*m33 + m10*m21*m33) / det
Matrix4[mat].z.y = (m03*m21*m30 - m01*m23*m30 - m03*m20*m31 + m00*m23*m31 + m01*m20*m33 - m00*m21*m33) / det
Matrix4[mat].z.z = (m01*m13*m30 - m03*m11*m30 + m03*m10*m31 - m00*m13*m31 - m01*m10*m33 + m00*m11*m33) / det
Matrix4[mat].z.w = (m03*m11*m20 - m01*m13*m20 - m03*m10*m21 + m00*m13*m21 + m01*m10*m23 - m00*m11*m23) / det
Matrix4[mat].w.x = (m12*m21*m30 - m11*m22*m30 - m12*m20*m31 + m10*m22*m31 + m11*m20*m32 - m10*m21*m32) / det
Matrix4[mat].w.y = (m01*m22*m30 - m02*m21*m30 + m02*m20*m31 - m00*m22*m31 - m01*m20*m32 + m00*m21*m32) / det
Matrix4[mat].w.z = (m02*m11*m30 - m01*m12*m30 - m02*m10*m31 + m00*m12*m31 + m01*m10*m32 - m00*m11*m32) / det
Matrix4[mat].w.w = (m01*m12*m20 - m02*m11*m20 + m02*m10*m21 - m00*m12*m21 - m01*m10*m22 + m00*m11*m22) / det
    
return