Quaternion

--***************************************************
--* QUATERNION
--***************************************************
--*
--* \file    Quaternion.ls
--* \brief   Quaternion class, new data type.
--* \author  Maltus
--* \version 1.1
--* \date    05/05/2009
--* \email   --
--* \todo    comment...
--*
--***************************************************
--* CONSTRUCTOR
--***************************************************
--*
--* <Quaternion> = script( <String> ).new()               -- default
--* <Quaternion> = script( <String> ).new( <List> )       -- <List> = <LinearList> / <PropList> / <AxisAngle>
--* <Quaternion> = script( <String> ).new( <Transform> )
--* <Quaternion> = script( <String> ).new( <Vector> )
--* <Quaternion> = script( <String> ).new( <Quaternion> ) -- copy
--*
--***************************************************
--* PUBLIC METHODS
--***************************************************
--*
--* <Symbol>     = <Quaternion>.ilk() / ilk( <Quaternion> )
--* <Boolean>    = ilk( <Quaternion>, <Symbol> )
--*
--* Predicate:
--* <Boolean>    = quaternionP( <Quaternion> )
--*
--* Operator: direct access (.x, .y, .z, .w) and bracket access ([])
--* <Float>      = getAt( <Integer> / <Symbol> / <String> )
--* <Float>      = setAt( <Integer> / <Symbol> / <String>, <Number> )
--*
--* <Void>       = invert()
--* <Void>       = oppose()
--* <Void>       = normalize()
--* <Void>       = identity()
--*
--* <Quaternion> = duplicate()
--* <Quaternion> = getInversed()
--* <Quaternion> = getOpposed()
--* <Quaternion> = getNormalized()
--*
--* <Quaternion> = multiply( <Quaternion> / <Transform> / <List> / <Vector> / <Number> )
--* <Quaternion> = add( <Quaternion> / <Transform> / <List> / <Vector> / <Number> )
--* <Quaternion> = subtract( <Quaternion> / <Transform> / <List> / <Vector> / <Number> )
--*
--* <Boolean>    = isEqualTo( <Quaternion> )
--* <Boolean>    = isIdentity()
--* <Boolean>    = isNormalized()
--*
--* <Float>      = dotProduct( <Quaternion> )
--* <Float>      = magnitude()
--*
--* <Transform>  = toTransform()
--* <Vector>     = toVector()
--* <AxisAngle>  = toAxisAngle()
--* <PropList>   = toPropList()
--* <LinearList> = toLineList()
--* <String>     = toString()
--*
--*
--***************************************************
--* PRIVATE METHODS
--***************************************************
--*
--* <Void>       = __setQuaternion()
--* <Void>       = __setQuatFromTransform( <Transform> )
--* <Void>       = __setQuatFromVector( <Vector> )
--* <Void>       = __setQuatFromUndefList( <PropList> / <LinearList> / <AxisAngle> )
--*
--* <Void>       = __setPropListFromAxisAngle( <AxisAngle> )
--* <Void>       = __listNormalize( <PropList> ) 'Optionnal'
--*
--* <Boolean>    = __isAxisAngle( <AxisAngle> )
--* <Boolean>    = __isLineList( <LinearList> )
--* <Boolean>    = __isPropList( <PropList> )
--*
--* <Float>      = __arcCos( <Number> )
--*
--* <Void>       = __throwError( <PropList> )
--* <Void>       = __throwPrivate()
--*
--*
--***************************************************
 
-- Constant
property DEGTORAD
property RADTODEG
property EPSILON
 
-- Public property
property quaternionP
 
-- Private properties
property ancestor
property p_sScriptName
 
 
--***************************************************
--* CONSTRUCTOR
--***************************************************
--*
--***************************************************
on new( me, aValue )  
 
  DEGTORAD         = PI / float(180)
  RADTODEG         = float(180) / PI
  EPSILON          = 0.0001
  --  
  __setQuaternion( VOID, me )
  --
  case ilk( aValue ) of
    #Void      : nothing
    #Transform : __setQuatFromTransform( VOID, me, aValue )
    #Vector    : __setQuatFromVector( VOID, me, aValue )
    #List      : __setQuatFromUndefList( VOID, me, aValue )
    #Quaternion: me.duplicate( aValue )
    otherwise  : __throwError( VOID, me, [#Error: "Value type mismatch !", #ID: "10505200901"] )
  end case  
  --
  return( me )
end
 
 
--***************************************************
--* GETAT
--***************************************************
--*
--***************************************************
on getAt( me, aProp )
  --  
  case ilk( aProp ) of
    #Symbol  : iPos = ([#x, #y, #z, #w]).getPos( aProp )
    #String  : iPos = ([#x, #y, #z, #w]).getPos( symbol( aProp ) )
    #Integer : iPos = aProp
    otherwise: iPos = 0
  end case
  --
  if ( (iPos <= 0) OR (iPos > 4) ) then __throwError( VOID, me, [#Error: "Argument out of range !", #ID: "10505200902"] )
  --
  return( (me.ancestor)[iPos] )
end
 
 
--***************************************************
--* SETAT
--***************************************************
--*
--***************************************************
on setAt( me, aProp, aValue )
  --
  case ilk( aProp ) of
    #Symbol  : iPos = ([#x, #y, #z, #w]).getPos( aProp )
    #String  : iPos = ([#x, #y, #z, #w]).getPos( symbol( aProp ) )
    #Integer : iPos = aProp
    otherwise: iPos = 0
  end case
  --
  if ( (iPos <= 0) OR (iPos > 4) ) then __throwError( VOID, me, [#Error: "Argument out of range !", #ID: "10505200903"] )
  if not( ilk( aValue, #Number ) ) then __throwError( VOID, me, [#Error: "Number expected !", #ID: "10505200904"] )
  (me.ancestor)[iPos] = float( aValue )
  --
  return( (me.ancestor)[iPos] )
end
 
 
--***************************************************
--* ILK
--***************************************************
--*
--***************************************************
on ilk( me )
  --
  iCnt = _movie.paramCount()
  if (iCnt > 2) then __throwError( VOID, me, [#Error: "Wrong number of argument !", #ID: "10505200905"] )
  --
  if (iCnt = 1) then
 
    if integerP( me )    then return( #Integer )
    if floatP( me )      then return( #Float )
    if stringP( me )     then return( #String )
    if symbolP( me )     then return( #Symbol )
    if voidP( me )       then return( #Void )
    if quaternionP( me ) then return( #Quaternion )
    if (objectP( me ) AND not(listP( me ))) then return( #Object ) -- << must be after your own predicate !
 
    __throwError( VOID, me, [#Error: "Unknown type !", #ID: "10505200906"] )
 
  else
 
    case( _movie.param(iCnt) ) of
      #Integer   : return( integerP( me ) )
      #Float     : return( floatP(  me ) )
      #Number    : return( integerP( me ) OR floatP( me ) )
      #String    : return( stringP( me ) )
      #Symbol    : return( symbolP( me ) )
      #Void      : return( voidP( me ) )
      #Quaternion: return( quaternionP( me ) )
      #Object    : return( (objectP( me ) AND not(listP( me ))) )     
      otherwise  : return( FALSE )
    end case    
 
  end if
  --  
end
 
 
--***************************************************
--* QUATERNIONP
--***************************************************
--*
--***************************************************
on quaternionP( me )
  --  
  if ( objectP( me ) AND not(listP( me )) ) then
    if not( voidP(me.getaProp(#p_sScriptName)) ) then
      if ( string( me ) contains (me.p_sScriptName) ) then
        return( TRUE )
      end if      
    end if    
  end if
  --
  return( FALSE )  
end
 
 
--***************************************************
--* INVERT
--***************************************************
--*
--***************************************************
on invert( me )
  --
  (me.ancestor)[1] = - (me.ancestor)[1]
  (me.ancestor)[2] = - (me.ancestor)[2]
  (me.ancestor)[3] = - (me.ancestor)[3]
  --
  return
end
 
 
--***************************************************
--* OPPOSE
--***************************************************
--*
--***************************************************
on oppose( me )
  --
  me.ancestor = (me.ancestor) * float(-1)
  --
  return
end
 
 
--***************************************************
--* NORMALIZE
--***************************************************
--*
--***************************************************
on normalize( me )
  --
  __listNormalize( VOID, me )
  --
  return
end
 
 
--***************************************************
--* IDENTITY
--***************************************************
--*
--***************************************************
on identity( me )  
  me.ancestor = [#x: float(0), #y: float(0), #z: float(0), #w: float(1)] 
  return
end
 
 
--***************************************************
--* DUPLICATE
--***************************************************
--*
--***************************************************
on duplicate( me )  
  return( _movie.script( (me.p_sScriptName) ).new( me ) ) 
end
 
 
--***************************************************
--* GETINVERSE
--***************************************************
--*
--***************************************************
on getInversed( me )  
  lInversed    = ( (me.ancestor).duplicate() ) * float(-1)
  lInversed[4] = - lInversed[4]
  return( _movie.script( (me.p_sScriptName) ).new( lInversed ) )
end
 
 
--***************************************************
--* GETOPPOSED
--***************************************************
--*
--***************************************************
on getOpposed( me )  
  lOpposed = ( (me.ancestor).duplicate() ) * float(-1)  
  return( _movie.script( (me.p_sScriptName) ).new( lOpposed ) )
end
 
 
--***************************************************
--* GETNORMALIZED
--***************************************************
--*
--***************************************************
on getNormalized( me )  
  lNormalized = (me.ancestor).duplicate()  
  __listNormalize( VOID, me, lNormalized ) 
  return( _movie.script( (me.p_sScriptName) ).new( lNormalized ) )
end
 
 
--***************************************************
--* MULTIPLY
--***************************************************
--*
--***************************************************
on multiply( me, aValue ) 
  --
  case ilk( aValue ) of
    #Quaternion: lValue = (aValue.ancestor).duplicate()
    #Number    : lValue = [#x: float(aValue), #y: float(aValue), #z: float(aValue), #w: float(aValue)]
    #Transform, #Vector, #List : lValue = (_movie.script( (me.p_sScriptName) ).new( aValue )).ancestor    
    otherwise  : __throwError( VOID, me, [#Error: "Value type mismatch !", #ID: "10505200907"] )
  end case
  --
  X1 = (me.ancestor)[1]
  Y1 = (me.ancestor)[2]
  Z1 = (me.ancestor)[3]
  W1 = (me.ancestor)[4]
  --
  X2 = lValue[1]
  Y2 = lValue[2]
  Z2 = lValue[3]
  W2 = lValue[4]
  lValue = VOID
  --  
  return( _movie.script( (me.p_sScriptName) ).new( [\
W1 * X2 + X1 * W2 + Y1 * Z2 - Z1 * Y2,\
W1 * Y2 + Y1 * W2 + Z1 * X2 - X1 * Z2,\
W1 * Z2 + Z1 * W2 + X1 * Y2 - Y1 * X2,\
W1 * W2 - X1 * X2 - Y1 * Y2 - Z1 * Z2] ) )     
end
 
 
--***************************************************
--* ADD
--***************************************************
--*
--***************************************************
on add( me, aValue ) 
  --
  case ilk( aValue ) of
    #Quaternion: lValue = (aValue.ancestor).duplicate()
    #Number    : lValue = [#x: float(aValue), #y: float(aValue), #z: float(aValue), #w: float(aValue)]
    #Transform, #Vector, #List : lValue = (_movie.script( (me.p_sScriptName) ).new( aValue )).ancestor 
    otherwise  : __throwError( VOID, me, [#Error: "Value type mismatch !", #ID: "10505200908"] )    
  end case
  --
  X = (me.ancestor)[1] + lValue[1]
  Y = (me.ancestor)[2] + lValue[2]
  Z = (me.ancestor)[3] + lValue[3]
  W = (me.ancestor)[4] + lValue[4]
  lValue = VOID
  --
  return( _movie.script( (me.p_sScriptName) ).new( [X, Y, Z, W] ) )
end
 
 
--***************************************************
--* SUBTRACT
--***************************************************
--*
--***************************************************
on subtract( me, aValue ) 
  --
  case ilk( aValue ) of
    #Quaternion: lValue = (aValue.ancestor).duplicate()
    #Number    : lValue = [#x: float(aValue), #y: float(aValue), #z: float(aValue), #w: float(aValue)]
    #Transform, #Vector, #List : lValue = (_movie.script( (me.p_sScriptName) ).new( aValue )).ancestor  
    otherwise  : __throwError( VOID, me, [#Error: "Value type mismatch !", #ID: "10505200909"] )    
  end case
  --
  X = (me.ancestor)[1] - lValue[1]
  Y = (me.ancestor)[2] - lValue[2]
  Z = (me.ancestor)[3] - lValue[3]
  W = (me.ancestor)[4] - lValue[4]
  lValue = VOID
  --
  return( _movie.script( (me.p_sScriptName) ).new( [X, Y, Z, W] ) )
end
 
 
--***************************************************
--* ISEQUALTO
--***************************************************
--*
--***************************************************
on isEqualTo( me, aValue ) 
  --
  if not( ilk( aValue, #Quaternion ) ) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200910"] )
  --
  return(\
( abs( (me.ancestor)[1] - (aValue.ancestor)[1] ) <= EPSILON ) AND\
( abs( (me.ancestor)[2] - (aValue.ancestor)[2] ) <= EPSILON ) AND\
( abs( (me.ancestor)[3] - (aValue.ancestor)[3] ) <= EPSILON ) AND\
( abs( (me.ancestor)[4] - (aValue.ancestor)[4] ) <= EPSILON ) )
end
 
 
--***************************************************
--* ISIDENTITY
--***************************************************
--*
--***************************************************
on isIdentity( me )  
  --
  if (\
( abs( (me.ancestor)[1] ) <= EPSILON ) AND\
( abs( (me.ancestor)[2] ) <= EPSILON ) AND\
( abs( (me.ancestor)[3] ) <= EPSILON ) AND\
( abs( (me.ancestor)[4] - float(1) ) <= EPSILON ) ) then return( TRUE )
  --
  return( FALSE )
end
 
 
--***************************************************
--* ISNORMALIZED
--***************************************************
--*
--***************************************************
on isNormalized( me )
  --
  if ( abs( me.magnitude() - float(1) ) <= EPSILON ) then return( TRUE )
  --
  return( FALSE )  
end
 
 
--***************************************************
--* DOTPRODUCT
--***************************************************
--*
--***************************************************
on dotProduct( me, aValue ) 
  --
  if not( ilk( aValue, #Quaternion ) ) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200911"] )
  --
  return(\
( (me.ancestor)[1] * aValue[1] ) + ( (me.ancestor)[2] * aValue[2] ) +\
( (me.ancestor)[3] * aValue[3] ) + ( (me.ancestor)[4] * aValue[4] ) )  
end
 
 
--***************************************************
--* MAGNITUDE
--***************************************************
--*
--***************************************************
on magnitude( me ) 
  --
  return( sqrt(\
(me.ancestor)[1] * (me.ancestor)[1] +\
(me.ancestor)[2] * (me.ancestor)[2] +\
(me.ancestor)[3] * (me.ancestor)[3] +\
(me.ancestor)[4] * (me.ancestor)[4] ) )  
end
 
 
--***************************************************
--* TOTRANSFORM
--***************************************************
--*
--***************************************************
on toTransform( me )
  --
  __listNormalize( VOID, me )
  --
  X1 = (me.ancestor)[1]
  Y1 = (me.ancestor)[2]
  Z1 = (me.ancestor)[3]
  W1 = (me.ancestor)[4]
  --
  X2 = X1 * X1
  Y2 = Y1 * Y1
  Z2 = Z1 * Z1
  W2 = W1 * W1
  --
  XY = X1 * Y1
  XZ = X1 * Z1
  YZ = Y1 * Z1
  --
  WX = W1 * X1
  WY = W1 * Y1
  WZ = W1 * Z1
  --
  trsf = transform()
  --
  trsf[1]  = float( 1.0 - 2.0 * (Y2 + Z2) )
  trsf[2]  = float( 2.0 * (XY + WZ) )
  trsf[3]  = float( 2.0 * (XZ - WY) )
  --
  trsf[5]  = float( 2.0 * (XY - WZ) )
  trsf[6]  = float( 1.0 - 2.0 * (X2 + Z2) )
  trsf[7]  = float( 2.0 * (YZ + WX) )
  --
  trsf[9]  = float( 2.0 * (XZ + WY) )
  trsf[10] = float( 2.0 * (YZ - WX) )
  trsf[11] = float( 1.0 - 2.0 * (X2 + Y2) )
  --
  return( trsf )
end
 
 
--***************************************************
--* TOVECTOR
--***************************************************
--*
--***************************************************
on toVector( me ) 
  --
  trsf   = toTransform( me )
  vEuler = trsf.rotation
  --
  return( vEuler )
end
 
 
--***************************************************
--* TOAXISANGLE
--***************************************************
--*
--***************************************************
on toAxisAngle( me ) 
  --
  __listNormalize( VOID, me )
  --
  X1 = (me.ancestor)[1]
  Y1 = (me.ancestor)[2]
  Z1 = (me.ancestor)[3]
  W1 = (me.ancestor)[4]  
  --
  fAngle     = __arcCos( VOID, me, W1 )
  fScale     = me.magnitude()  
  --
  if ((0 <= fAngle) OR (PI >= fAngle)) then __throwError( VOID, me, [#Error: "Angle must be between 0 and PI !", #ID: "10505200912"] )
  lAxisAngle = []
  --  
  if ( fScale <= EPSILON ) then
    lAxisAngle.add( vector(1, 0, 0) )
    lAxisAngle.add( float(0) )
  else if ( (X1 = float(0)) AND (Y1 = float(0)) AND (Z1 = float(0)) ) then
    lAxisAngle.add( vector(1, 0, 0) )
    lAxisAngle.add( float(0) )
  else
    vEuler = vector( X1 / fScale, Y1 / fScale, Z1 / fScale )
    vEuler.normalize()
    lAxisAngle.add( vEuler )
    lAxisAngle.add( fAngle * float(2) * RADTODEG )
  end if
  --
  return( lAxisAngle )
end
 
 
--***************************************************
--* TOPROPLIST
--***************************************************
--*
--***************************************************
on toPropList( me )
  --
  return( (me.ancestor).duplicate() )  
end
 
 
--***************************************************
--* TOLINELIST
--***************************************************
--*
--***************************************************
on toLineList( me )
  --  
  return( [ (me.ancestor)[1], (me.ancestor)[2], (me.ancestor)[3], (me.ancestor)[4] ] )
end
 
 
--***************************************************
--* TOSTRING
--***************************************************
--*
--***************************************************
on toString( me )
  --
  return( "Quaternion("&&"#x:"&&(me.ancestor)[1]&", #y:"&&(me.ancestor)[2]&", #z:"&&(me.ancestor)[3]&", #w:"&&(me.ancestor)[4]&&")" )
end
 
 
--***************************************************
--* __SETQUATERNION
--***************************************************
--*
--***************************************************
on __setQuaternion( PRIVATE, me )  
  --
  if not(voidP( PRIVATE )) then __throwPrivate( VOID, me )
  if not(objectP( me ))    then __throwError( VOID, me, [#Error: "Object expected !", #ID: "10505200913"] )  
  -- 
  sScript          = string( me )
  iWrdCnt          = sScript.word.count
  iStrLgth         = (sScript.word[2..iWrdCnt-2]).length
  me.p_sScriptName = (sScript.word[2..iWrdCnt]).char[2..(iStrLgth-1)]   
  --
  me.ancestor      = [ #x: float(0), #y: float(0), #z: float(0), #w: float(1) ]
  QuaternionP      = TRUE
  --
  return
end
 
 
--***************************************************
--* __SETQUATFROMTRANSFORM
--***************************************************
--*
--***************************************************
on __setQuatFromTransform( PRIVATE, me, aTransform )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200914"] )
  --    
  fTrace = 1 + aTransform[1] + aTransform[6] + aTransform[11]
  --  
  if ( fTrace > EPSILON ) then
    --
    fRoot = sqrt( fTrace ) * float(2)
    (me.ancestor)[1] = ( aTransform[10] - aTransform[7] ) / fRoot
    (me.ancestor)[2] = ( aTransform[3]  - aTransform[9] ) / fRoot
    (me.ancestor)[3] = ( aTransform[5]  - aTransform[2] ) / fRoot
    (me.ancestor)[4] = 0.25 * fRoot
    --
  else if ( (aTransform[1] > aTransform[6]) AND (aTransform[1] > aTransform[11]) ) then
    --
    fRoot = sqrt( float(1) + aTransform[1] - aTransform[6] - aTransform[11] ) * float(2)
    (me.ancestor)[1] = 0.25 * fRoot
    (me.ancestor)[2] = ( aTransform[5]  + aTransform[2] ) / fRoot
    (me.ancestor)[3] = ( aTransform[3]  + aTransform[9] ) / fRoot
    (me.ancestor)[4] = ( aTransform[10] - aTransform[7] ) / fRoot  
    --
  else if ( aTransform[6] > aTransform[11] ) then
    --
    fRoot = sqrt( float(1) + aTransform[6] - aTransform[1] - aTransform[11] ) * float(2)
    (me.ancestor)[1] = ( aTransform[5]  + aTransform[2] ) / fRoot
    (me.ancestor)[2] = 0.25 * fRoot
    (me.ancestor)[3] = ( aTransform[10] + aTransform[7] ) / fRoot
    (me.ancestor)[4] = ( aTransform[3]  - aTransform[9] ) / fRoot
    --
  else
    --
    fRoot = sqrt( float(1) + aTransform[11] - aTransform[1] - aTransform[6] ) * float(2)
    (me.ancestor)[1] = ( aTransform[3]  + aTransform[9] ) / fRoot
    (me.ancestor)[2] = ( aTransform[10] + aTransform[7] ) / fRoot
    (me.ancestor)[3] = 0.25 * fRoot
    (me.ancestor)[4] = ( aTransform[5]  - aTransform[2] ) / fRoot
    --
  end if  
  --
  __listNormalize( VOID, me )    
  --  
  return
end
 
 
--***************************************************
--* __SETQUATFROMVECTOR
--***************************************************
--*
--***************************************************
on __setQuatFromVector( PRIVATE, me, aEuler )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200915"] )
  --
  X = (aEuler.x * DEGTORAD) * 0.5
  Y = (aEuler.y * DEGTORAD) * 0.5
  Z = (aEuler.z * DEGTORAD) * 0.5
  --
  fCosRoll  = cos( X )
  fCosPitch = cos( Y )
  fCosYaw   = cos( Z )
  --
  fSinRoll  = sin( X )
  fSinPitch = sin( Y )  
  fSinYaw   = sin( Z )  
  --
  fCosPitchCosYaw = fCosPitch * fCosYaw 
  fSinPitchSinYaw = fSinPitch * fSinYaw  
  --
  (me.ancestor)[1] = fSinRoll * fCosPitchCosYaw     - fCosRoll * fSinPitchSinYaw
  (me.ancestor)[2] = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw
  (me.ancestor)[3] = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw
  (me.ancestor)[4] = fCosRoll * fCosPitchCosYaw     + fSinRoll * fSinPitchSinYaw
  --
  __listNormalize( VOID, me )
  --
  return  
end
 
 
--***************************************************
--* __SETQUATFROMUNDEFLIST
--***************************************************
--*
--***************************************************
on __setQuatFromUndefList( PRIVATE, me, aUndefList )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200916"] )
  --
  if ilk( aUndefList, #LinearList ) then
    iListCnt   = aUndefList.count()
    iAxisAngle = 2
    iLineList  = 4
    --
    if ( iListCnt = iAxisAngle ) then      
      if not( __isAxisAngle( VOID, me, aUndefList ) ) then __throwError( VOID, me, [#Error: "Axis angle expected !", #ID: "10505200917"] )
      me.ancestor = __setPropListFromAxisAngle( VOID, me, aUndefList )   
    else if ( iListCnt = iLineList ) then     
      if not( __isLineList( VOID, me, aUndefList ) ) then __throwError( VOID, me, [#Error: "Linear list expected !", #ID: "10505200918"] )
      me.ancestor = [#x: float(aUndefList[1]), #y: float(aUndefList[2]), #z: float(aUndefList[3]), #w: float(aUndefList[4])]      
    else
      __throwError( VOID, me, [#Error: "Undefined list !", #ID: "10505200919"] )
    end if
    --
  else if ilk( aUndefList, #PropList ) then   
    if not( __isPropList( VOID, me, aUndefList ) ) then __throwError( VOID, me, [#Error: "Property list expected !", #ID: "10505200920"] )
    me.ancestor = aUndefList.duplicate()
    --  
  end if
  --
  aUndefList  = VOID 
  --
  return
end
 
 
--***************************************************
--* __SETPROPLISTFROMAXISANGLE
--***************************************************
--*
--***************************************************
on __setPropListFromAxisAngle( PRIVATE, me, aAxisAngle )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200921"] )
  --
  vEuler     = aAxisAngle[1].getNormalized()
  fTheta     = aAxisAngle[2] * DEGTORAD
  fSin       = sin( fTheta * 0.5 )
  --
  lProperty   = [#x: float(0), #y: float(0), #z: float(0), #w: float(1)]
  lProperty.x = vEuler.x * fSin
  lProperty.y = vEuler.y * fSin
  lProperty.z = vEuler.z * fSin
  lProperty.w = cos( fTheta * 0.5 )
  --
  __listNormalize( VOID, me, lProperty )
  --
  return( lProperty )
end
 
 
--***************************************************
--* __LISTNORMALIZE
--***************************************************
--
--***************************************************
on __listNormalize( PRIVATE, me, aPropList )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200922"] )
  if (voidP(aPropList))     then aPropList = me.ancestor
  --
  fMagnitude = sqrt( aPropList[1] * aPropList[1] + aPropList[2] * aPropList[2] + aPropList[3] * aPropList[3] + aPropList[4] * aPropList[4] )
  --  
  if ( fMagnitude < EPSILON ) then
    aPropList[1] = float(0)
    aPropList[2] = float(0)
    aPropList[3] = float(0)
    aPropList[4] = float(1)
  else
    fLength      = float(1) / fMagnitude
    aPropList[1] = aPropList[1] * fLength
    aPropList[2] = aPropList[2] * fLength
    aPropList[3] = aPropList[3] * fLength
    aPropList[4] = aPropList[4] * fLength
  end if  
  --  
  return
end
 
 
--***************************************************
--* __ISAXISANGLE
--***************************************************
--*
--***************************************************
on __isAxisAngle( PRIVATE, me, aAxisAngle )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200923"] )
  --
  if (not(ilk( aAxisAngle, #LinearList ))) then return( FALSE )
  if ( aAxisAngle.count() <> 2 )           then return( FALSE )
  if (not(ilk( aAxisAngle[1], #Vector )))  then return( FALSE )
  if (not(ilk( aAxisAngle[2], #Number )))  then return( FALSE )
  --
  return( TRUE )
end
 
 
--***************************************************
--* __ISLINELIST
--***************************************************
--*
--***************************************************
on __isLineList( PRIVATE, me, aLineList )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200924"] )
  --
  if not(ilk( aLineList, #LinearList )) then return( FALSE )
  if ( aLineList.count() <> 4 )         then return( FALSE ) 
  if not(ilk( aLineList[1], #Number ))  then return( FALSE )
  if not(ilk( aLineList[2], #Number ))  then return( FALSE )
  if not(ilk( aLineList[3], #Number ))  then return( FALSE )
  if not(ilk( aLineList[4], #Number ))  then return( FALSE )
  --
  return( TRUE )
end
 
 
--***************************************************
--* __ISPROPLIST
--***************************************************
--*
--***************************************************
on __isPropList( PRIVATE, me, aPropList )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200925"] )
  --
  if not(ilk( aPropList, #PropList ))     then return( FALSE ) 
  if ( aPropList.count() <> 4 )           then return( FALSE )
  if ilk( aPropList.getaProp(#x), #VOID ) then return( FALSE )
  if ilk( aPropList.getaProp(#y), #VOID ) then return( FALSE )
  if ilk( aPropList.getaProp(#z), #VOID ) then return( FALSE )
  if ilk( aPropList.getaProp(#w), #VOID ) then return( FALSE )
  if not(ilk( aPropList.x, #Float ))      then return( FALSE )
  if not(ilk( aPropList.y, #Float ))      then return( FALSE )
  if not(ilk( aPropList.z, #Float ))      then return( FALSE )
  if not(ilk( aPropList.w, #Float ))      then return( FALSE )
  --
  return( TRUE )
end
 
 
--***************************************************
--* __ARCCOS
--***************************************************
--*
--***************************************************
on __arcCos( PRIVATE, me, x )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  if not(quaternionP( me )) then __throwError( VOID, me, [#Error: "Quaternion expected !", #ID: "10505200926"] )
  --
  x = float(x)
  --
  if (x < float(0)) then
    return( PI + atan( sqrt( float(1) - (x * x) ) / x ) )
  else if (x > 0) then
    return( atan( sqrt( float(1) - (x * x) ) / x ) )
  else
    return( PI * 0.5 )
  end if 
  --
end
 
 
--***************************************************
--* __THROWERROR
--***************************************************
--
--***************************************************
on __throwError( PRIVATE, me, aErrorList )
  --
  if not(voidP( PRIVATE ))  then __throwPrivate( VOID, me )
  --
  if ( ilk(_player.alertHook, #Object) AND (_system.environmentPropList[#runMode] = "Author") ) then    
    -- _player.alert(...)    
  else    
    trace( "Error:"&&aErrorList.Error )       
  end if
  --
  HALT
  --
  return
end
 
 
--***************************************************
--* __THROWPRIVATE
--***************************************************
--
--***************************************************
on __throwPrivate( PRIVATE, me )
  --
  if ( ilk(_player.alertHook, #Object) AND (_system.environmentPropList[#runMode] = "Author") ) then 
    -- _player.alert(...)     
  else
    trace( "Error: You couldn't access private method from your location !" )        
  end if
  --
  HALT
  --  
  return
end