v3dlib.pkg

Go to the documentation of this file.

// -- processed by [filterPKG] --
/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2009 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

/**************************************************
 SO3Engine (Ogre 3D) library
 
 Version: 1.0
 Author: Bastien BOURINEAU / I-maginer
 Last update: 02.04.2009

**************************************************/

// Meter
var iGlobalUnit=1;

var sV3DDEFAULTRESOURCESPATH="tools/os3dlib/res/";

var iV3Ddebug=0;

// Frames handling
var iV3DmaxFramerate=90;     // Maximum possible framerate

var iV3DIndex=0;
var iV3DSessionIndex=0;

// - Mouse -
var V3DCLICK_NO=0;
var V3DCLICK_LEFT=1;
var V3DCLICK_RIGHT=2;
var V3DCLICK_SHIFT=4;
var V3DCLICK_CTRL=8;
var V3DCLICK_MIDDLE=16;


var V3DAXIS_X=32;
var V3DAXIS_Y=64;
var V3DAXIS_Z=128;


// - Struct viewport -
struct V3Dviewport{

  V3D_iViewportIndex (I);
  V3D_viewport (SO3_VIEWPORT);
  V3D_iViewportX (F);
  V3D_iViewportY (F);
  V3D_iViewportW (F);
  V3D_iViewportH (F);
  V3D_lFlashControl ([SO3_FLASH_CONTROL r1]);
  V3D_iBgColor (I

);
};
typedef struct mkV3Dviewport V3Dviewport;


// - Struct Axis -
struct V3Daxis{

  V3D_axisFather (SO3_OBJECT);
  V3D_axisShell (SO3_OBJECT);
  V3D_xAxisObject (SO3_OBJECT);
  V3D_yAxisObject (SO3_OBJECT);
  V3D_zAxisObject (SO3_OBJECT);
  V3D_xAxisTextObject (SO3_OBJECT);
  V3D_yAxisTextObject (SO3_OBJECT);
  V3D_zAxisTextObject (SO3_OBJECT);
  V3D_iAxisMode (I
  
);
};
typedef struct mkV3Daxis V3Daxis;


// - Struct Helper -
struct V3Dhelper{

  V3D_helperFather (SO3_OBJECT);
  V3D_helperIcon (SO3_OBJECT);
  V3D_iHelperMode (I
  
);
};
typedef struct mkV3Dhelper V3Dhelper;


// - Struct Session -
struct V3Dsession{

  V3D_sessionView (V3Dview);
  V3D_session (SO3_SCENE);
  V3D_lCamera ([[I SO3_OBJECT] r1]);
  V3D_defaultCamera (SO3_OBJECT);
  V3D_prevDefaultCamera (SO3_OBJECT);
  V3D_shellNavigate (SO3_OBJECT);
  
  V3D_physics (V3Dphysics);
  V3D_lAxis ([[SO3_OBJECT V3Daxis] r1]);
  V3D_lHelper ([[SO3_OBJECT V3Dhelper] r1]);
  V3D_helperGrid ([SO3_OBJECT [SO3_OBJECT r1]]);
  V3D_bHelpersState (I);
  
  V3D_selectedAxis ([V3Daxis I]);
  V3D_cbAxisClick (fun [V3Dsession SO3_OBJECT I I I I] I);
  V3D_cbAxisUnClick (fun [V3Dsession SO3_OBJECT I I I I] I);  
  V3D_cbAxisMove (fun [V3Dsession SO3_OBJECT I I I I F] I);
  V3D_bNavigate (I);
  
  V3D_lAnimations ([[S V3Danim] r1]);
  V3D_bAnimations (I
  
);
};
typedef struct mkV3Dsession V3Dsession;


struct V3Danim{

  V3D_anim (SO3_ANIM);
  V3D_meshAnim (SO3_OBJECT);
  V3D_nodePRS ([[F F F] [F F F F] [F F F]]);
  V3D_sAnimName (S);
  V3D_bAnimState (I);
  V3D_iAnimType (I);
  V3D_cbAnimPlay (fun [V3Danim] I);
  V3D_cbAnimPause (fun [V3Danim] I);
  V3D_cbAnimStop (fun [V3Danim] I);
  V3D_AnimEditorValues ([I I F F]
  
);
};
typedef struct mkV3Danim V3Danim;


// - Struct 3D -
struct V3Dview{

  V3D_win (ObjWin);
  V3D_buffer (SO3_BUFFER);
  V3D_channel (Chn);
  V3D_iWinW (I);
  V3D_iWinH (I);
  V3D_iWinX (I);
  V3D_iWinY (I);
  V3D_iOldWinW (I);
  V3D_iOldWinH (I);  
  
  V3D_lSessions ([[I V3Dsession] r1]);
  V3D_bPaused (I);
  
  // ressources 
  V3D_iRenderTick (I);
  
  // mouse / keyboard
  V3D_iClickStatus (I);
  V3D_iClickX (I);
  V3D_iClickY (I);
  V3D_iMoveX (I);
  V3D_iMoveY (I);
  V3D_iRenderMoveX (I);
  V3D_iRenderMoveY (I);  
  V3D_iMoveClickStatus (I);
  V3D_bMouseEnabled (I);
  V3D_bKeyboardEnabled (I);
  
  // Callback
  V3D_cbInit (fun [V3Dview] I);
  V3D_cbDestroy (fun [V3Dview] I);
  V3D_cbPreRenderEffects (fun [V3Dview] I);
  V3D_cbPreRender (fun [V3Dview] I);
  V3D_cbPostRender (fun [V3Dview] I);
  V3D_cbClick (fun [V3Dview I I I] I);
  V3D_cbDbClick (fun [V3Dview I I I] I);
  V3D_cbUnClick (fun [V3Dview I I I] I);
  V3D_cbWheel (fun [V3Dview I I I I] I);
  V3D_cbCursorMove (fun [V3Dview I I I] I);
  V3D_cbKeyDown (fun [V3Dview I I] I);
  V3D_cbKeyUp (fun [V3Dview I] I);
  V3D_cbDropFile (fun [V3Dview I I [P r1]] I);
  V3D_cbCameraChange (fun [V3Dview V3Dsession SO3_OBJECT] I);
  V3D_cbResizeView (fun [V3Dview I I] I);
  
  V3D_lViewport ([[I V3Dviewport] r1]);
  
  V3D_bFullScreen (I);
  V3D_bState (I
  
);
};
typedef struct mkV3Dview V3Dview;


proto V3DviewSetFocus=fun [V3Dview] I;
proto V3DphysCreate=fun [V3Dsession] I;
proto V3DphysDestroy=fun [V3Dsession] I;
proto V3DphysReset=fun [V3Dsession] I;
//proto V3DphysUpdate=fun [V3Dsession] I;

V3Dlcat(p, q){
if p==nil
  then
    q
  else let p -> [h nxt] in
    h::V3Dlcat nxt q;
}


V3DisUrl(url){
if (!strcmpi "http://" (substr url 0 7)) || (!strcmpi "https://" (substr url 0 8)) || (!strcmpi "ftp://" (substr url 0 6)) || (!strcmpi "mms://" (substr url 0 6))  || (!strcmpi "rstp://" (substr url 0 7)) then
    1
  else 0;
}


V3DgetPathFile(longfile, file){
if (longfile==nil) || (strlen longfile)==0 || (nth_char longfile ((strlen longfile)-1)) == '/ then
  (
    if (strfind "." file 0) != nil then
      [longfile file]
    else if file != nil then
      [strcatn longfile::file::"/"::nil nil]
    else
      [longfile nil];
  )
  else
    V3DgetPathFile
      substr longfile 0 (strlen longfile)-1
      strcat
        substr longfile ((strlen longfile)-1) 1
        file;
}


// return the fileName without Path and Extension
V3DgetFileNameWithoutExt(file){
let V3DgetPathFile file "" -> [_ file2] in
  substr file2 0 (strfind "." file2 0);
}


V3DgetFileExt(file){
let V3DgetPathFile file "" -> [_ file2] in
  substr file2 ((strfind "." file2 0) + 1) 1024;
}


V3DgetFilePathWithoutExt(file){
substr file 0 (strfind "." file 0);
}


V3DremoveIdxFromList(l, idx){
if l==nil
  then
    nil
  else
    let hd l -> [id _] in
    if id == idx then
      tl l
    else
      (hd l)::V3DremoveIdxFromList tl l idx;
}


V3DremoveTupFromListBy2ndElem(l, s2nd){
if l==nil
  then
    nil
  else
    let hd l -> [_ elem] in
    if elem == s2nd then
      tl l
    else
      (hd l)::V3DremoveTupFromListBy2ndElem tl l s2nd;
}


V3DremoveTupFromListByName(l, name){
if l==nil
  then
    nil
  else
    let hd l -> [sname _] in
    if (!strcmp name sname) then
      tl l
    else
      (hd l)::V3DremoveTupFromListByName tl l name;
}


V3DgetSessionIndex(viewstr, sessionstr){
let sizelist viewstr.V3D_lSessions -> size in
  let nil -> idx in
  let 0 -> i in
  (
    while i < size && idx == nil do
    (
      let nth_list viewstr.V3D_lSessions i -> [sidx sstr] in
      if sstr != sessionstr then nil else
        set idx = sidx;
      
      set i = i + 1;
    );
    idx;
  );
}


V3DgetSession(sessionstr){
sessionstr.V3D_session;
}


V3DgetSessionByIndex(viewstr, idx){
switch viewstr.V3D_lSessions idx;
}


V3DgetDefaultSession(viewstr){
switch viewstr.V3D_lSessions 0;
}


V3DdegToRad(f){
f *. ((2.0 *. PIf) /. 360.0);
}


V3DradToDeg(f){
f /. ((2.0 *. PIf) /. 360.0);
}


V3DgetObjectPos(sessionstr, obj){
if sessionstr == nil then nil else
  (
    SO3ObjectGetPosition sessionstr.V3D_session obj;
  );
}


V3DgetObjectScale(sessionstr, obj){
if sessionstr == nil then nil else
  (
    SO3ObjectGetScale sessionstr.V3D_session obj;
  );
}


V3DgetObjectOrientation(sessionstr, obj){
if sessionstr == nil then nil else
  (
    SO3ObjectGetOrientation sessionstr.V3D_session obj;
  );
}


V3DsetObjectPos(sessionstr, obj, pos){
if sessionstr == nil then nil else
  (
    if pos == nil then nil else
      SO3ObjectSetPosition sessionstr.V3D_session obj pos;

    pos;
  );
}


V3DsetObjectScale(sessionstr, obj, scale){
if sessionstr == nil then nil else
  (
    if scale == nil then nil else
      SO3ObjectSetScale sessionstr.V3D_session obj scale;
  
    scale;
  );
}


V3DsetObjectOrientation(sessionstr, obj, quat){
if sessionstr == nil then nil else
  (
    if quat == nil then nil else
      SO3ObjectSetOrientation sessionstr.V3D_session obj quat;
    quat;
  );
}


V3DgetSessionView(sessionstr){
sessionstr.V3D_sessionView;
}


V3DgetViewportByIndex(viewstr, idx){
switch viewstr.V3D_lViewport idx;
}


V3DgetViewportIndex(viewstr, viewport){
let sizelist viewstr.V3D_lViewport -> size in
  let nil -> idx in
  let 0 -> i in
  (
    while i < size && idx == nil do
    (
      let nth_list viewstr.V3D_lViewport i -> [sidx view] in
      if view != viewport then nil else
        set idx = sidx;
      
      set i = i + 1;
    );
    idx;
  );
}


V3DgetDefaultViewport(viewstr){
switch viewstr.V3D_lViewport 0;
}


V3DsetViewportColor(viewportstr, color){
set viewportstr.V3D_iBgColor = color;
  SO3ViewportSetBackgroundColor viewportstr.V3D_viewport color;
  0;
}


V3DgetViewportColor(viewportstr){
SO3ViewportGetBackgroundColor viewportstr.V3D_viewport;
}


V3DdelViewport(viewstr, viewportstr){
let sizelist viewportstr.V3D_lFlashControl -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list viewportstr.V3D_lFlashControl i -> flashctrl in
    (
      SO3FlashControlDestroy flashctrl;
    );
    set i = i + 1;
  );
  set viewportstr.V3D_lFlashControl = nil;
  
  SO3ViewportDestroy viewportstr.V3D_viewport;
  let V3DgetViewportIndex viewstr viewportstr -> idx in
    set viewstr.V3D_lViewport = V3DremoveIdxFromList viewstr.V3D_lViewport idx;
  0;
}


V3DaddViewport(viewstr, x, y, w, h, backcolor){
let
    let 0 -> i in
    (
      while ((switch viewstr.V3D_lViewport i) != nil) do
      (
        set i = i + 1;
      );
      i;
    )
  -> idx in
  let mkV3Dviewport [idx nil x y w h nil backcolor] -> newviewport in
  (
    set viewstr.V3D_lViewport = V3Dlcat viewstr.V3D_lViewport [idx newviewport]::nil;
    newviewport;
  );
}


V3DsetViewport(viewstr, viewportstr, sessionstr, camera){
if viewportstr.V3D_viewport == nil then
  (
    set viewportstr.V3D_viewport = SO3ViewportCreate viewstr.V3D_channel viewstr.V3D_buffer (V3DgetSession sessionstr) camera viewportstr.V3D_iViewportX viewportstr.V3D_iViewportY viewportstr.V3D_iViewportW viewportstr.V3D_iViewportH viewportstr.V3D_iViewportIndex;
    SO3ViewportSetBackgroundColor viewportstr.V3D_viewport viewportstr.V3D_iBgColor;
    SO3ViewportSetShadowEnabled viewportstr.V3D_viewport 1;
    0;
  )
  else
  (
    SO3CameraSetViewport viewportstr.V3D_viewport (V3DgetSession sessionstr) camera;
    0;
  );
  0;
}


V3DsetViewportPositionSize(viewportstr, x, y, w, h){
if viewportstr.V3D_viewport == nil then nil else
  (
    set viewportstr.V3D_iViewportX = x;
    set viewportstr.V3D_iViewportY = y;
    set viewportstr.V3D_iViewportW = w;
    set viewportstr.V3D_iViewportH = h;
      SO3ViewportSetPositionSize viewportstr.V3D_viewport x y w h;
  );
  0;
}


V3DchangeCameraViewport(sessionstr, viewportstr, camera){
let if viewportstr == nil then V3DgetDefaultViewport (V3DgetSessionView sessionstr) else viewportstr -> viewportstr in
  (
    V3DsetViewport (V3DgetSessionView sessionstr) viewportstr sessionstr camera;
    //exec sessionstr.V3D_sessionView.V3D_cbCameraChange with [sessionstr.V3D_sessionView sessionstr camera];
  );
  0;
}


V3DsetCamera(sessionstr, camera, fovlenght, fovy, nclip, fclip){
if sessionstr == nil then nil else
  (
    if fovlenght == nil then nil else
      SO3CameraSetFocalLenght sessionstr.V3D_session camera fovlenght;
    
    if fovy == nil then nil else
      SO3CameraSetFOVy sessionstr.V3D_session camera fovy;
      
    if nclip == nil then nil else
      SO3CameraSetNearClipDistance sessionstr.V3D_session camera nclip;
    
    if fclip == nil then nil else
      SO3CameraSetFarClipDistance sessionstr.V3D_session camera fclip;      
  );
  camera;
}


V3DgetCameraByIndex(sessionstr, idx){
switch sessionstr.V3D_lCamera idx;
}


V3DgetCameraIndex(sessionstr, camera){
let sizelist sessionstr.V3D_lCamera -> size in
  let nil -> idx in
  let 0 -> i in
  (
    while i < size && idx == nil do
    (
      let nth_list sessionstr.V3D_lCamera i -> [sidx cam] in
      if cam != camera then nil else
        set idx = sidx;
      
      set i = i + 1;
    );
    idx;
  );
}


V3DgetDefaultCamera(sessionstr){
sessionstr.V3D_defaultCamera;
}


V3DsetDefaultCamera(sessionstr, camera){
if camera == nil then nil else
  (
    set sessionstr.V3D_prevDefaultCamera = sessionstr.V3D_defaultCamera;
    set sessionstr.V3D_defaultCamera = camera;
    exec sessionstr.V3D_sessionView.V3D_cbCameraChange with [sessionstr.V3D_sessionView sessionstr camera];
  );
  0;
}


V3DsetCbCameraChange(viewstr, cbfun){
set viewstr.V3D_cbCameraChange = cbfun;
  0;
}


V3DrestaurePreviousDefaultCamera(sessionstr){
if sessionstr.V3D_prevDefaultCamera == nil then nil else
  let sessionstr.V3D_defaultCamera -> camera in
  (
    set sessionstr.V3D_defaultCamera = sessionstr.V3D_prevDefaultCamera;
    set sessionstr.V3D_prevDefaultCamera = camera;
  );
  0;
}


V3DdelCamera(sessionstr, camera){
if camera != sessionstr.V3D_defaultCamera then nil else
  (
    V3DrestaurePreviousDefaultCamera sessionstr;
    set sessionstr.V3D_prevDefaultCamera = nil;
    V3DchangeCameraViewport sessionstr (V3DgetDefaultViewport (V3DgetSessionView sessionstr)) (V3DgetDefaultCamera sessionstr);
  );
  
  SO3ObjectDestroy sessionstr.V3D_session camera;
  
  let V3DgetCameraIndex sessionstr camera -> idx in
    set sessionstr.V3D_lCamera = V3DremoveIdxFromList sessionstr.V3D_lCamera idx;
  0;
}


V3DaddCamera(sessionstr, name){
let
    let 0 -> i in
    (
      while ((switch sessionstr.V3D_lCamera i) != nil) do
      (
        set i = i + 1;
      );
      i;
    )
  -> idx in
  let SO3CameraCreate sessionstr.V3D_session name -> newcam in
  (
    set sessionstr.V3D_lCamera = V3Dlcat sessionstr.V3D_lCamera [idx newcam]::nil;
    if sessionstr.V3D_defaultCamera != nil then nil else
      set sessionstr.V3D_defaultCamera = newcam;
    
    newcam;
  );
}


V3DsetLight(sessionstr, light, type, dcolor, scolor, range, const, linear, quadr){
if (sessionstr == nil) || (light == nil) then nil else
  (
    SO3LightSetType sessionstr.V3D_session light type;
    SO3LightSetDiffuseColor sessionstr.V3D_session light dcolor;
    SO3LightSetSpecularColor sessionstr.V3D_session light scolor;
    SO3LightSetAttenuation sessionstr.V3D_session light [range const linear quadr];  
    
    light;
  );
}


V3DenableLight(sessionstr, light, state){
SO3LightSetVisible sessionstr.V3D_session light state;
  0;
}


V3DaddLight(sessionstr, name, father, type, dcolor, scolor, range, const, linear, quadr){
if sessionstr == nil then nil else
  let SO3LightCreate sessionstr.V3D_session name -> light in
  (
    if father == nil then nil else
      SO3ObjectLink sessionstr.V3D_session light father;
    
    SO3LightSetType sessionstr.V3D_session light type;
    SO3LightSetDiffuseColor sessionstr.V3D_session light dcolor;
    SO3LightSetSpecularColor sessionstr.V3D_session light scolor;
    SO3LightSetAttenuation sessionstr.V3D_session light [range const linear quadr];
    //SO3LightSetVisible sessionstr.V3D_session light 0;

    //SO3LightSetSpotFallOff sessionstr.V3D_session light falloff;    
    //SO3LightSetPowerScale sessionstr.V3D_session light 1000.0;
    //SO3ObjectLookAt sessionstr.V3D_session light [0.0 0.0 0.0] 2; 
    light;
  );
}


V3DaddResource(sessionstr, ressource, group, type){
let V3DgetPathFile ressource "" -> [longfile filename] in
  if longfile == nil && filename == nil then nil else
  (
    if (filename == nil) then
      SO3AddResourceLocationDirectory (substr longfile 0 ((strlen longfile) - 1)) group
    else if (V3DisUrl ressource) then
      SO3AddResourceLocationURL ressource group
    else if (!strcmpi (V3DgetFileExt filename) "zip") then
      SO3AddResourceLocationZIP ressource group
    else
      SO3SceneLoadResource sessionstr.V3D_session ressource group type;
  );
  0;
}


V3DaddMesh(sessionstr, file, name, idx, group, father){
if (sessionstr == nil) || (file == nil) then nil else
  (
    V3DaddResource sessionstr file group SO3_RESOURCE_MESH;
    
    let SO3SceneLoadEntity sessionstr.V3D_session file strcatn idx::"."::name::nil -> mesh in
    (
      if father == nil then nil else
        SO3ObjectLink sessionstr.V3D_session mesh father;
      mesh;
    );
  );
}


V3DaddEditableMesh(sessionstr, file, name, idx, group, father){
if (sessionstr == nil) || (file == nil) then nil else
  (
    V3DaddResource sessionstr file group SO3_RESOURCE_MESH;

    let SO3SceneLoadEntityWithIndex sessionstr.V3D_session file name idx group -> mesh in
    (
      if father == nil then nil else
        SO3ObjectLink sessionstr.V3D_session mesh father;
      mesh;
    );
  );
}


V3DaddShell(sessionstr, name, idx, father, pos, ang){
if sessionstr == nil then nil else
  let if name == nil || (!strcmp name "") then idx else if idx == nil || (!strcmp idx "") then name else strcatn idx::"."::name::nil -> name in
  let SO3SceneNodeCreate sessionstr.V3D_session name -> shell in
  (
    if father == nil then nil else
      SO3ObjectLink sessionstr.V3D_session shell father;
    
    if pos == nil then nil else
      SO3ObjectSetPosition sessionstr.V3D_session shell pos;
    
    if ang == nil then nil else
      SO3ObjectSetOrientation sessionstr.V3D_session shell ang;
    
    shell;
  );
}


V3DangularTarget(sessionstr, src, dist){
let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) src -> [sax say saz] in
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) dist -> [dax day daz] in
  let SO3MathsQuatToEulerXYZ SO3ObjectGetOrientation (V3DgetSession sessionstr) src -> [_ oy oz] in
  let daz -. saz -> dx in
  let -.dax +. sax -> dy in
  let day -. say -> dh in
  let sqrt ((dx*.dx) +. (dy*.dy)) -> d in
  if d >. 0.001 then
    //SO3MathsEulerXYZToQuat [(atan (dh/.d)) (atan2 dy dx) 0.0]
    SO3MathsEulerXYZToQuat [(atan (dh/.d)) (atan2 dy dx) oz]
  else
    SO3MathsEulerXYZToQuat [0.0 oy oz];
}


// update axis pos and scale
V3DupdateObjectAxis(viewstr, sessionstr, axisstr){
if (axisstr == nil) || (axisstr.V3D_axisFather) == nil then nil else
  let (V3DgetDefaultViewport viewstr) -> viewportstr in  
  let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) camera -> [cx cy cz] in  
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) axisstr.V3D_axisFather -> [ox oy oz] in
  let SO3ObjectGetGlobalOrientation (V3DgetSession sessionstr) axisstr.V3D_axisFather -> quat in
  let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [_ _ vw vh] in
  
  // same object size on different distances
  let SO3CameraGetFOVy sessionstr.V3D_session camera -> fovy in
  let if fovy <=. 0.0 then 0.000001 else fovy -> fovy in
  let sqrt ((sqr(cx -. ox)) +. (sqr(cy -. oy)) +. (sqr(cz -. oz))) -> dist in
  let maxf 0.000001 ((dist /. ((itof vh) /. 2.0)) *. fovy) /. 2.0 -> scale in
  (
    SO3ObjectSetPosition (V3DgetSession sessionstr) axisstr.V3D_axisShell [ox oy oz];
    SO3ObjectSetOrientation (V3DgetSession sessionstr) axisstr.V3D_axisShell quat;
    SO3ObjectSetScale (V3DgetSession sessionstr) axisstr.V3D_axisShell [scale scale scale];
    //SO3ObjectSetOrientation (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject (V3DangularTarget sessionstr axisstr.V3D_xAxisTextObject camera);
    //SO3ObjectSetOrientation (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject (V3DangularTarget sessionstr axisstr.V3D_xAxisTextObject camera);
    //SO3ObjectSetOrientation (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject (V3DangularTarget sessionstr axisstr.V3D_xAxisTextObject camera);
  );
  0;
}


V3DupdateAxisTarget(viewstr, sessionstr){
let sizelist sessionstr.V3D_lAxis -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lAxis i -> [refobj axisstr] in
      V3DupdateObjectAxis viewstr sessionstr axisstr;
    
    set i = i + 1;
  );
  0;
}


V3DshowObjectAxis(viewstr, sessionstr, refobj, mode, state){
if (refobj == nil) then nil else
  if state then
  let (switch sessionstr.V3D_lAxis refobj) -> axisstr in
  let if (axisstr != nil) then axisstr else mkV3Daxis [nil nil nil nil nil nil nil nil 0] -> axisstr in
  let SO3ObjectGetName (V3DgetSession sessionstr) refobj -> refname in
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) refobj -> pos in
  let SO3ObjectGetGlobalOrientation (V3DgetSession sessionstr) refobj -> quat in
  let (V3DgetDefaultViewport viewstr) -> viewportstr in  
  let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in  
  (
    set axisstr.V3D_iAxisMode = mode;
    
    // reset axis if exist
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_xAxisObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_yAxisObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_zAxisObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject;
    SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_axisShell;
    
    set axisstr.V3D_axisFather = refobj;
    set axisstr.V3D_axisShell = SO3SceneNodeCreate (V3DgetSession sessionstr) strcat refname ".coord_axis";
    
    if mode == 2 then
    (
      set axisstr.V3D_xAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_x.mesh") strcat refname ".coords_ang_axis_x";
      set axisstr.V3D_yAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_y.mesh") strcat refname ".coords_ang_axis_y";
      set axisstr.V3D_zAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_z.mesh") strcat refname ".coords_ang_axis_z";
    )
    else
    (
      set axisstr.V3D_xAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_x.mesh") strcat refname ".coords_axis_x";
      set axisstr.V3D_yAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_y.mesh") strcat refname ".coords_axis_y";
      set axisstr.V3D_zAxisObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_z.mesh") strcat refname ".coords_axis_z";
    );
    
    set axisstr.V3D_xAxisTextObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_x.mesh") strcat refname ".coords_axis_text_x";
    set axisstr.V3D_yAxisTextObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_y.mesh") strcat refname ".coords_axis_text_y";
    set axisstr.V3D_zAxisTextObject = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_z.mesh") strcat refname ".coords_axis_text_z";
    
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_xAxisObject 1;
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_yAxisObject 1;
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_zAxisObject 1;
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject 1;
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject 1;
    SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject 1;
    
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_xAxisObject axisstr.V3D_axisShell;
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_yAxisObject axisstr.V3D_axisShell;
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_zAxisObject axisstr.V3D_axisShell;
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject axisstr.V3D_axisShell;
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject axisstr.V3D_axisShell;
    SO3ObjectLink (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject axisstr.V3D_axisShell;
    
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_xAxisObject 0;
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_yAxisObject 0;
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_zAxisObject 0;
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject 0;
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject 0;
    SO3ObjectSetCastShadows (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject 0;
    
    SO3ObjectSetPosition (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject [95.0 0.0 0.0];
    SO3ObjectSetPosition (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject [0.0 95.0 0.0];
    SO3ObjectSetPosition (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject [0.0 0.0 95.0];
    
    SO3ObjectSetPosition (V3DgetSession sessionstr) axisstr.V3D_axisShell pos;
    SO3ObjectSetOrientation (V3DgetSession sessionstr) axisstr.V3D_axisShell quat;

    SO3ObjectSetAutoTracking (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject camera 1 [0.0 0.0 (-.1.0)] nil;
    SO3ObjectSetAutoTracking (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject camera 1 [0.0 0.0 (-.1.0)] nil;
    SO3ObjectSetAutoTracking (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject camera 1 [0.0 0.0 (-.1.0)] nil;
    
    // TODO change to render priority
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_xAxisObject 1;
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_yAxisObject 1;
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_zAxisObject 1;
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject 1;
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject 1;
    SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject 1;    
    
    set sessionstr.V3D_lAxis = V3Dlcat sessionstr.V3D_lAxis [refobj axisstr]::nil;
  )
  else
  (
    let (switch sessionstr.V3D_lAxis refobj) -> axisstr in
    if axisstr == nil then nil else
    (
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_xAxisObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_yAxisObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_zAxisObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_xAxisTextObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_yAxisTextObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_zAxisTextObject;
      SO3ObjectDestroy (V3DgetSession sessionstr) axisstr.V3D_axisShell;
      
      set sessionstr.V3D_lAxis = V3DremoveIdxFromList sessionstr.V3D_lAxis refobj;
    );
  );
  0;
}


// update axis pos and scale
V3DupdateObjectHelper(viewstr, sessionstr, helperstr){
if (helperstr == nil) || (helperstr.V3D_helperFather) == nil then nil else
  let (V3DgetDefaultViewport viewstr) -> viewportstr in  
  let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) camera -> [cx cy cz] in  
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) helperstr.V3D_helperFather -> [ox oy oz] in
  let SO3ObjectGetGlobalOrientation (V3DgetSession sessionstr) helperstr.V3D_helperFather -> quat in
  let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [_ _ vw vh] in
  
  // same object size on different distances
  let SO3CameraGetFOVy sessionstr.V3D_session camera -> fovy in
  let if fovy <=. 0.0 then 0.000001 else fovy -> fovy in
  let sqrt ((sqr(cx -. ox)) +. (sqr(cy -. oy)) +. (sqr(cz -. oz))) -> dist in
  let maxf 0.000001 ((dist /. ((itof vh) /. 2.0)) *. fovy) /. 2.0 -> scale in
  (
    SO3ObjectSetPosition (V3DgetSession sessionstr) helperstr.V3D_helperIcon [ox oy oz];
    SO3ObjectSetOrientation (V3DgetSession sessionstr) helperstr.V3D_helperIcon quat;
    SO3ObjectSetScale (V3DgetSession sessionstr) helperstr.V3D_helperIcon [scale scale scale];
  );
  0;
}


V3DupdateHelpersTarget(viewstr, sessionstr){
if !sessionstr.V3D_bHelpersState then nil else
  let sizelist sessionstr.V3D_lHelper -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lHelper i -> [refobj helperstr] in
      V3DupdateObjectHelper viewstr sessionstr helperstr;
    
    set i = i + 1;
  );
  0;
}


V3DshowObjectHelper(viewstr, sessionstr, refobj, mode, state){
if (refobj == nil) then nil else
  if state then
  let (switch sessionstr.V3D_lHelper refobj) -> helperstr in
  let if helperstr != nil then helperstr else mkV3Dhelper [nil nil mode] -> helperstr in
  let SO3ObjectGetName (V3DgetSession sessionstr) refobj -> refname in
  let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) refobj -> pos in
  let SO3ObjectGetGlobalOrientation (V3DgetSession sessionstr) refobj -> quat in
  let (V3DgetDefaultViewport viewstr) -> viewportstr in  
  let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in  
  (
    // reset helper if exist
    SO3ObjectDestroy (V3DgetSession sessionstr) helperstr.V3D_helperIcon;
    
    set helperstr.V3D_helperFather = refobj;
    
    if !sessionstr.V3D_bHelpersState then nil else
    ( 
      if mode == 4 then // light
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_light.mesh") strcat refname ".helper_light";
      )
      else if mode == 8 then // camera
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_camera.mesh") strcat refname ".helper_camera";
      )
      else // dummy
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_dummy.mesh") strcat refname ".helper_dummy";
      );
      
      //SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) helperstr.V3D_helperIcon 1;
      
      SO3ObjectSetCastShadows (V3DgetSession sessionstr) helperstr.V3D_helperIcon 0;
      
      SO3ObjectSetPosition (V3DgetSession sessionstr) helperstr.V3D_helperIcon pos;
      SO3ObjectSetOrientation (V3DgetSession sessionstr) helperstr.V3D_helperIcon quat;
      
      // TODO change to render priority
      //SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) helperstr.V3D_helperIcon 1;  
    );
    
    set sessionstr.V3D_lHelper = V3Dlcat sessionstr.V3D_lHelper [refobj helperstr]::nil;
  )
  else
  (
    let (switch sessionstr.V3D_lHelper refobj) -> helperstr in
    if helperstr == nil then nil else
    (
      SO3ObjectDestroy (V3DgetSession sessionstr) helperstr.V3D_helperIcon;
      
      set sessionstr.V3D_lHelper = V3DremoveIdxFromList sessionstr.V3D_lHelper refobj;
    );
  );
  0;
}


V3DisSceneHelperVisible(sessionstr){
if !sessionstr.V3D_bHelpersState then 0 else 1;
}


V3DenableHelpers(viewportstr, sessionstr, state){
let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in  
  let sizelist sessionstr.V3D_lHelper -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lHelper i -> [_ helperstr] in
    if state then
    let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) helperstr.V3D_helperFather -> pos in
    let SO3ObjectGetGlobalOrientation (V3DgetSession sessionstr) helperstr.V3D_helperFather -> quat in
    let SO3ObjectGetName (V3DgetSession sessionstr) helperstr.V3D_helperFather -> refname in
    (
      // reset helper if exist
      SO3ObjectDestroy (V3DgetSession sessionstr) helperstr.V3D_helperIcon;

      if helperstr.V3D_iHelperMode == 4 then // light
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_light.mesh") strcat refname ".helper_light";
      )
      else if helperstr.V3D_iHelperMode == 8 then // camera
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_camera.mesh") strcat refname ".helper_camera";
      )
      else // dummy
      (
        set helperstr.V3D_helperIcon = SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_dummy.mesh") strcat refname ".helper_dummy";
      );
          
      SO3ObjectSetMouseForeGround (V3DgetSession sessionstr) helperstr.V3D_helperIcon 1;
      
      SO3ObjectSetCastShadows (V3DgetSession sessionstr) helperstr.V3D_helperIcon 0;
      
      SO3ObjectSetPosition (V3DgetSession sessionstr) helperstr.V3D_helperIcon pos;
      SO3ObjectSetOrientation (V3DgetSession sessionstr) helperstr.V3D_helperIcon quat;
      
      // TODO change to render priority
      SO3ObjectSetRenderOverlay (V3DgetSession sessionstr) helperstr.V3D_helperIcon 1;
      0;
    )
    else
    (
      SO3ObjectDestroy (V3DgetSession sessionstr) helperstr.V3D_helperIcon;
      0;
    );
    
    set i = i + 1;
  );
  set sessionstr.V3D_bHelpersState = state;
  0;
}


V3DgetObjectFromHelper(sessionstr, obj){
let nil -> found in
  (
    let sizelist sessionstr.V3D_lHelper -> size in
    let 0 -> i in
    while i < size && found == nil do
    (
      let nth_list sessionstr.V3D_lHelper i -> [_ helperstr] in
        if helperstr.V3D_helperIcon != obj then nil else
          set found = helperstr.V3D_helperFather;
        
      set i = i + 1;
    );
    if found == nil then obj else found;
  );
}


V3DgetObjectSize(sessionstr, object){
let SO3ObjectGetBoundingBoxInfo (V3DgetSession sessionstr) object -> [size _ _] in
    size;
}


V3DgetGlobalObjectCenter(sessionstr, object){
let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) object -> [x y z] in
  let SO3ObjectGetBoundingBoxInfo (V3DgetSession sessionstr) object -> [_ bpos _] in
  let bpos -> [bx by bz] in
  if bpos == nil then
    [x y z]
  else
    [(x +. bx) (y +. by) (z +. bz)];
}


V3DgetObjectRadius(sessionstr, object){
let V3DgetObjectSize sessionstr object -> size in
  let size -> [px py pz] in
  let if px >. py then px else py -> radius in
  let if radius >. pz then radius else pz -> radius in
  let if size == nil then 100.0 else radius -> radius in
    radius;
}


V3DisSceneGridVisible(sessionstr){
if sessionstr.V3D_helperGrid == nil then 0 else 1;
}


V3DshowSceneGrid(sessionstr, mode){
if (mode && (sessionstr.V3D_helperGrid != nil)) then nil else
  if mode then
  (
    let SO3SceneNodeCreate (V3DgetSession sessionstr) "default_helper_grid" -> node in
    let SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH "helpers/default_grid_helper.mesh") "default_helper_grid_square" -> square in
    let square::nil -> lobj in
    (
      SO3ObjectSetScale (V3DgetSession sessionstr) square [(0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit))];
      SO3ObjectLink (V3DgetSession sessionstr) square node;
      SO3ObjectSetCastShadows (V3DgetSession sessionstr) square 0;
      let -5 * iGlobalUnit -> i in
      while i < (5 * iGlobalUnit) do
      (
        let SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH (if i == 0 then "helpers/h_line_b.mesh" else "helpers/h_line_w.mesh")) strcat "default_helper_grid_hline_" (itoa i) -> hline in
        let SO3SceneLoadEntity (V3DgetSession sessionstr) (strcat sV3DDEFAULTRESOURCESPATH (if i == 0 then "helpers/v_line_b.mesh" else "helpers/v_line_w.mesh")) strcat "default_helper_grid_vline_" (itoa i) -> vline in
        (
          SO3ObjectSetScale (V3DgetSession sessionstr) hline [(0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit))];
          SO3ObjectSetScale (V3DgetSession sessionstr) vline [(0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit)) (0.01 *. (itof iGlobalUnit))];
          SO3ObjectLink (V3DgetSession sessionstr) hline node;
          SO3ObjectLink (V3DgetSession sessionstr) vline node;
          
          SO3ObjectSetCastShadows (V3DgetSession sessionstr) hline 0;
          SO3ObjectSetCastShadows (V3DgetSession sessionstr) vline 0;
          
          SO3ObjectSetPosition (V3DgetSession sessionstr) hline [0.0 0.0 (itof i)];
          SO3ObjectSetPosition (V3DgetSession sessionstr) vline [(itof i) 0.0 0.0];
          
          set lobj = hline::vline::lobj;
        );
        
        set i = i + iGlobalUnit;
      );
      
      set sessionstr.V3D_helperGrid = [node lobj];
    );
    0;
  )
  else if (sessionstr.V3D_helperGrid != nil) then
  let sessionstr.V3D_helperGrid -> [node lobj] in
  (
    let sizelist lobj -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list lobj i -> obj in
        SO3ObjectDestroy (V3DgetSession sessionstr) obj;
      
      set i = i + 1;
    );
    
    SO3ObjectDestroy (V3DgetSession sessionstr) node;
    set sessionstr.V3D_helperGrid = nil;
    0;
  )
  else nil;
  0;
}


V3DcameraPan(sessionstr, viewportstr, x, y){
let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in
  let SO3CameraGetFOVy (V3DgetSession sessionstr) camera -> fovy in
  let if fovy <=. 0.0 then 0.000001 else fovy -> fovy in
  let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [vx vy vw vh] in
  let SO3ObjectGetPosition (V3DgetSession sessionstr) camera -> [_ _ dist] in
  let ((itof vw)) /. atan fovy -> dx in
  let ((-.dist *. ((itof vw))) /. dx /. ((itof vh))) -> coef in
  let (itof x) *. coef -> mx in
  let (itof y) *. coef -> my in
  let [mx my 0.0] -> vect in
    SO3ObjectTranslate (V3DgetSession sessionstr) sessionstr.V3D_shellNavigate vect SO3_LOCAL_TS;
  0;
}


V3DsetShellNavPos(sessionstr, pos){
SO3ObjectSetPosition (V3DgetSession sessionstr) sessionstr.V3D_shellNavigate pos;
  0;
}


V3DsetAmbientLight(sessionstr, color){
SO3SceneSetAmbientLight (V3DgetSession sessionstr) color;
  0;
}


V3DgetAmbientLight(sessionstr){
SO3SceneGetAmbientLight (V3DgetSession sessionstr);
}


V3DsetShadowTechnique(sessionstr, type, dist, color, self){
SO3SceneSetShadowTechnique (V3DgetSession sessionstr) (if type == nil then SO3_SHADOWTYPE_NONE else type);
  SO3SceneSetShadowFarDistance (V3DgetSession sessionstr) (if dist == nil then 3000.0 else dist);
  SO3SceneSetShadowColor (V3DgetSession sessionstr) (if color == nil then 0x000000 else color);
  SO3SceneSetSelfShadowTexture (V3DgetSession sessionstr) (if self == nil then 1 else self);   
  0;
}


V3DsetShadowCameraType(sessionstr, camtype, px, py, pz, pd){
if camtype == SO3_PLANE_SHADOW_CAMERA then
  (
    SO3SceneSetPlaneShadowCamera (V3DgetSession sessionstr) [px py pz] pd;
  )
  else if camtype == SO3_FOCUSED_SHADOW_CAMERA then
  (
    SO3SceneSetFocusedShadowCamera (V3DgetSession sessionstr);
  )
  else if camtype == SO3_LISPSM_SHADOW_CAMERA then
  (
    SO3SceneSetLISPSMShadowCamera (V3DgetSession sessionstr);
  )
  else // SO3_DEFAULT_SHADOW_CAMERA
  (
    SO3SceneSetDefaultShadowCamera (V3DgetSession sessionstr);
  );
  0;
}


V3DgetShadowCameraType(sessionstr){
SO3SceneGetShadowCameraSetup (V3DgetSession sessionstr);
}


V3DsetShadowTextureParams(sessionstr, size, count, offset, fadestart, fadestop){
SO3SceneSetShadowTextureSize (V3DgetSession sessionstr) (if size == nil then 512 else size);
  SO3SceneSetShadowTextureCount (V3DgetSession sessionstr) (if count == nil then 1 else count);
  SO3SceneSetShadowDirLightTextureOffset (V3DgetSession sessionstr) (if offset == nil then 0.0 else offset);
  SO3SceneSetShadowTextureFadeStart (V3DgetSession sessionstr) (if fadestart == nil then 0.7 else fadestart);
  SO3SceneSetShadowTextureFadeEnd (V3DgetSession sessionstr) (if fadestop == nil then 0.9 else fadestop);
  0;
}


V3DsetObjectReceiveShadows(sessionstr, obj, bool){
let SO3EntityMaterialList (V3DgetSession sessionstr) obj -> l in
  let sizelist l -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list l i -> mat in
      SO3MaterialSetReceiveShadows (V3DgetSession sessionstr) mat bool;
      
    set i = i + 1;
  );
  0;
}


V3DsetSceneFog(sessionstr, mode, color, density, linearstart, linearend){
let if mode != nil then mode else SO3SceneGetFogMode (V3DgetSession sessionstr) -> mode in
  let if color != nil then color else SO3SceneGetFogColor (V3DgetSession sessionstr) -> color in
  let if density != nil then density else SO3SceneGetFogDensity (V3DgetSession sessionstr) -> density in
  let if linearstart != nil then linearstart else SO3SceneGetFogStart (V3DgetSession sessionstr) -> linearstart in
  let if linearend != nil then linearend else SO3SceneGetFogEnd (V3DgetSession sessionstr) -> linearend in
    SO3SceneSetFog (V3DgetSession sessionstr) mode color density linearstart linearend;
  0;
}


V3DsetSceneAnimationState(sessionstr, state){
set sessionstr.V3D_bAnimations = state;
  0;
}


V3DgetSceneAnimationState(sessionstr){
sessionstr.V3D_bAnimations;
}


V3DaddAnimation(sessionstr, obj, name, length, speed, weight, state, loop, transmode, rotmode){
let switchstr sessionstr.V3D_lAnimations name -> animexist in
  if animexist != nil then animexist else
  let if weight == nil then 1.0 else weight -> weight in
  let mkV3Danim [nil obj nil name state SO3_SCENENODE_ANIM nil nil nil nil] -> animstr in
  (
    set animstr.V3D_anim = SO3SceneCreateSceneNodesAnimation (V3DgetSession sessionstr) obj animstr.V3D_sAnimName length;
    SO3AnimationSetLoop (V3DgetSession sessionstr) animstr.V3D_anim loop;
    SO3AnimationSetInterpMode (V3DgetSession sessionstr) animstr.V3D_anim transmode;
    SO3AnimationSetRotInterpMode (V3DgetSession sessionstr) animstr.V3D_anim rotmode; 
    SO3AnimationSetWeight (V3DgetSession sessionstr) animstr.V3D_anim weight;
    SO3AnimationSetSpeed (V3DgetSession sessionstr) animstr.V3D_anim speed;
    set sessionstr.V3D_lAnimations = [name animstr]::sessionstr.V3D_lAnimations;
    animstr;
  );
}


V3DaddMorphAnimation(sessionstr, anim, obj, name, speed, weight, state, loop){
if anim == nil then nil else
  let switchstr sessionstr.V3D_lAnimations name -> animexist in
  if animexist != nil then animexist else
  let if weight == nil then 1.0 else weight -> weight in
  let mkV3Danim [anim obj nil name state SO3_VERTEX_ANIM nil nil nil nil] -> animstr in
  (
    SO3AnimationSetLoop (V3DgetSession sessionstr) animstr.V3D_anim loop;
    SO3AnimationSetWeight (V3DgetSession sessionstr) animstr.V3D_anim weight;
    SO3AnimationSetSpeed (V3DgetSession sessionstr) animstr.V3D_anim speed;
    set sessionstr.V3D_lAnimations = [name animstr]::sessionstr.V3D_lAnimations;
    
    animstr;
  );
}


V3DloadSkeleton(sessionstr, obj, sklfile){
SO3SceneAttachSkeleton (V3DgetSession sessionstr) obj sklfile;
}


V3DgetSkeletonRoot(sessionstr, obj){
SO3GetRootBoneFromMesh (V3DgetSession sessionstr) obj;
}


V3DgetAnimationsFromMesh(sessionstr, obj){
SO3ObjectGetVertexAnimations (V3DgetSession sessionstr) obj;
}


V3DgetMeshAnimationByName(sessionstr, obj, name){
SO3SceneGetAnimation sessionstr.V3D_session obj name;
}


V3DdelAnimation(sessionstr, animstr){
if animstr.V3D_anim == nil then nil else
    SO3AnimationDestroy sessionstr.V3D_session animstr.V3D_anim;
    
  set sessionstr.V3D_lAnimations = V3DremoveTupFromListByName sessionstr.V3D_lAnimations animstr.V3D_sAnimName;
  0;
}


V3DaddAnimationKey(sessionstr, animstr, obj, pos, quat, scale, ftime){
let SO3ObjectGetAnimTrack sessionstr.V3D_session obj animstr.V3D_anim -> animtrack in
  let if animtrack == nil then (SO3SceneCreateAnimTrack sessionstr.V3D_session obj animstr.V3D_anim SO3_NODE_TRACK) else animtrack -> animtrack in
    SO3AnimTrackCreateKey sessionstr.V3D_session animtrack ftime pos quat scale;
  0;
}


V3DdelAnimationTrack(sessionstr, animstr, obj){
let SO3ObjectGetAnimTrack sessionstr.V3D_session obj animstr.V3D_anim -> animtrack in
  if animtrack == nil then nil else
    SO3AnimTrackDestroy sessionstr.V3D_session animtrack;
  0;
}


V3DgetAnimationByName(sessionstr, name){
if name == nil then nil else
  let switchstr sessionstr.V3D_lAnimations name -> animstr in
  if animstr == nil then nil else
    animstr;
}


V3DsetAnimationWeight(sessionstr, animstr, weight){
SO3AnimationSetWeight (V3DgetSession sessionstr) animstr.V3D_anim weight;
}


V3DgetAnimationWeight(sessionstr, animstr){
SO3AnimationGetWeight (V3DgetSession sessionstr) animstr.V3D_anim;
}


V3DsetAnimationState(sessionstr, animstr, state){
set animstr.V3D_bAnimState = state;
}


V3DsetAnimationLoop(sessionstr, animstr, loop){
SO3AnimationSetLoop sessionstr.V3D_session animstr.V3D_anim loop;
}


V3DsetAnimationSpeed(sessionstr, animstr, speed){
SO3AnimationSetSpeed sessionstr.V3D_session animstr.V3D_anim speed;
}


V3DsetAnimationInterpolationMode(sessionstr, animstr, mode){
SO3AnimationSetInterpMode sessionstr.V3D_session animstr.V3D_anim mode;
}


V3DsetAnimationRotInterpolationMode(sessionstr, animstr, mode){
SO3AnimationSetRotInterpMode  sessionstr.V3D_session animstr.V3D_anim mode;
}


V3DgetAnimationState(sessionstr, animstr){
animstr.V3D_bAnimState;
}


V3DgetAnimationLoop(sessionstr, animstr){
SO3AnimationGetLoop sessionstr.V3D_session animstr.V3D_anim;
}


V3DgetAnimationSpeed(sessionstr, animstr){
SO3AnimationGetSpeed sessionstr.V3D_session animstr.V3D_anim;
}


V3DgetAnimationType(animstr){
animstr.V3D_iAnimType;
}


V3DsetAnimationPosition(sessionstr, animstr, pos){
SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim pos;
}


V3DgetAnimationPosition(sessionstr, animstr){
SO3AnimationGetTimePosition sessionstr.V3D_session animstr.V3D_anim;
}


V3DgetAnimationLenght(sessionstr, animstr){
SO3AnimationGetLenght sessionstr.V3D_session animstr.V3D_anim;
}


V3DsetAnimationCbPlay(animstr, cbfun){
set animstr.V3D_cbAnimPlay = cbfun;
}


V3DsetAnimationCbPause(animstr, cbfun){
set animstr.V3D_cbAnimPause = cbfun;
}


V3DsetAnimationCbStop(animstr, cbfun){
set animstr.V3D_cbAnimStop = cbfun;
}


V3DresetAnimation(sessionstr, animstr){
V3DsetAnimationState sessionstr animstr 0;
  SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 0;
  SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0;
  
  if animstr.V3D_iAnimType == SO3_SCENENODE_ANIM then
  let animstr.V3D_nodePRS -> [vec quat scale] in
  (
    SO3ObjectSetPosition sessionstr.V3D_session animstr.V3D_meshAnim vec;
    SO3ObjectSetOrientation sessionstr.V3D_session animstr.V3D_meshAnim quat;
    SO3ObjectSetScale sessionstr.V3D_session animstr.V3D_meshAnim scale;
    0;
  )
  else
  (
    SO3ObjectResetToInitialState sessionstr.V3D_session animstr.V3D_meshAnim;
    0;
  );
  0;
}


V3DresetAnimations(sessionstr){
let sizelist sessionstr.V3D_lAnimations -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lAnimations i -> [_ animstr] in
      SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0;
    
    set i = i + 1;
  );
  0;
}


V3DpauseAnimation(sessionstr, animstr){
V3DsetAnimationState sessionstr animstr 0;
  exec animstr.V3D_cbAnimPause with [animstr];
  SO3AnimationSetPause sessionstr.V3D_session animstr.V3D_anim 1;
  0;
}


V3DplayAnimation(sessionstr, animstr){
let SO3AnimationGetLenght (V3DgetSession sessionstr) animstr.V3D_anim -> lenght in
  let SO3AnimationGetTimePosition (V3DgetSession sessionstr) animstr.V3D_anim -> pos in
  if !(SO3AnimationGetPause sessionstr.V3D_session animstr.V3D_anim) || (pos >=. lenght) then
    SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0
  else nil;
  
  V3DsetAnimationState sessionstr animstr 1;
  
  exec animstr.V3D_cbAnimPlay with [animstr];
  SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 1;
  0;
}


V3DplayAnimationFromPos(sessionstr, animstr, startpos){
SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim startpos;
  V3DsetAnimationState sessionstr animstr 1;
  exec animstr.V3D_cbAnimPlay with [animstr];
  SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 1;
  0;
}


V3DstopAnimation(sessionstr, animstr){
V3DsetAnimationState sessionstr animstr 0;
  SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 0;
  exec animstr.V3D_cbAnimStop with [animstr];
  SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0;
  0;
}


V3DenableAnimation(sessionstr, animstr, state){
if !state then
  (
    SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0;
    SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 0;
    
    if animstr.V3D_iAnimType == SO3_SCENENODE_ANIM then
    (
      /*
      let SO3AnimationListAnimTrack sessionstr.V3D_session animstr.V3D_anim -> l in
      let sizelist l -> tsize in
      let 0 -> t in
      while t < tsize do
      (
        let nth_list l t -> track in
        let SO3AnimTrackGetObject sessionstr.V3D_session track -> obj in
          SO3ObjectResetToInitialState sessionstr.V3D_session obj;
        
        set t = t + 1;
      );*/
      0;
    )
    else if animstr.V3D_iAnimType == SO3_VERTEX_ANIM || animstr.V3D_iAnimType == SO3_SKELETAL_ANIM then
    (
      SO3ObjectResetToInitialState sessionstr.V3D_session animstr.V3D_meshAnim;
      0;
    )
    else nil;

  )
  else
  (
    if animstr.V3D_iAnimType == SO3_SCENENODE_ANIM then
    (      
      /*
      let SO3AnimationListAnimTrack sessionstr.V3D_session animstr.V3D_anim -> l in
      let sizelist l -> tsize in
      let 0 -> t in
      while t < tsize do
      (
        let nth_list l t -> track in
        let SO3AnimTrackGetObject sessionstr.V3D_session track -> obj in
          SO3ObjectSetInitialState sessionstr.V3D_session obj;
        
        set t = t + 1;
      );*/
      0;
    )
    else if animstr.V3D_iAnimType == SO3_VERTEX_ANIM || animstr.V3D_iAnimType == SO3_SKELETAL_ANIM then
    (
      SO3ObjectSetInitialState sessionstr.V3D_session animstr.V3D_meshAnim;
      0;
    )
    else nil;
    
    SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim animstr.V3D_bAnimState;
    0;
  );
  0;
}


V3DenableAnimations(sessionstr, state){
let sizelist sessionstr.V3D_lAnimations -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lAnimations i -> [_ animstr] in
    if !state then
    (
      SO3AnimationSetTimePosition sessionstr.V3D_session animstr.V3D_anim 0.0;
      SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim 0;
      
      if animstr.V3D_iAnimType == SO3_SCENENODE_ANIM then
      (
        /*
        let SO3AnimationListAnimTrack sessionstr.V3D_session animstr.V3D_anim -> l in
        let sizelist l -> tsize in
        let 0 -> t in
        while t < tsize do
        (
          let nth_list l t -> track in
          let SO3AnimTrackGetObject sessionstr.V3D_session track -> obj in
            SO3ObjectResetToInitialState sessionstr.V3D_session obj;
          
          set t = t + 1;
        );*/
        0;
      )
      else if animstr.V3D_iAnimType == SO3_VERTEX_ANIM || animstr.V3D_iAnimType == SO3_SKELETAL_ANIM then
      (
        SO3ObjectResetToInitialState sessionstr.V3D_session animstr.V3D_meshAnim;
        0;
      )
      else nil;
      
    )
    else
    (
      if animstr.V3D_iAnimType == SO3_SCENENODE_ANIM then
      (
        /*
        let SO3AnimationListAnimTrack sessionstr.V3D_session animstr.V3D_anim -> l in
        let sizelist l -> tsize in
        let 0 -> t in
        while t < tsize do
        (
          let nth_list l t -> track in
          let SO3AnimTrackGetObject sessionstr.V3D_session track -> obj in
            SO3ObjectSetInitialState sessionstr.V3D_session obj;
          
          set t = t + 1;
        );*/
        0;
      )
      else if animstr.V3D_iAnimType == SO3_VERTEX_ANIM || animstr.V3D_iAnimType == SO3_SKELETAL_ANIM then
      (
        SO3ObjectSetInitialState sessionstr.V3D_session animstr.V3D_meshAnim;
        0;
      )
      else nil;
      
      SO3AnimationSetEnable sessionstr.V3D_session animstr.V3D_anim animstr.V3D_bAnimState;  
    );
    
    set i = i + 1;
  );
  0;
}


V3DanimationEditorValues(sessionstr, state){
if !state then nil else
  let sizelist sessionstr.V3D_lAnimations -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lAnimations i -> [_ animstr] in
    (
      let V3DgetAnimationState sessionstr animstr -> state in
      let V3DgetAnimationLoop sessionstr animstr -> loop in
      let V3DgetAnimationSpeed sessionstr animstr -> speed in
      let V3DgetAnimationWeight sessionstr animstr -> weight in
        set animstr.V3D_AnimEditorValues = [state loop speed weight];
        
      set animstr.V3D_nodePRS = [(SO3ObjectGetPosition sessionstr.V3D_session animstr.V3D_meshAnim) (SO3ObjectGetOrientation sessionstr.V3D_session animstr.V3D_meshAnim) (SO3ObjectGetScale sessionstr.V3D_session animstr.V3D_meshAnim)];
      0;
    );
    
    set i = i + 1;
  );
  
  V3DresetAnimations sessionstr;
  V3DenableAnimations sessionstr state;
  V3DsetSceneAnimationState sessionstr state;
  
  if state then nil else
  let sizelist sessionstr.V3D_lAnimations -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list sessionstr.V3D_lAnimations i -> [_ animstr] in
    let animstr.V3D_AnimEditorValues -> [state loop speed weight] in
    (
      V3DsetAnimationState sessionstr animstr state;
      V3DsetAnimationLoop sessionstr animstr loop;
      V3DsetAnimationSpeed sessionstr animstr speed;
      V3DsetAnimationWeight sessionstr animstr weight;
      
      let animstr.V3D_nodePRS -> [vec quat scale] in
      (
        SO3ObjectSetPosition sessionstr.V3D_session animstr.V3D_meshAnim vec;
        SO3ObjectSetOrientation sessionstr.V3D_session animstr.V3D_meshAnim quat;
        SO3ObjectSetScale sessionstr.V3D_session animstr.V3D_meshAnim scale;
      );
      0;
    );
    
    set i = i + 1;
  );
  0;
}


/* ********************************************************************************************* /
  RENDER
/ ********************************************************************************************* */

cbV3DbufferPreRender(buffer, viewstr){
exec viewstr.V3D_cbPreRender with [viewstr];
  
  if viewstr.V3D_bPaused then nil else
    exec viewstr.V3D_cbPreRenderEffects with [viewstr];
  
  let [viewstr.V3D_iMoveX-(viewstr.V3D_iWinW>>1) (viewstr.V3D_iWinH>>1)-viewstr.V3D_iMoveY] -> [x y] in  
  let sizelist viewstr.V3D_lSessions -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
    (
      let sessionstr.V3D_selectedAxis -> [axisstr _] in
      // Camera rotation on mouse drag
      if (viewstr.V3D_iMoveClickStatus != 1) || (!sessionstr.V3D_bNavigate) || ((axisstr != nil) && axisstr.V3D_iAxisMode) then nil else
        let [(viewstr.V3D_iMoveX-viewstr.V3D_iClickX) (viewstr.V3D_iClickY-viewstr.V3D_iMoveY)] -> [dx dy] in
        let 1.0 /. (((itof viewstr.V3D_iWinW * 2) /. ((itof dx) +. 0.000001)) +. 0.000001) -> fdx in
        let 1.0 /. (((itof viewstr.V3D_iWinH * 2) /. ((itof dy) +. 0.000001)) +. 0.000001) -> fdy in
        (
          SO3ObjectRotateYaw sessionstr.V3D_session sessionstr.V3D_shellNavigate (-. fdx) SO3_WORLD_TS;
          SO3ObjectRotatePitch sessionstr.V3D_session sessionstr.V3D_shellNavigate (-. fdy) SO3_LOCAL_TS;
        );
      
      if (viewstr.V3D_iMoveClickStatus != 16) || (!sessionstr.V3D_bNavigate) then nil else
      (
        let if viewstr.V3D_iRenderMoveX == nil then viewstr.V3D_iClickX else viewstr.V3D_iRenderMoveX -> mvx in
        let if viewstr.V3D_iRenderMoveY == nil then viewstr.V3D_iClickY else viewstr.V3D_iRenderMoveY -> mvy in
        let [(viewstr.V3D_iMoveX-mvx) (mvy-viewstr.V3D_iMoveY)] -> [dx dy] in
          V3DcameraPan sessionstr V3DgetDefaultViewport viewstr dx dy;
      );
      
      let if viewstr.V3D_iRenderTick == 0 then _tickcount else viewstr.V3D_iRenderTick -> lasttick in
      (
        let sizelist viewstr.V3D_lViewport -> vsize in
        let 0 -> v in
        while v < vsize do
        (
          let nth_list viewstr.V3D_lViewport v -> [_ viewportstr] in
            if !(SO3DebugGetEnable viewportstr.V3D_viewport) then nil else
            let _tickcount -> curtick in
            let (curtick - viewstr.V3D_iRenderTick) -> frametime in
            let if frametime <= 0 then 1 else frametime -> frametime in
              SO3DebugSetText viewportstr.V3D_viewport strcatn "FPS : "::(itoa (1000 / frametime))::"\n"::"Frametime : "::(itoa frametime)::"\n"::"Polygon count : "::(itoa SO3BufferGetTriangleCount viewstr.V3D_buffer)::"\n"::nil;
          
          set v = v + 1;
        );
        set viewstr.V3D_iRenderTick = _tickcount;
      );
      
      V3DupdateAxisTarget viewstr sessionstr;
      V3DupdateHelpersTarget viewstr sessionstr;
    );
    set i = i + 1;
  );
  
  set viewstr.V3D_iRenderMoveX = viewstr.V3D_iMoveX;
  set viewstr.V3D_iRenderMoveY = viewstr.V3D_iMoveY;  
  0;
}
  

cbV3DbufferPostRender(buffer, viewstr){
exec viewstr.V3D_cbPostRender with [viewstr];
  0;
}


cbV3Drender(viewstr){
0;
}


cbV3DtickRender(tmr, viewstr){
cbV3Drender viewstr;
  0;
}


V3DdeleteSession(viewstr, sessionstr){
if sessionstr == nil then nil else
  (
    V3DphysDestroy sessionstr;
    SO3SceneDelete sessionstr.V3D_session;
    
    let V3DgetSessionIndex viewstr sessionstr -> idx in
      set viewstr.V3D_lSessions = V3DremoveIdxFromList viewstr.V3D_lSessions idx;
  );
  0;
}


V3DcrSession(viewstr, name){
let
    let 0 -> i in
    (
      while ((switch viewstr.V3D_lSessions i) != nil) do
      (
        set i = i + 1;
      );
      i;
    )
  -> idx in
  
  let mkV3Dsession [viewstr nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] -> sessionstr in
  (
    set viewstr.V3D_lSessions = V3Dlcat viewstr.V3D_lSessions [idx sessionstr]::nil;
    
    // create the new scene
    
    set sessionstr.V3D_session = SO3SceneCreate viewstr.V3D_channel strcatn (itoa iV3DSessionIndex)::"."::name::nil;
    set iV3DSessionIndex = iV3DSessionIndex + 1;
    
    set sessionstr.V3D_bHelpersState = 0;
    
    // create the default camera
    V3DaddCamera sessionstr "default_camera";
    
    // create a shell
    set sessionstr.V3D_shellNavigate = SO3SceneNodeCreate sessionstr.V3D_session "camshell";
    
    // set the shell position
    SO3ObjectSetPosition sessionstr.V3D_session sessionstr.V3D_shellNavigate [0.0 0.0 0.0];
    
    // set the shell orientation
    SO3ObjectRotatePitch sessionstr.V3D_session sessionstr.V3D_shellNavigate (-.0.5) SO3_LOCAL_TS;
    
    // link the camera to the shell
    SO3ObjectLink sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) sessionstr.V3D_shellNavigate;
    
    // define that the camera always look at this point
    //SO3ObjectLookAt sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) [0.0 0.0 0.0] 2;  
    
    SO3ObjectSetPosition sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) [0.0 0.0 (5.0 *. itof(iGlobalUnit))];
    
    // set the ambient light color
    V3DsetAmbientLight sessionstr 0x000000;
    
    set sessionstr.V3D_bNavigate = 0;
    
    // helpers resources
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helpers.material") "V3DdefaultResources" SO3_RESOURCE_MATERIAL;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_camera.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_dummy.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_light.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/default_grid_helper.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/h_line_b.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/h_line_w.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/v_line_b.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/v_line_w.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
    
    V3DphysCreate sessionstr;
    
    sessionstr;
  );
}


V3DresetSession(sessionstr){
SO3SceneClear sessionstr.V3D_session;  
  SO3GroupDelete "V3DdefaultResources";
  
  set sessionstr.V3D_lCamera = nil;
  set sessionstr.V3D_lAxis = nil;
  set sessionstr.V3D_lHelper = nil;
  set sessionstr.V3D_shellNavigate = nil;
  set sessionstr.V3D_lAnimations = nil;
  set sessionstr.V3D_prevDefaultCamera = nil;
  set sessionstr.V3D_defaultCamera = nil;
  
  V3DphysReset sessionstr;
  
  SO3GroupCreate "V3DdefaultResources";
  
  V3DsetCamera sessionstr (V3DaddCamera sessionstr "default_camera") nil nil 0.01 nil;
  
  // create a shell
  set sessionstr.V3D_shellNavigate = SO3SceneNodeCreate sessionstr.V3D_session "camshell";
  
  // set the shell position
  SO3ObjectSetPosition sessionstr.V3D_session sessionstr.V3D_shellNavigate [0.0 0.0 0.0];
  
  // set the shell orientation
  SO3ObjectRotatePitch sessionstr.V3D_session sessionstr.V3D_shellNavigate (-.0.5) SO3_LOCAL_TS;
  
  // link the camera to the shell
  SO3ObjectLink sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) sessionstr.V3D_shellNavigate;
  
  SO3ObjectSetPosition sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) [0.0 0.0 (5.0 *. itof(iGlobalUnit))];
  
  V3DchangeCameraViewport sessionstr nil (V3DgetDefaultCamera sessionstr);
  
  // helpers resources
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helpers.material") "V3DdefaultResources" SO3_RESOURCE_MATERIAL;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/ang_axis_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_x.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_y.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/coords_axis_text_z.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;  
  
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_camera.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_dummy.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/helper_light.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/default_grid_helper.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/h_line_b.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/h_line_w.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/v_line_b.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  SO3SceneLoadResource sessionstr.V3D_session (strcat sV3DDEFAULTRESOURCESPATH "helpers/v_line_w.mesh") "V3DdefaultResources" SO3_RESOURCE_MESH;
  
  if sessionstr.V3D_helperGrid == nil then nil else
  (
    set sessionstr.V3D_helperGrid = nil;
    V3DshowSceneGrid sessionstr 1;
  );
  0;
}


cbV3DkillFocus(win, viewstr){
if !viewstr.V3D_iClickStatus then nil else
  (
    if viewstr.V3D_iClickX == nil || viewstr.V3D_iClickY == nil then nil else
      exec viewstr.V3D_cbUnClick with [viewstr viewstr.V3D_iClickX viewstr.V3D_iClickY viewstr.V3D_iClickStatus];    
    set viewstr.V3D_iClickStatus = V3DCLICK_NO;
  );
  
  if !viewstr.V3D_iMoveClickStatus then nil else
  (
    if viewstr.V3D_iMoveX == nil || viewstr.V3D_iMoveY == nil then nil else
      exec viewstr.V3D_cbUnClick with [viewstr viewstr.V3D_iMoveX viewstr.V3D_iMoveY viewstr.V3D_iMoveClickStatus];    
    set viewstr.V3D_iMoveClickStatus = V3DCLICK_NO;
  );
  0;
}


V3DflashCtrlHasFocus(viewstr){
let sizelist viewstr.V3D_lViewport -> sizev in
  let 0 -> iv in
  let nil -> ret in
  (
    while (iv < sizev && ret == nil) do
    (
      let nth_list viewstr.V3D_lViewport iv -> [_ viewportstr] in
      let sizelist viewportstr.V3D_lFlashControl -> size in
      let 0 -> i in
      while (i < size && ret == nil) do
      (
        let nth_list viewportstr.V3D_lFlashControl i -> flashctrl in
        if ((SO3FlashControlHasFocus flashctrl) && (SO3FlashControlGetKeyboardState flashctrl)) then
          set ret = flashctrl
        else nil;
        
        set i = i + 1;
      );
        
      set iv = iv + 1;
    );
    ret;
  );
}


V3DviewSetFocus(viewstr){
SO3BufferSetFocus viewstr.V3D_buffer;
  0;
}


V3DgetInfosFromCoords(sessionstr, posx, posy){
let nil -> infos in
  let V3DgetSessionView sessionstr -> viewstr in
  (
    let sizelist viewstr.V3D_lViewport -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list viewstr.V3D_lViewport i -> [_ viewportstr] in
      let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [x y w h] in
      let if (posx > x) && (posy > y) && (posx < (x + w)) && (posy < (y + h)) then
            SO3ObjectGetInfo sessionstr.V3D_session (SO3ViewportGetCamera viewportstr.V3D_viewport sessionstr.V3D_session) ((itof (posx - x)) /. (itof w)) ((itof (posy - y)) /. (itof h))
          else nil
      -> objinfos in
      if objinfos == nil then nil else
        set infos = objinfos;
      
      set i = i + 1;
    );
    infos;
  );
}


V3DgetExInfosFromCoords(sessionstr, posx, posy){
let nil -> infos in
  let V3DgetSessionView sessionstr -> viewstr in
  (
    let sizelist viewstr.V3D_lViewport -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list viewstr.V3D_lViewport i -> [_ viewportstr] in
      let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [x y w h] in
      let if (posx > x) && (posy > y) && (posx < (x + w)) && (posy < (y + h)) then
            SO3ObjectGetInfoEx sessionstr.V3D_session (SO3ViewportGetCamera viewportstr.V3D_viewport sessionstr.V3D_session) ((itof (posx - x)) /. (itof w)) ((itof (posy - y)) /. (itof h))
          else nil
      -> objinfos in
      if objinfos == nil then nil else
        set infos = objinfos;
      
      set i = i + 1;
    );
    // obj mat F I [F F F] [F F F] [F F F] [F F] [F F] [F F] [F F F] [F F]
    infos;
  );
}


// ret [mode spacing fov]
V3DviewGetStereo(viewstr){
SO3BufferGetStereoVisionProperties viewstr.V3D_buffer;
}


V3DviewGetStereoMode(viewstr){
let SO3BufferGetStereoVisionProperties viewstr.V3D_buffer -> [mode spacing fov] in mode;
}


V3DviewSetStereo(viewstr, mode, spacing, fov){
SO3BufferSetStereoVision viewstr.V3D_buffer mode spacing fov;
  0;
}


V3DchangeSelectedAxis(sessionstr, objname, mode){
let SO3SceneGetObject (V3DgetSession sessionstr) objname -> refobj in
  let (switch sessionstr.V3D_lAxis refobj) -> axisstr in
    set sessionstr.V3D_selectedAxis = [axisstr mode];
  0;
}


cbV3DviewDropFile(buffer, viewstr, x, y, lp){
exec viewstr.V3D_cbDropFile with [viewstr x y lp];
  0;
}  


cbV3DviewKeyDown(buffer, viewstr, key, ascode){
if (V3DflashCtrlHasFocus viewstr) != nil then nil else
  (
    if key == 328 then // UP
    (
      let sizelist viewstr.V3D_lSessions -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
        if !sessionstr.V3D_bNavigate then nil else
        (
          SO3ObjectRotatePitch sessionstr.V3D_session sessionstr.V3D_shellNavigate (-.0.1) SO3_LOCAL_TS;
        );
        set i = i + 1;
      );
    )
    else nil;
    if key == 336 then // DOWN
    (
      let sizelist viewstr.V3D_lSessions -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
        if !sessionstr.V3D_bNavigate then nil else
        (
          SO3ObjectRotatePitch sessionstr.V3D_session sessionstr.V3D_shellNavigate (0.1) SO3_LOCAL_TS;
        );
        set i = i + 1;
      );
    )
    else nil;
    if key == 331 then // LEFT
    (
      let sizelist viewstr.V3D_lSessions -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
        if !sessionstr.V3D_bNavigate then nil else
        (
          SO3ObjectRotateYaw sessionstr.V3D_session sessionstr.V3D_shellNavigate (-.0.1) SO3_WORLD_TS;
        );
        set i = i + 1;
      );
    )
    else nil;
    if key == 333 then // RIGHT
    (
      let sizelist viewstr.V3D_lSessions -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
        if !sessionstr.V3D_bNavigate then nil else
        (
          SO3ObjectRotateYaw sessionstr.V3D_session sessionstr.V3D_shellNavigate (0.1) SO3_WORLD_TS;
        );
        set i = i + 1;
      );
    )
    else nil;
    
    exec viewstr.V3D_cbKeyDown with [viewstr key ascode];
  );
  0;
}


cbV3DviewKeyUp(buffer, viewstr, key){
if (V3DflashCtrlHasFocus viewstr) != nil then nil else
  (
    exec viewstr.V3D_cbKeyUp with [viewstr key];
  );
  0;
}


cbV3DviewDbClick(buffer, viewstr, posx, posy, btn){
let (V3DflashCtrlHasFocus viewstr) -> flashctrl in
  if (flashctrl != nil) && (SO3FlashControlIsMouseOver flashctrl) then nil else
  (
    exec viewstr.V3D_cbDbClick with [viewstr posx posy btn];
  );
  0;
}


cbV3DviewClick(buffer, viewstr, posx, posy, btn, key){
let (V3DflashCtrlHasFocus viewstr) -> flashctrl in
  if (flashctrl != nil) && (SO3FlashControlIsMouseOver flashctrl) then nil else
  (
    SO3BufferSetFocus viewstr.V3D_buffer;
    set viewstr.V3D_iClickX = posx;
    set viewstr.V3D_iClickY = posy;
    set viewstr.V3D_iClickStatus = if btn == nil then V3DCLICK_NO else btn;
    
    let sizelist viewstr.V3D_lSessions -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
      if sessionstr.V3D_selectedAxis != nil then nil else
      let SO3SceneGetLastInfos (V3DgetSession sessionstr) -> infos in
      let infos -> [obj mat subid _ _ _ _ _ _ _ _ _ _] in
      let sizelist sessionstr.V3D_lAxis -> size2 in
      let 0 -> i2 in
      while (i2 < size2) && (sessionstr.V3D_selectedAxis == nil) do
      (
        let nth_list sessionstr.V3D_lAxis i2 -> [_ axisstr] in
        if obj == axisstr.V3D_xAxisObject then
        (
          set sessionstr.V3D_selectedAxis = [axisstr V3DAXIS_X];
          exec sessionstr.V3D_cbAxisClick with [sessionstr axisstr.V3D_axisFather V3DAXIS_X posx posy btn];
        )
        else if obj == axisstr.V3D_yAxisObject then
        (
          set sessionstr.V3D_selectedAxis = [axisstr V3DAXIS_Y];
          exec sessionstr.V3D_cbAxisClick with [sessionstr axisstr.V3D_axisFather V3DAXIS_Y posx posy btn]
        )
        else if obj == axisstr.V3D_zAxisObject then
        (
          set sessionstr.V3D_selectedAxis = [axisstr V3DAXIS_Z];
          exec sessionstr.V3D_cbAxisClick with [sessionstr axisstr.V3D_axisFather V3DAXIS_Z posx posy btn]
        )
        else nil;
        
        set i2 = i2 + 1;
      );
      
      set i = i + 1;
    );
    
    exec viewstr.V3D_cbClick with [viewstr posx posy btn];
  );
  0;
}


V3DgetCursorTrans(viewstr){
if viewstr.V3D_iMoveClickStatus & (V3DCLICK_LEFT|V3DCLICK_RIGHT|V3DCLICK_MIDDLE) then
    [(viewstr.V3D_iMoveX-viewstr.V3D_iClickX) (viewstr.V3D_iClickY-viewstr.V3D_iMoveY)]
  else
    nil;
}


V3DisClicked(viewstr){
viewstr.V3D_iClickStatus;
}


V3DisMoveClicked(viewstr){
viewstr.V3D_iMoveClickStatus;
}


cbV3DviewUnclick(buffer, viewstr, posx, posy, btn, key){
if (V3DflashCtrlHasFocus viewstr) != nil then nil else
  (
    if viewstr.V3D_iClickStatus == V3DCLICK_NO && viewstr.V3D_iMoveClickStatus == V3DCLICK_NO then nil else
    (
      set viewstr.V3D_iClickStatus = V3DCLICK_NO;
      set viewstr.V3D_iMoveClickStatus = V3DCLICK_NO;
      set viewstr.V3D_iRenderMoveX = nil;
      set viewstr.V3D_iRenderMoveY = nil;
      
      let sizelist viewstr.V3D_lSessions -> size in
      let 0 -> i in
      while i < size do
      (
        let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
        if sessionstr.V3D_selectedAxis == nil then nil else
        let sessionstr.V3D_selectedAxis -> [axisstr axisflag] in
        (
          exec sessionstr.V3D_cbAxisUnClick with [sessionstr axisstr.V3D_axisFather axisflag posx posy btn];
          set sessionstr.V3D_selectedAxis = nil;
        );
        
        set i = i + 1;
      );
      
      exec viewstr.V3D_cbUnClick with [viewstr posx posy btn];
    );
  );
  0;
}


cbV3DviewWheel(buffer, viewstr, posx, posy, delta, btn){
if (V3DflashCtrlHasFocus viewstr) != nil then nil else
  (
    let sizelist viewstr.V3D_lSessions -> size in
    let 0 -> i in
    while i < size do
    (
      let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
      if !sessionstr.V3D_bNavigate then nil else
      let if iGlobalUnit > 1 then ((itof iGlobalUnit) /. 10.0) else (itof iGlobalUnit) -> unitdiv in
      (
        let SO3ObjectGetPosition sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) -> [_ _ z] in   
        let ((itof -delta) *. (((absf z) +. 10.0) /. (100.0 /. unitdiv)) ) -> zm in
        if zm <. 0.0 && z <=. 0.0 then nil else
          SO3ObjectSetPosition sessionstr.V3D_session (V3DgetDefaultCamera sessionstr) [0.0 0.0 z +. zm];
        0;
      );
      set i = i + 1;
    );
    
    exec viewstr.V3D_cbWheel with [viewstr posx posy delta btn];
  );
  0;
}


V3DgetMoveAxis(viewstr, posx, posy, btn){
let sizelist viewstr.V3D_lSessions -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
    if sessionstr.V3D_lAxis == nil then nil else
    (
      let SO3SceneGetLastInfos (V3DgetSession sessionstr) -> infos in
      let infos -> [obj _ _ _ _ _ _ _ _ _ _ _ _] in
      
      if sessionstr.V3D_selectedAxis != nil then
      let sessionstr.V3D_selectedAxis -> [selectedaxisstr axisflag] in
      let (V3DgetDefaultViewport viewstr) -> viewportstr in
      let SO3ViewportGetCamera viewportstr.V3D_viewport (V3DgetSession sessionstr) -> camera in
      let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) camera -> [cx cy cz] in  
      let SO3ObjectGetGlobalPosition (V3DgetSession sessionstr) selectedaxisstr.V3D_axisFather -> [ox oy oz] in
      
      let SO3CameraGetFOVy sessionstr.V3D_session camera -> fovy in
      let if fovy <=. 0.0 then 0.000001 else fovy -> fovy in
      
      let if axisflag == V3DAXIS_X then
            [selectedaxisstr.V3D_xAxisObject selectedaxisstr.V3D_xAxisTextObject]
          else if axisflag == V3DAXIS_Y then
            [selectedaxisstr.V3D_yAxisObject selectedaxisstr.V3D_yAxisTextObject]
          else if axisflag == V3DAXIS_Z then
            [selectedaxisstr.V3D_zAxisObject selectedaxisstr.V3D_zAxisTextObject]
          else nil
      -> [axisobj letterobj] in
      
      let SO3ObjectGetScreenPixelCoord (V3DgetSession sessionstr) viewportstr.V3D_viewport axisobj -> [shpx shpy] in
      let SO3ObjectGetScreenPixelCoord (V3DgetSession sessionstr) viewportstr.V3D_viewport letterobj -> [lhpx lhpy] in
      let [(itof (lhpx-shpx)) (itof (lhpy-shpy))] -> [u v] in
      
      let [(posx - viewstr.V3D_iMoveX) (posy - viewstr.V3D_iMoveY)] -> [mvx mvy] in
      let sqrt ((sqr(cx -. ox)) +. (sqr(cy -. oy)) +. (sqr(cz -. oz))) -> dist in
      let SO3ViewportGetPixelPositionSize viewportstr.V3D_viewport -> [_ _ vw vh] in
      
      // TODO find the real algo ! use global scale ?
      let maxf 0.000001 ((dist /. (itof vh)) *. fovy) *. 98.5 -> scale in
      let SO3ObjectGetParent (V3DgetSession sessionstr) selectedaxisstr.V3D_axisFather -> ofather in
      let if ofather == (SO3ObjectGetSceneRoot (V3DgetSession sessionstr)) then [1.0 1.0 1.0] else SO3ObjectGetGlobalScale (V3DgetSession sessionstr) ofather -> [gsx gsy gsz] in
      //let SO3ObjectGetGlobalScale (V3DgetSession sessionstr) selectedaxisstr.V3D_axisFather -> [gsx gsy gsz] in
      let if axisflag == V3DAXIS_X then gsx else if axisflag == V3DAXIS_Y then gsy else if axisflag == V3DAXIS_Z then gsz else 1.0 -> gscale in
      let ((scale *. (u *. (itof mvx) +. v *. (itof mvy))) /. sqr(0.001+.sqrt((sqr u)+.(sqr v)))) /. gscale -> coef in
      (
        if u == nil || v == nil then nil else
        (
          exec sessionstr.V3D_cbAxisMove with [sessionstr selectedaxisstr.V3D_axisFather axisflag mvx mvy btn coef];
        );
        0;
      )
      else
      (
        let sizelist sessionstr.V3D_lAxis -> size2 in
        let 0 -> i2 in
        while i2 < size2 do
        (
          let nth_list sessionstr.V3D_lAxis i2 -> [_ axisstr] in
          if axisstr.V3D_iAxisMode then
          (
            if obj == axisstr.V3D_xAxisObject then
            (
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_xAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_yAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_zAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);            
              );
              0;
            )
            else if obj == axisstr.V3D_yAxisObject then
            (
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_xAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_yAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_zAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);            
              );
              0;
            )
            else if obj == axisstr.V3D_zAxisObject then
            (
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_xAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_yAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_zAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 255 0 0);       
              );
              0;
            )
            else
            (
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_xAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 255 0 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_yAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 255 0 0);
              );
              let hd (SO3EntityMaterialList (V3DgetSession sessionstr) axisstr.V3D_zAxisObject) -> mat in
              (
                SO3MaterialSetSelfIllumination (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetAmbient (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);
                SO3MaterialSetDiffuse (V3DgetSession sessionstr) mat (make_rgba 0 0 255 0);            
              );
              0;
            );
          )
          else nil;
          
          set i2 = i2 + 1;
        );
        0;
      );
    );
    
    set i = i + 1;
  );
  0;
}


cbV3DcursorMove(win, viewstr, posx, posy, btn){
let (V3DflashCtrlHasFocus viewstr) -> flashctrl in
  if (flashctrl != nil) && (SO3FlashControlIsMouseOver flashctrl) then nil else
  (
    let if viewstr.V3D_iClickStatus == V3DCLICK_NO then nil else btn -> btn in
    (
      set viewstr.V3D_iMoveClickStatus = if btn == nil then V3DCLICK_NO else btn;
      V3DgetMoveAxis viewstr posx posy btn;
      
      set viewstr.V3D_iMoveX = posx;
      set viewstr.V3D_iMoveY = posy;
      
      exec viewstr.V3D_cbCursorMove with [viewstr posx posy btn];
    );
   );
  0;
}


V3DsetCbResizeView(viewstr, cbfun){
set viewstr.V3D_cbResizeView = cbfun;
  0;
}


V3DsetCbPreRenderEffects(viewstr, cbfun){
set viewstr.V3D_cbPreRenderEffects = cbfun;
  0;
}


V3DsetCbPreRender(viewstr, cbfun){
set viewstr.V3D_cbPreRender = cbfun;
  0;
}


V3DsetCbPostRender(viewstr, cbfun){
set viewstr.V3D_cbPostRender = cbfun;
  0;
}


V3DsetCbKeyDown(viewstr, cbfun){
set viewstr.V3D_cbKeyDown = cbfun;
  0;
}


V3DsetCbKeyUp(viewstr, cbfun){
set viewstr.V3D_cbKeyUp = cbfun;
  0;
}


V3DsetCbClick(viewstr, cbfun){
set viewstr.V3D_cbClick = cbfun;
  0;
}


V3DsetCbDropFile(viewstr, cbfun){
set viewstr.V3D_cbDropFile = cbfun;
  0;
}


V3DgetCbClick(viewstr){
viewstr.V3D_cbClick;
}


V3DsetCbDbClick(viewstr, cbfun){
set viewstr.V3D_cbDbClick = cbfun;
  0;
}


V3DgetCbDbClick(viewstr){
viewstr.V3D_cbDbClick;
}


V3DsetCbUnClick(viewstr, cbfun){
set viewstr.V3D_cbUnClick = cbfun;
  0;
}


V3DgetCbUnClick(viewstr){
viewstr.V3D_cbUnClick;
}


V3DsetCbWheel(viewstr, cbfun){
set viewstr.V3D_cbWheel = cbfun;
  0;
}


V3DgetCbWheel(viewstr){
viewstr.V3D_cbWheel;
}


V3DsetCbCursorMove(viewstr, cbfun){
set viewstr.V3D_cbCursorMove = cbfun;
  0;
}


V3DgetCbCursorMove(viewstr){
viewstr.V3D_cbCursorMove;
}


V3DsetCbAxisMove(sessionstr, cbfun){
set sessionstr.V3D_cbAxisMove = cbfun;
  0;
}


V3DsetCbAxisClick(sessionstr, cbfun){
set sessionstr.V3D_cbAxisClick = cbfun;
  0;
}


V3DsetCbAxisUnClick(sessionstr, cbfun){
set sessionstr.V3D_cbAxisUnClick = cbfun;
  0;
}


V3DenableKeyboard(viewstr, mode){
set viewstr.V3D_bKeyboardEnabled = mode;
   
  if !mode then
  (
    SO3CbBufferKeyDown viewstr.V3D_buffer nil nil ;
    SO3CbBufferKeyUp viewstr.V3D_buffer nil nil ;
    //_CBwinKeydown viewstr.V3D_win nil nil;
    //_CBwinKeyup viewstr.V3D_win nil nil;
  )
  else
  (
    SO3CbBufferKeyDown viewstr.V3D_buffer @cbV3DviewKeyDown viewstr;
    SO3CbBufferKeyUp viewstr.V3D_buffer @cbV3DviewKeyUp viewstr;
    //_CBwinKeydown viewstr.V3D_win @cbV3DviewKeyDown viewstr;
    //_CBwinKeyup viewstr.V3D_win @cbV3DviewKeyUp viewstr;
  );
  0;
}


V3DenableMouse(viewstr, mode){
set viewstr.V3D_bMouseEnabled = mode;
  if !mode then
  (
    SO3CbBufferClick viewstr.V3D_buffer nil nil ;
    SO3CbBufferUnclick viewstr.V3D_buffer nil nil ;
    SO3CbBufferWheel viewstr.V3D_buffer nil nil ;
    SO3CbBufferMouseMove viewstr.V3D_buffer nil nil ;
    SO3CbBufferDClick viewstr.V3D_buffer nil nil ;
    SO3CbBufferDrop viewstr.V3D_buffer nil nil;
  )
  else
  (
    SO3CbBufferClick viewstr.V3D_buffer @cbV3DviewClick viewstr;
    SO3CbBufferUnclick viewstr.V3D_buffer @cbV3DviewUnclick viewstr;
    SO3CbBufferWheel viewstr.V3D_buffer @cbV3DviewWheel viewstr;
    SO3CbBufferMouseMove viewstr.V3D_buffer @cbV3DcursorMove viewstr;
    SO3CbBufferDClick viewstr.V3D_buffer @cbV3DviewDbClick viewstr;
    SO3CbBufferDrop viewstr.V3D_buffer @cbV3DviewDropFile viewstr;
  );
  0;
}


V3DenableNavigate(sessionstr, mode){
set sessionstr.V3D_bNavigate = mode;
  0;
}


V3DsetCursor(viewstr, cursor){
if (V3DflashCtrlHasFocus viewstr) != nil then nil else
  _SETwinCursor viewstr.V3D_win cursor;
  0;
}


cbV3DbufferSize(buffer, viewstr, w, h){
exec viewstr.V3D_cbResizeView with [viewstr w h];
  0;
}


cbV3Dsize(win, viewstr, w, h){
if w == 0 || h == 0 then nil else
  (
    set viewstr.V3D_iWinW = w;
    set viewstr.V3D_iWinH = h;
    
    SO3BufferSetPositionSize viewstr.V3D_buffer 0 0 w h;
  );
  0;
}


V3DresizeView(viewstr, x, y, w, h){
set viewstr.V3D_iWinX = x;
  set viewstr.V3D_iWinY = y;
  set viewstr.V3D_iWinW = w;
  set viewstr.V3D_iWinH = h;
  
  _SIZEwindow viewstr.V3D_win viewstr.V3D_iWinW viewstr.V3D_iWinH viewstr.V3D_iWinX viewstr.V3D_iWinY;
  0;
}


V3DgetViewPosSize(viewstr){
[viewstr.V3D_iWinX viewstr.V3D_iWinY viewstr.V3D_iWinW viewstr.V3D_iWinH];
}


V3DgetViewPos(viewstr){
[viewstr.V3D_iWinX viewstr.V3D_iWinY];
}


V3DgetViewSize(viewstr){
[viewstr.V3D_iWinW viewstr.V3D_iWinH];
}


V3DgetFullScreenState(viewstr){
viewstr.V3D_bFullScreen;
}


V3DsetScreenInfos(viewstr, x, y, width, height, fsize, fcolor){
let fcolor & 255 -> r in
  let (fcolor>>8) &  255 -> g in
  let (fcolor>>16) & 255 -> b in  
  let make_rgba r g b 0 -> crgba in
    
  let V3DgetDefaultSession viewstr -> sessionstr in
  let V3DgetDefaultViewport viewstr -> viewportstr in
    SO3DebugDisplayProperties sessionstr.V3D_session viewportstr.V3D_viewport nil crgba [x y] [width height] fsize;
  0;
}


V3DenableScreenInfos(viewstr, state){
let V3DgetDefaultSession viewstr -> sessionstr in
  let V3DgetDefaultViewport viewstr -> viewportstr in
  (
    SO3DebugSetEnable viewportstr.V3D_viewport state;
    SO3WorldShowLines sessionstr.V3D_session state;
   );
  0;
}


V3DsetWindowedMode(viewstr){
if !viewstr.V3D_bFullScreen then nil else
  (
    set viewstr.V3D_iWinW = viewstr.V3D_iOldWinW;
    set viewstr.V3D_iWinH = viewstr.V3D_iOldWinH;  
    
    //_SHOWwindow viewstr.V3D_win WINDOW_UNHIDDEN;

    SO3BufferSetProperties viewstr.V3D_buffer 0 viewstr.V3D_iWinW viewstr.V3D_iWinH;

    V3DviewSetFocus viewstr;
    
    set viewstr.V3D_bFullScreen = 0;
  );
  0;
}


V3DEnableRender(viewstr, state){
set viewstr.V3D_bState = state;
  0;
}


V3DenableView(viewstr, mode){
if mode then
  (
    _SHOWwindow viewstr.V3D_win WINDOW_UNHIDDEN;
    V3DEnableRender viewstr 1;
  )
  else if !mode then
  (
    _SHOWwindow viewstr.V3D_win WINDOW_HIDDEN;
    V3DEnableRender viewstr 0;
  )
  else nil;
  0;
}


V3DsetFullScreenMode(viewstr, w, h){
if viewstr.V3D_bFullScreen then nil else
  (   
    //_SHOWwindow viewstr.V3D_win WINDOW_HIDDEN;
    
    set viewstr.V3D_iOldWinW = viewstr.V3D_iWinW;
    set viewstr.V3D_iOldWinH = viewstr.V3D_iWinH;  
    
    set viewstr.V3D_iWinW = w;
    set viewstr.V3D_iWinH = h;  
        
    SO3BufferSetProperties viewstr.V3D_buffer 1 viewstr.V3D_iWinW viewstr.V3D_iWinH;
     
    set viewstr.V3D_bFullScreen = 1;
  );
  0;
}


V3DswitchFullScreenMode(viewstr, w, h){
if viewstr.V3D_bFullScreen then
    V3DsetWindowedMode viewstr
  else
    V3DsetFullScreenMode viewstr w h;
  0;
}


V3DdsFlashControl(viewportstr, flashctrl){
set viewportstr.V3D_lFlashControl = remove_from_list viewportstr.V3D_lFlashControl flashctrl;
  SO3FlashControlDestroy flashctrl;
  0;
}


V3DcbFlashControlMouseIn(flashctrl, viewstr){
0;
}


V3DcbFlashControlMouseOut(flashctrl, viewstr){
0;
}


V3DcrFlashControl(viewstr, viewportstr, file, x, y, w, h, zorder, name, type, flag){
let SO3FlashControlCreate viewstr.V3D_channel viewportstr.V3D_viewport x y w h zorder name flag -> flashctrl in
  (
    if type == 0 then SO3FlashControlLoadFile flashctrl _checkpack file else SO3FlashControlLoadUrl flashctrl file;
    set viewportstr.V3D_lFlashControl = flashctrl::viewportstr.V3D_lFlashControl;
    SO3CbInsideEventFlashControl flashctrl @V3DcbFlashControlMouseIn viewstr;
    SO3CbOutsideEventFlashControl flashctrl @V3DcbFlashControlMouseOut viewstr;
    flashctrl;
  );
}


V3DcrFlashControlOnMaterial(viewstr, mat, tec, pass, index, file, w, h, name, type){
let V3DgetDefaultSession viewstr -> sessionstr in
  let SO3MaterialSetFlash viewstr.V3D_channel sessionstr.V3D_session mat tec pass index w h name -> flashctrl in
  (
    if type == 0 then SO3FlashControlLoadFile flashctrl _checkpack file else SO3FlashControlLoadUrl flashctrl file;
    //set viewportstr.V3D_lFlashControl = flashctrl::viewportstr.V3D_lFlashControl;
    flashctrl;
  );
}


V3DcrView(chan, fatherwin, ix, iy, iw, ih, cbinit, cbdestroy, defview){
// init the ogre resources location to scol partitions
  SO3InitSCOLResourceLocations;
  
  let mkV3Dview [nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil 0 1] -> viewstr in
  let _CRwindow chan fatherwin ix iy iw ih WN_CHILDINSIDE|WN_NOCAPTION|WN_NOBORDER strcatn (itoa iV3DIndex)::".v3dwin"::nil -> win in
  (
    SO3GroupCreate "V3DdefaultResources";
    
    set viewstr.V3D_channel = chan;
    
    // set the buffer window
    set viewstr.V3D_buffer = SO3BufferCreate chan win 0 0 iw ih;
    SO3CbBufferSize viewstr.V3D_buffer @cbV3DbufferSize viewstr;
    SO3CbBufferPreRender viewstr.V3D_buffer @cbV3DbufferPreRender viewstr;
    SO3CbBufferPostRender viewstr.V3D_buffer @cbV3DbufferPostRender viewstr;
    
    _SHOWwindow win WINDOW_HIDDEN;
    _CBwinKillFocus win @cbV3DkillFocus viewstr;
    _CBwinSize win @cbV3Dsize viewstr;
    
    set viewstr.V3D_win = win;
    set viewstr.V3D_iWinW = iw;
    set viewstr.V3D_iWinH = ih;
    set viewstr.V3D_iWinX = ix;
    set viewstr.V3D_iWinY = iy;
    
    set viewstr.V3D_iMoveClickStatus = V3DCLICK_NO;
    set viewstr.V3D_iClickStatus = V3DCLICK_NO;
    set viewstr.V3D_bMouseEnabled = 0;
    set viewstr.V3D_bKeyboardEnabled = 0;
    set viewstr.V3D_bPaused = 0;
    set viewstr.V3D_iRenderTick = _tickcount;
    
    set viewstr.V3D_cbDestroy = cbdestroy;
    set viewstr.V3D_cbInit = cbinit;
    
    // default session
    if !defview then nil else
      V3DcrSession viewstr "main";
    
    
    set iV3DIndex = iV3DIndex + 1;
        
    exec viewstr.V3D_cbInit with [viewstr];
    
    viewstr;    
  );
}


V3DdsView(viewstr){
let sizelist viewstr.V3D_lViewport -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list viewstr.V3D_lViewport i -> [_ viewportstr] in
      V3DdelViewport viewstr viewportstr;
    
    set i = i + 1;
  );
  
  let sizelist viewstr.V3D_lSessions -> size in
  let 0 -> i in
  while i < size do
  (
    let nth_list viewstr.V3D_lSessions i -> [_ sessionstr] in
    (
      SO3SceneDelete sessionstr.V3D_session;
    );
    set i = i + 1;
  );
  
  SO3DestroyBuffer viewstr.V3D_buffer;
  
  if viewstr.V3D_win == nil then nil else
    _DSwindow viewstr.V3D_win;
  
  SO3GroupDelete "V3DdefaultResources";
  
  exec viewstr.V3D_cbDestroy with [viewstr];
  0;
}


cbV3DdsMainWin(win, viewstr){
V3DdsView viewstr;
  _closemachine;
  0;
}


cbV3DsizeMainWin(win, viewstr, w, h){
V3DresizeView viewstr viewstr.V3D_iWinX viewstr.V3D_iWinY w h;
  0;
}
// -- [/filterPKG] --

---