v3dlib_physics.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.
-----------------------------------------------------------------------------
*/

/**************************************************
 Ogre 3D Newton physics library
 Version: 1.0
 Author: Bastien BOURINEAU
 Last update: 16.12.2008

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

// arch     : SO3_PA_DEFAULT SO3_PA_MEDIUM SO3_PA_BEST
// solver   : SO3_SM_EXACT SO3_SM_ADAPTATIVE 
// friction : SO3_FM_EXACT SO3_FM_ADAPTATIVE 

struct V3Dphysics{

  V3DPHYS_vWold ([F F F]);
  V3DPHYS_iFps (I);
  V3DPHYS_fGravity (F);
  V3DPHYS_iArchMode (I);
  V3DPHYS_iSolverMode (I);
  V3DPHYS_iFrictionMode (I);
  
  V3DPHYS_iLastUpdate (I);
  V3DPHYS_bEnable (I

);
};
typedef struct mkV3Dphysics V3Dphysics;


proto V3DphysCreateBodyShape=fun [V3Dsession SO3_OBJECT] SO3_PHYSICBODY;
proto V3DphysCreateBodyEllipsoid=fun [V3Dsession SO3_OBJECT] SO3_PHYSICBODY;
proto V3DphysCreateBodyCustomEllipsoid=fun [V3Dsession SO3_OBJECT [F F F]] SO3_PHYSICBODY;
proto V3DphysCreateBodyBox=fun [V3Dsession SO3_OBJECT] SO3_PHYSICBODY;
proto V3DphysCreateBodyCustomBox=fun [V3Dsession SO3_OBJECT [F F F]] SO3_PHYSICBODY;
proto V3DphysCreateBodyCollisionTree=fun [V3Dsession SO3_OBJECT] SO3_PHYSICBODY;



V3DphysGetNodeBody(sessionstr, node){
SO3SceneNodeGetBody (V3DgetSession sessionstr) node;
}


V3DphysGetBodyNode(sessionstr, body){
SO3BodyGetSceneNode (V3DgetSession sessionstr) body;
}


V3DphysEnablePhysic(sessionstr, state){
if (sessionstr.V3D_physics.V3DPHYS_bEnable == 1 && state == 1) then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_bEnable = state;
    
    set sessionstr.V3D_physics.V3DPHYS_iLastUpdate = _tickcount;
    SO3WorldSetEnabled (V3DgetSession sessionstr) state;
  );
  0;
}


V3DphysGetState(sessionstr){
sessionstr.V3D_physics.V3DPHYS_bEnable;
}


V3DphysSetWorld(sessionstr, vec){
if vec == nil then nil else
  let vec -> [x y z] in
  (
    set sessionstr.V3D_physics.V3DPHYS_vWold = vec;
    SO3WorldSetSize (V3DgetSession sessionstr) [(-.x /. 2.0) (-.y /. 2.0) (-.z /. 2.0)] [(x /. 2.0) (y /. 2.0) (z /. 2.0)];
  ); 
  0;
}


V3DphysGetWorld(sessionstr){
sessionstr.V3D_physics.V3DPHYS_vWold;
}


V3DphysSetFps(sessionstr, fps){
if fps == nil then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_iFps = fps;
    SO3WorldSetFPS (V3DgetSession sessionstr) sessionstr.V3D_physics.V3DPHYS_iFps;
  );
  0;
}


V3DphysGetFps(sessionstr){
sessionstr.V3D_physics.V3DPHYS_iFps;
}


V3DphysSetGravity(sessionstr, g){
if g == nil then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_fGravity = g;
    SO3WorldSetGravity (V3DgetSession sessionstr) (-.(sessionstr.V3D_physics.V3DPHYS_fGravity *. (itof iGlobalUnit)));
  );
  0;
}


V3DphysGetGravity(sessionstr){
sessionstr.V3D_physics.V3DPHYS_fGravity;
}


V3DphysSetArchitectureMode(sessionstr, mode){
if mode == nil then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_iArchMode = mode;
    SO3WorldSetPlateformArchitecture (V3DgetSession sessionstr) sessionstr.V3D_physics.V3DPHYS_iArchMode;
  );
  0;
}


V3DphysGetArchitectureMode(sessionstr){
sessionstr.V3D_physics.V3DPHYS_iArchMode;
}


V3DphysGetArchitectureModeName(sessionstr){
let [SO3_PA_DEFAULT "default"]::[SO3_PA_MEDIUM "medium"]::[SO3_PA_BEST "best"]::nil -> l in
    switch l (V3DphysGetArchitectureMode sessionstr);
}


V3DphysSetArchitectureModeByName(sessionstr, smode){
let ["default" SO3_PA_DEFAULT]::["medium" SO3_PA_MEDIUM]::["best" SO3_PA_BEST]::nil -> l in
    V3DphysSetArchitectureMode sessionstr (switchstr l smode);
}


V3DphysSetSolverMode(sessionstr, mode){
if mode == nil then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_iSolverMode = mode;
    SO3WorldSetSolverModel (V3DgetSession sessionstr) sessionstr.V3D_physics.V3DPHYS_iSolverMode;
  );
  0;
}


V3DphysGetSolverMode(sessionstr){
sessionstr.V3D_physics.V3DPHYS_iSolverMode;
}


V3DphysGetSolverModeName(sessionstr){
let [SO3_SM_EXACT "exact"]::[SO3_SM_ADAPTATIVE "adaptative"]::nil -> l in
    switch l (V3DphysGetSolverMode sessionstr);
}


V3DphysSetSolverModeByName(sessionstr, smode){
let ["exact" SO3_SM_EXACT]::["adaptative" SO3_SM_ADAPTATIVE]::nil -> l in
    V3DphysSetSolverMode sessionstr (switchstr l smode);
}


V3DphysSetFrictionMode(sessionstr, mode){
if mode == nil then nil else
  (
    set sessionstr.V3D_physics.V3DPHYS_iFrictionMode = mode;
    SO3WorldSetFrictionModel (V3DgetSession sessionstr) sessionstr.V3D_physics.V3DPHYS_iFrictionMode;
  );
  0;
}


V3DphysGetFrictionMode(sessionstr){
sessionstr.V3D_physics.V3DPHYS_iFrictionMode;
}


V3DphysGetFrictionModeName(sessionstr){
let [SO3_FM_EXACT "exact"]::[SO3_FM_ADAPTATIVE "adaptative"]::nil -> l in
    switch l (V3DphysGetFrictionMode sessionstr);
}


V3DphysSetFrictionModeByName(sessionstr, smode){
let ["exact" SO3_FM_EXACT]::["adaptative" SO3_FM_ADAPTATIVE]::nil -> l in
    V3DphysSetFrictionMode sessionstr (switchstr l smode);
}


V3DphysSetBodyMass(sessionstr, body, mass){
SO3BodySetMass (V3DgetSession sessionstr) body mass;
  0;
}


V3DphysSetBodyLinearDamping(sessionstr, body, value){
SO3BodySetLinearDamping (V3DgetSession sessionstr) body value;
  0;
}


V3DphysSetBodyAngularDamping(sessionstr, body, vec){
SO3BodySetAngularDamping (V3DgetSession sessionstr) body vec;
  0;
}


V3DphysSetBodyContinuousCollision(sessionstr, body, mode){
SO3BodySetContiniousCollisionMode (V3DgetSession sessionstr) body mode;
  0;
}


V3DphysSetBodyMaterial(sessionstr, body, matname){
let if ((matname == nil) || (!strcmp "" (strtrim matname))) then "default" else matname -> matname in
  let SO3PhysicsGetMaterial (V3DgetSession sessionstr) matname -> mat in
  let if mat == nil then SO3PhysicsMaterialCreate (V3DgetSession sessionstr) matname else mat -> mat in
  (
    SO3BodySetMaterial (V3DgetSession sessionstr) body mat;
    mat;
  );
}


V3DphysCreateMaterialOnNode(sessionstr, node){
let SO3ObjectGetName (V3DgetSession sessionstr) node -> name in
  let V3DphysGetNodeBody sessionstr node -> body in
  if (body == nil) then nil else
  let SO3PhysicsMaterialCreate (V3DgetSession sessionstr) strcat name "_physmat" -> mat in
  (
    SO3BodySetMaterial (V3DgetSession sessionstr) body mat;
    mat;
  );
}


V3DphysCreateBodyShape(sessionstr, node){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;
    
    SO3BodyCreateShape (V3DgetSession sessionstr) node;
  );
}       


V3DphysCreateBodyEllipsoid(sessionstr, node){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;

    let SO3ObjectGetBoundingBoxInfo (V3DgetSession sessionstr) node -> [[sx sy sz] _ _] in
      SO3BodyCreateEllipsoid (V3DgetSession sessionstr) node [sx/.2.0 sy/.2.0 sz/.2.0];
  );
}


V3DphysCreateBodyCustomEllipsoid(sessionstr, node, vec){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;

    SO3BodyCreateEllipsoid (V3DgetSession sessionstr) node vec;
  );
}


V3DphysCreateBodyBox(sessionstr, node){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;

    let SO3ObjectGetBoundingBoxInfo (V3DgetSession sessionstr) node -> [vec _ _] in
      SO3BodyCreateBox (V3DgetSession sessionstr) node vec;
  );
}


V3DphysCreateBodyCustomBox(sessionstr, node, vec){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;

    SO3BodyCreateBox (V3DgetSession sessionstr) node vec;
  );
}


V3DphysCreateBodyCollisionTree(sessionstr, node){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;

    SO3EntitySetCollisionTree (V3DgetSession sessionstr) node;
  );
}


V3DphysDestroyBody(sessionstr, node){
let V3DphysGetNodeBody sessionstr node -> body in
  (
    if body == nil then nil else
      SO3BodyDestroy (V3DgetSession sessionstr) body;
  );
}


V3DphysSetMaterialProperties(material, bcoll, bcontcoll, staticfriction, kineticfriction, elasticity, softness){
0;
}


V3DphysEnableBody(sessionstr, body, mode){
let if !mode == 0 then 0 else 1 -> state in
    SO3BodySetFreeze (V3DgetSession sessionstr) body state;
  0;
}


V3DphysShowDebug(sessionstr, state){
SO3WorldShowLines (V3DgetSession sessionstr) state;
  0;
}


V3DphysCreate(sessionstr){
let mkV3Dphysics [nil nil nil nil nil nil nil nil] -> physstr in
  //SO3_PA_DEFAULT SO3_SM_EXACT SO3_FM_EXACT 
  (
    set sessionstr.V3D_physics = physstr;
    
    V3DphysSetArchitectureMode sessionstr SO3_PA_DEFAULT;
    V3DphysSetSolverMode sessionstr SO3_SM_EXACT;
    V3DphysSetFrictionMode sessionstr SO3_FM_EXACT;
    
    V3DphysSetWorld sessionstr [100000.0 100000.0 100000.0];
    V3DphysSetFps sessionstr 75;
    V3DphysSetGravity sessionstr 9.81;
    V3DphysEnablePhysic sessionstr 0;
  );
  0;
}


V3DphysDestroy(sessionstr){
V3DphysEnablePhysic sessionstr 0;
  set sessionstr.V3D_physics = nil;
  0;
}


V3DphysReset(sessionstr){
V3DphysDestroy sessionstr;
  V3DphysCreate sessionstr;
  0;
}
// -- [/filterPKG] --

---