Sorry your browser is not supported!

Fixed parameter issue with NDB_NewtonConvexCollisionCalculateVolume
Fixed doc for NDB_NewtonWorldRayCast (flags are 1 & 2)
Fixed TreeCollision with Limb flag bug (Limb 0 wouldn't have collision)
Fixed doc for NDB_NewtonJoint(Set/Get)Stiffness
Added Continuous Collision commands and modified Terrain demo to show how they work
Fixed demos with stacked boxes so they are more stable
Added commands for custom Sphere Collision callbacks using NewtonMaterialSetContactNormalDirection() from the SDK
Fixed bone number wheel leak when destroying ragdolls
Fixed bug in NDB_BodySetLiquid that affected NDB_BodySetBuoyancy
Added NoScale flag to NDB_BodyAddForceLocal/Global and NDB_BodySetForceLocal/Global

Newton Game Dynamic 1.53
- fixed documentation on function NewtonBodySetMatrixRecursive, now agree with header file description.
- fixed function NewtonBodyGetForce now returns correct net force aplied by the solver to the body.
- fixed function NewtonBodyGetTorque now returns correct net torque applied by the solver to the body.
- fixed separate collision with compound collision was not working correctly.
- fixed collision tree fases are single sided for raycastin and also for contact points.
- fixed spherical surfaced objects do not jumps when crossing across chared edge of collision tree adjacent faces.
- fixed vehicle joint no longer explode due to tires speening out of control
  when the vehicle was airborne and continue torque was applid to tires.
  tire max speed is clamped at 500 m/s per secund on idle. 
- fixed sphere and polygon edge contacts were rejected when contact was exactly over the edge
  now contacs on edge are included as valid. 
- fixed NewtonConvexCollisionCalculateInertialMatrix on compound collision agregates was using 
  a matrix from a last update instead of the normal primitive offset.
- fixed contact point between sphere collision were calculatedted incorrecly, they could cause big 
  misbehavior on games likes pool. (special thanks to user LtJax, for reporting teh bug privaltly) 
- Improvement tree collidder is not longer based on Bounding Boxes hierarkies for polygoin querie, 
  a proprietarty faster algorithm with smaller data structure is used instead. 
- API change function NewtonWorldRayCast now take an extra prefilter parameter for smarter and faster filtering.
- SDK raycast now show normals and ray at ray hit position on static geometries.
- Added Linux build now recognize SSE instrictuon set if present in eh system.
- Added Mac build now worlks with universal binary, it also make use of altivec and SEE, if present in the system
- Mac build is comaptible with G3/G4/G5 runing OS10
- modification linear and angular damping, are campled between 0.0 and 1.0 (allowing for not damping forces in simulations).

Newton Game Dynamic 1.52
-license has been modified to include the specific engine release.
-license clause specifying the Newton logo should be on any splash screen has been change to say the logo should be on any credit screen.
-changed lower limit of mass to be considered static body form 0.01 to 0.001
-slight overall engine optimization be replacing some of the standard math function with custom inline versions.
-fixed SetMinimunFrameRate now clamp fps bewteen 60 and 1000 frame per secund. 
-fixed convex hull prototype did not have const argument in front of imput arguments.
-fixed documentation on NewtonBodyGetSleepingState and NewtonBodyGetAutoFreeze was incorrect.
-fixed buyancy force calculation now works with transform modifiers. 
-added funtion NewtonWorldForEachBodyInAABBDo

Newton Game Dynamic 1.51
-Fixed vehicles tires friction was too weak.
-Fixed Vehicle collision with other dynamic bodies was too hard.
-Fixed ray cast normal in some primitives were inconsistent or un-rotated.
-Fixed debug display of comvex modifier wih non identity matrix ofsset were displaying incerrectly.
-Fixed setting center of mass after the body matrix was not shifting the initial matrix position of the body.
-Fixed continues collision was ignoring collision objects that where touching but not colliding. Allowing for fast moving body pass trough each other’s. 
-Fixed trivial rejection of convex primitives incorrectly rejecting collision with large flat convex polygon, leading to tire lost of traction.
-Fixed bug skipping clean contact generation across flat polygons between collision tree and convex primitives.
-Added marking of flat and concave edges on user defined meshes (see height field tutorial)
-Removed compiler option /Gs10000000 from visual studio (crash in some windows system).
-Removed Virtual memory used because horrendous vs8 does not handle virtual memory correctly.
 (this may slow down the collision tree generation of windows systems)

Newton Game Dynamic 1.5
- Improvement simple vehicle joint has been redesigned for easy implementation.
- Improvement optimized contact calculation for, capsules, cylinders and cones.
- Improvement tree optimizer now generates nicer optimized convex polygonal meshes.
- Improvement bilateral joints constraint are much more stable and less prompt to blow up.
- Improvement collision tree filter contact across coplanar and concave faces. 
- Improvement implemented new unique algorithm for contact selection, now does not have upper bound in contacts calculation.
- Fixed bug ray cast on convex hulls geometry is pixel accurate now.
- Fixed bug unstable contact point calculation for capsules collision.
- Fixed bug ray cast on boxes on rare occasion producing wrong intersection.
- Fixed collision tree optimizer much faster at building optimized collision.   
- Fixed bug crash when adding NULL collision geometry to a compound aggregates.
- Fixed bug convex hull on point clouds of 4 vertices not longer crash the engine.
- Fixed bug ray casting on all collision geometries not longer is one frame behind.
- Fixed bug debug displayed collision primitive were rendered one frame behind the update.
- Fixed bug in collision tree optimizer adding multiple triangle layers when multiple ID where used.
- Fixed bug in convex collision primitives not been cached properly (very important for memory saving)
- Fixed bug with ray cast occasionally missing collision when called from outside of a Newton Update call.
- Fixed random crash bug due to pointers alias between the solver and the collision system charing the same memory buffer.  
- Fixed collision tree optimizer not longer run out of memory for reasonable size memory meshes (2 million triangles or larger)  
- API all dll version are now mutithreaded.
- API vehicle joint function NewtonVehicleBalanceTires has been deprecated.
- API change function NewtonWorldCollide is changed to NewtonCollisionCollide.
- API change function NewtonWorldCollide is changed to NewtonCollisionCollide.
- API change function tire ID are pointers instead of unsigned integers.
- API change funtion Buoyancy callback funtion now report the collision ID of the current geometry
- API change function NewtonCreateConvexHull not longer take a matrix offset as parameter.
- API change function NewtonConvexCollisionCalculateVolume is changed to NewtonConvexCollisionCalculateVolume
- New feature added calculation of the closest point and separating vector from a point to convex geometries.
- New feature added calculation of the closest point and separating vector between two convex geometries.
- New feature the ability to offset the center of mass of a rigid body.
- New feature custom joint now can act like spring/damper system.
- New feature custom joint jacobina matrix is fully exposed to teh application.
- New feature implementation of continue collision base of translational speed.
- New feature added function to calculate inertia matrix of a convex collision objects.

` MAIN LOOP

	repeat
		updateBaseTimer()       ` Update timer
		checkInput()            ` Get input from user, store in flags
		updatePhysicsForces(1)  ` Update the physics
		moveCamera(1)           ` finally, move the camera before the sync
		updatePlayerState(1)  ` Player dead, falling, etc
		doDebugNewton()
		sync
		cleanupDebugNewton()
	until _levelExit = TRUE

remstart
PHYSICS ENGINE DESCRIPTION
We use time-slicing, so it is guaranteed that Newton will update 100 times
per second, no matter how fast the machine is.  The steps we perform per
10 millisecond slice is as follows:
1) Call recordPhysicsReactions()
   - Will record the current state of the player before the Newton Update
     This is capture info such as velocity and direction, etc
2) Call updatePhysicsReactions()
   - adds forces based on player input
   - if player has contact with a widget, it calls doWidgetReaction to do
     action or set state on widget
   - checks to see if any special material contact has occurred
   - checks to see if player is in a Zone, if they are call doZoneReaction
3) Call updateWidgetsReactions()
   - goes through all widgets, and updates their state
   - if widget active, then performs activity for widget
   - Also handles animation of widgets
4) Call NDB_NewtonUpdate 0.01
   - Updates Newton ahead by 10 milliseconds
5) Call recordMaterialContact()
   - Checks for all materials to see if player has contacted them.  Currently
     only useful for checking Widgets and ROUGH type tiles.
   - Will probably be useful for generating sounds or other material-based activites
6) Call updateCamera()
   - Updates camera target angle based on accumulated player input using fixed time-step
And repeat...
remend


` This is the main function for physics activity.  It uses time-slicing.
` It should run through an iteration every 1/100 second
function updatePhysicsForces(plyr as integer)
	` If sync ever gets faster than 100 FPS, this will prevent premature updates
	if Timing.timeBank# < 0.01 then exitfunction
	
	repeat
		recordPhysicsReactions(plyr)
		updatePhysicsReactions(plyr)
		updateWidgetsReactions(plyr)
		Timing.newt# = hitimer()
		NDB_NewtonUpdate 0.01
		recordMaterialContact(plyr)
		Timing.newt# = hitimer() - Timing.newt#
		inc Timing.newtTotal#, Timing.newt#
		` Make sure updateCamera is AFTER player object moves (or camera "stutters")
		updateCamera(plyr)
		dec Timing.timeBank#, 0.01
	until Timing.timebank# < 0.01
` For camera and any other routines that require the latest marble states
recordPhysicsReactions(plyr)
endfunction

sync on
sync rate 60
autocam off

set ambient light 100
set point light 0, 50, 100, -50
set light range 0, 5000

randomize timer()

load image "..\media\floor.png",1

position camera 0.0, 5.0, -20.0

dim GOSTR$(2)
GOSTR$(1) = "SIMULATION PAUSED"
GOSTR$(2) = "SIMULATION RUNNING"
gosub MakePickObjects

TOP:
gosub MakeFloor
GO = 1
wait 100

do
   if lower$(inkey$()) = "q" then exit
   if lower$(inkey$()) = "r"
      goto TOP
   endif
   if spacekey() and SPACEPRESSED = 0 then SPACEPRESSED = 1
   if SPACEPRESSED = 1
      SPACEPRESSED = 2
      inc GO, 1
      if GO > 1 then GO = 0
   endif
   if spacekey()=0 then SPACEPRESSED = 0
   gosub DrawOnscreenData
   gosub HandleCamera
   sync
loop

end

MakeFloor:
   FloorObj = FreeObject()
   load object "..\media\box.x", FloorObj
   position object FloorObj, 0.0, -20.0, 0.0
   scale object FloorObj, (1000.0*100.0), (10.0*100.0), (1000.0*100.0)
   scale object texture FloorObj, 10.0, 10.0
   texture object FloorObj, 1
return


`this subroutine makes the simple in-screen display, which explains how to use the demo.
DrawOnscreenData:
   box 5,5,615,112,rgb(0,0,0),rgb(100,100,100),rgb(0,0,0),rgb(100,100,100)
   line 5,5,615,5
   line 5,5,5,112
   line 615,5,615,112
   line 5,112,615,112
   text 10,10,"Newton Game Dynamics Wrapper version:"
   text 10,20,"COLLISION PRIMITIVES TEST"
   text 10,40," [B]ox || [S]phere || [C]ylinder || ca[P]sule || co[N]e || convex [H]ull"
   text 10,50," Hold CTRL for debug data || Drag RMB to move bodies"
   text 10,60," Drag Mouse to look || Arrows to move camera || Space to (un)pause"
   text 10,70," Press "r" to reset || press "q" to quit"
   text 10,80," FPS:"+str$(screen fps())
   text 15,95,GOSTR$(GO+1)
return

` FUNCTIONS ---------------------------------
function FreeObject()
   repeat
      inc i
      if object exist(i)=0 then found=1
   until found
endfunction i

function GetColor()
   repeat
      r = rnd(1)*255
      g = rnd(1)*255
      b = rnd(1)*255
   until r<>0 or g<>0 or b<> 0
   color =  rgb(r,g,b)
endfunction color

` This subroutine handles moving/rotating the camera.  should be pretty straightforward.
HandleCamera:
   `-------------------------
   `CAMERA
   `-------------------------
   if upkey() then move camera 1.0
   if downkey() then move camera -1.0
   if leftkey()
      turn camera left 90.0
      move camera 1.0
      turn camera right 90.0
   endif
   if rightkey()
      turn camera right 90.0
      move camera 1.0
      turn camera left 90.0
   endif
   if mouseclick()=1 and MOUSE = 0
      MOUSE = 1
      dump = mousemovex()
      dump = mousemovey()
   endif
   if mouseclick()=1 and MOUSE = 1
      inc CamAngleX#, mousemovey()
      inc CamAngleY#, mousemovex()
      rotate camera CamAngleX#, CamAngleY#, 0.0
   endif

return

MakePickObjects:

   `PickObjects
   PickObj1 = FreeObject()
   make object sphere PickObj1, 0.5
   set object emissive PickObj1, rgb(255,255,0)
   set object ambience PickObj1, 100
   hide object PickObj1
   PickObj2 = FreeObject()
   make object sphere PickObj2, 0.5
   set object emissive PickObj2, rgb(255,0,255)
   set object ambience PickObj2, 100
   hide object PickObj2

return

function NeverCalled()
   if memblock exist(1) then delete memblock 1
endfunction