ODE Physics Editor for 14,95€

It is finished right now:

www.lcuriel.arrakis.es/kode/

OLD POST:
Hi people. I am working on a full ode editor to be used with c++ or blitz3D code. With a very simple editor you can make ragdoll's, vehicle's, and test them inmediately in a Blitz3D window.

Then you can export to b3d code (with my own wrapper dll or standard c++ code).

The editor comes with the last version of my dll wrapper with working trimesh collision and full set of commands (ray collision, ccylinder, box, trimesh, geom transform, all joints, etc...).

I am planning on selling the pack (editor + wrapper) for 14,95€. I have implemented the basic interface and the vehicle editor, now working on the ragdoll editor.

Do you see like an interesting offer? Any comment really apreciated, thanks!

I would - if it's truly pro and (relatively) easy to use. No use to buy a helper app if it doesn't speed up the dev'ving process... :)

What is your "own wrapper code"... can you explain how it differs from JV-ODE? And what's the ETA on your editor?

I will need a large number of ODE objs for my project so if I can make all those collision objs more easily it will be well worth the money.

Hi Mustang! Thanks for your reply. Of course i would like to make it pro (i try!!!). My wrapper supports tri mesh perfectly (at least at the same rate as the original ode).

With the kit i will give lot of source code with examples. It will support all the original ode primitives (not sure about the cylinder support). It will work in a very similar way to Jv-Ode, but more similiar to arkon's one. Don't know the release time right now, hope less than a month.

The really power of the editor is that you can drag bodies and joints with the mouse in a visual way, then with one click you see the result instantly.

The Wrapper it will use has been tested very hard, and is working perfectly in my racing game.

That would be good - and very pro feature... testing (any) stuff is really tedious if it isn't fast & easy.



Do you have a downloadable racing game demo I can "test"? Although my game is far from any car game it has (driveable) vehicles and (hopefully) lot's of ragdolls, explosions and all the usual "level" and building stuff that needs good collisions... so what you there would be perfect for me.

Cool, good luck!
How long have you been working on this?
Took me exactly 1 year and 3 days to get mine to a working stage :D

Well, the problem with my racing game is that is growing too fast, and i don't have any recent demo. Anyway i promise i will show demos of my kit and my game before selling it!!!

Mr. Pickles, do you have a ode physics editor working right now?

No I don't entirely, you beat me to it :D
Sounds like a very good kit you've got in the works here!

Getting closer, and here are the basics of the editor:

All is based on: objects,joints and trimeshes.
An Object can have:
- 1 Body
- 1 or More Geoms (Including Geom Transforms)
- 1 or More Meshes

You have joints for the objects, supporting all ode joints.

And then you can have one trimesh of any size.

The basic working is:

- You create objects, and assign them bodies, geoms, meshes (or only one of them).
An object with only geom is a static object.
An object with only a mesh is a decoration object.
An object with only a body has no too much sense.

- You create then joints, and select two bodies for every joint or only one to have it attached to the world.

- You load if you want a trimesh.

At any point you can change the properties of mass, intertia tensor, suspension, cfm, erp, etc...

Then you click the PLAY button and all start running, been able to drag objects with the mouse in real time.

Ok, this was only for you to have news!

Cool! Can I modifyi interactively those mass etc values when the simulation is running or does it need a reset between value changes (ODE I mean)?

Well, at this moment you select all those properties (mass, intertia tensor, etc...) in the editor, before the simulation starts.

If you need to change the mass you stop the simulation, change it, and start it again. It is a very fast method, although it is not while the simulation is running.

mmm, it is a good idea anyway, although ODE doesn't like when you change things like that during the simulation :D

Yup, that's the normal case with physics I guess... you need to set everything beforehand and then the simulation takes over, not much you can change while it's running. Would be good and nice though if something like that would work.

I know that there are some options that can be changed without problems, like the Gravity, the number of steps, and ... why not ... the mass ;) So there is a function called AdjustMass!

Wow, here is the first screenshot. The interface is still in development.

At the moment, almost all ODE properties are implemented. I am debugging the save and load processes and deciding some things. I plan to release when the editor become almost a level editor for physics too!

www.lcuriel.arrakis.es/kode/kodesc1.jpg

Enjoy!

Looks great :D

KuRiX, the link is dead for me at the moment, it gives a 'Cannot find server' message...

I'll try again later :)

Yeah, sorry, my server arrakis is dead!!!. You can see the screenshot in the gallery!

Thanks!

Ah, looking good so far KuRiX :)

Will there be a limited demo version available when the editor is completed?

Of Course... It will be full featured but with save and export disabled and limited time dll ...

Thanks for your interest, i am working very hard on making this fast and really util...

I think you should ditch the DirectX GUI and use a real interface. Especially when ODEEd is free:
www.odeed.org

You should use OpenGL with BlitzPlus, but if you can't program the 3D maths, use PureBasic to put windows controls in a Blitz3D window.

I know Odeed, and it is exactly the reason of doing my own editor...

I find it too slow to make anything serious...

Well the editor is finished right now. The .BB Export is finished and i have added dCylinder to the Dll, although i include a fake cylinder using boxed ccylinder, which works lot better than dcylinder.

The only remaining thing is the c++ export and lot of testing, and perhaps some optimizations. I will prepare the demos (ragdolls, vehicles, trimesh, etc...) and then a demo will be available in two days, before the official release.

Cheers, KuRi.

Cool! I have really waited for this and was bit worried because often these "It will be ready in xx weeks" promises just fade and soft becomes vapourware. Good job! Screenshots?

vapourware, hahaha, nice name.

Here are some more screenshots:

www.lcuriel.arrakis.es/kode/scr1.jpg
www.lcuriel.arrakis.es/kode/scr2.jpg
www.lcuriel.arrakis.es/kode/scr3.jpg
www.lcuriel.arrakis.es/kode/scr4.jpg

Enjoy!

Be less confusing to only expose parameters when they are applicable.

Thanks, i will try to hide the invalid values...

Use a listview (multi-column list box), if your gui supports it.

Nope, it is not supported. But i have fixed it disabling the invalid parameters :D

Well, i keep preparing the tutorials!

Well, KODE IS HERE!

Please try the demo before buying. I am testing this very hard.

Check all the docs in the Web. The help docs come with the pack.

www.lcuriel.arrakis.es/kode/

Download the Demo. Execute, then load the tutorials file and click Simulation -> Run!

Hope you like it. Please do not attack me too much if you don't like it. This is my first selling software.

All comments and suggestions are welcome.

Coolness! Downloading now... I really can't start testing it until tomorrow evening though.

Looks very good,

What version of ODE are you using ?
are you wrapper included when i buy the editor ?

Is there any issus like with the trimesh ?

/Alienforce

Hello Alien. The Full Wrapper is included when you buy. I use the latest of CSV ODE. I have recompiled with the last files and i have added dcylinder.

I have included almost all ODE functions (Rays, Trimesh, Geomtransform, etc...) but if someone fails ask me and i will add it ;)

The trimesh works perfectly with cubes, spheres, ccylinders, rays, etc...

the only non working is the dcylinder with trimesh. Anyway the better way to make a cylinder is using a boxed ccylinder :D

Just bought it! I trust that it is as good as it (demo) looks, and will get even better in the future. I have few ideas brewing alread... I'll email you about those later, after getting the full soft and bit of experimenting. :)

Well, thanks then Mustang! I have already sent it to you - 2 MB, i hope your email account is big enough.

And please, email me with all your ideas and questions, i want to make it the best editor! To email me please use the seller mail: kurisoft @ arrakis [dot] es

How come KuRix can make trimesh work with primatives and JVODE has trouble ? Is the trimesh clean or hacked to work ?

I'd buy it just for a good wrapper..

Well i never saw the JV-ODE code with the trimesh. I bought Jedive Wrapper the first day it was released, but when i saw its rotation problem i decided to make my own dll wrapper in a similar way to the arkon's one.

You can test the Trimesh in the demo version, so please download it and make all the tests to see if it is good for you. As i have mentioned somewhere before, trimesh works perfectly for cubes, rays, spheres,ccylinders,... At least in the same way the original ODE does. I have not faked that :D

It is only not working with dcylinder (due to the original dcylinder implementation). But i am going to add a boxed ccylinder in the .kode library on my web very soon!

Getting download now. Thanks for the reply.

Work really nicely. Well done. I will probably buy this at some point.

Quick question: can you load a mesh (eg. a skull) and have an auto-sized physics sphere attached/created for it? or even vice-versa?

Hi Beaker. Thanks!. You are the creator of FontText!, I bought it not long ago, nice software.

At this point there is an automatically creation of physics object (body + mesh + geom) but not for loaded meshes. But i think this is an easy "to do" thing, cause i only need to take the size of the mesh and create bounding sphere or bounding box.

The way to do this now is loading the mesh, then creating the sphere body and geom and reescaling it to fit the mesh.

The idea is now in my "to do" list. Cheers!

Here it is, as i promised, a boxed Cylinder. This is an easy way to make a normal cylinder using ccylinder and 2 boxes. The advantage is that you can use it to have perfect collision with trimeshes.

Check out the kode library:

www.lcuriel.arrakis.es/kode/library.htm

KuRiX - does your's editor HAVE to use your ODE wrapper, or can it export to other formats? ie. Can it be used for editing ODE scenes/objects for a non-Blitz program?

Well, it has a C++ Code Exporter, but this haven't been tested, so it will give you a very nice aproximation of the c++ code, but it is not directly compilable (you need to put it in the ode directory with the libs, the includes, the 3d mesh loader, etc...).

If you want a dedicated exporter for any program send me the commands and i will add it ;)

Hi Kurix,

Kode Editor Demo, KODE Config Window
1. Be nice to see description of what the parameter does when you click on one of the text boxes.

Kode Editor Demo, Edit, Delete Entity
shortcut says 'supr' whats that mean ?

Kode Editor Demo, Simulation
1. Be nice to set graphics mode for simulation window.

Kode Editor Demo, New entity, Edit
Color picker allows me to choose a color but doesn't appear to do anything, whats it for ? Some basic help on mouse over would be good.

Kode Editor Demo, (Camera/Entity)
It's hard to tell which button is active.
Whats the difference between them?

Userlibs\BlitzKODE.decls
1. Be nice if the KODE_ prefixs were dropped so we can easily run the arkon demos. I know the user can edit the decls and do this, just more work.

Export:
How about some sample B3d code output?

Other questions:
Why create and entity ?
Why use a trimesh ?
Can simulation load more than one Trimesh ?
Can simulation load B3d for Trimesh ?
Can Ode handle more than one Trimesh ?
What GUI you using with KODE ?
How do I run KODE full screen ?

I'm close to buying this for working trimesh support alone, and it's icing on the cake to get the KODE Editor and B3d code generator. Nice work so far.

* I like the clever idea to make the demo dll with time steps limit. 8)

Hi Wayne. Really Thanks for that post. It seems like you are testing it very hard. good job.

I will answer all your questions one by one:

Kode Editor Demo, KODE Config Window
1. Be nice to see description of what the parameter does when you click on one of the text boxes.

Well, i would like to add tags, but the gui doesn't support them. I know i must complete the help docs.

Kode Editor Demo, Edit, Delete Entity
shortcut says 'supr' whats that mean ?

"supr" is the Delete Key :D. Sorry, this is my fault, in spanish is the supr key ("suprimir")

Kode Editor Demo, Simulation
1. Be nice to set graphics mode for simulation window.

Click on Simulation -> Setup to change the resolution. Do you want to set it fullscreen?

Kode Editor Demo, (Camera/Entity)
It's hard to tell which button is active.
Whats the difference between them?

Camera is for moving and rotating cameras. When this button is active you cannot move entities, so it is more secure.

Userlibs\BlitzKODE.decls 
1. Be nice if the KODE_ prefixs were dropped so we can easily run the arkon demos. I know the user can edit the decls and do this, just more work.

This is not the Arkons wrapper. Functions may be different.

- I will post here some b3d code output sample later.

Other Questions:

- Why create an entity?
Why not?. Entities are the base of the editor. Entities are bodies, geoms, meshes, trimeshes, etc...

- Why use a trimesh?
A Trimesh is a huge collection of triangles where you can collide objects. So it is perfect for game maps, levels, scenarios, etc...

- Can simulation load more than one Trimesh ?
Not at this time. It is better to have only one big trimesh modelled in your favourite 3d modeller.

- Can simulation load B3d for Trimesh?
Yes, you can change the file type in the load dialog.

- Can Ode handle more than one Trimesh ?
I think it can, but it is to support trimesh trimesh collision that is not full working on ODE.

- What GUI you using with KODE ?
BliztUI

Cheers, KuRiX

How do I run KODE full screen ?
Will customers will receive KODE Editor source ?

I really like this editor.
What is the price is US Dollars ? ($18 ?)

I can't live with KODE function prefixes.
Please consider and option to drop prefixes from the code generator.

Thanks for the reply

Here is the stripped down decls

.lib "BlitzKODE.dll"
isDemo%():"_KODE_isDemo@0"
dSetContactMode(mode%):"_KODE_dSetContactMode@4"
dSetMU(value#):"_KODE_dSetMU@4"
dSetMU2(value#):"_KODE_dSetMU2@4"
dSetBOUNCE(value#):"_KODE_dSetBOUNCE@4"
dSetBOUNCE_VEL(value#):"_KODE_dSetBOUNCE_VEL@4"
dSetSLIP1(value#):"_KODE_dSetSLIP1@4"
dSetSLIP2(value#):"_KODE_dSetSLIP2@4"
dSetSOFT_ERP(value#):"_KODE_dSetSOFT_ERP@4"
dSetSOFT_CFM(value#):"_KODE_dSetSOFT_CFM@4"
dSetMOTION1(value#):"_KODE_dSetMOTION1@4"
dSetMOTION2(value#):"_KODE_dSetMOTION2@4"
dBodyGetCollisionsCount%(body%):"_KODE_dBodyGetCollisionsCount@4"
dBodyGetCollisionDepth#(body%, num%):"_KODE_dBodyGetCollisionDepth@8"
dBodyGetCollisionX#(body%, num%):"_KODE_dBodyGetCollisionX@8"
dBodyGetCollisionY#(body%, num%):"_KODE_dBodyGetCollisionY@8"
dBodyGetCollisionZ#(body%, num%):"_KODE_dBodyGetCollisionZ@8"
dBodyGetCollisionNX#(body%, num%):"_KODE_dBodyGetCollisionNX@8"
dBodyGetCollisionNY#(body%, num%):"_KODE_dBodyGetCollisionNY@8"
dBodyGetCollisionNZ#(body%, num%):"_KODE_dBodyGetCollisionNZ@8"
dBodyGetCollisionBody%(body%, num%):"_KODE_dBodyGetCollisionBody@8"
dBodyGetCollisionGeom%(body%, num%):"_KODE_dBodyGetCollisionGeom@8"
dBodyGetCollisionFX#(body%, num%):"_KODE_dBodyGetCollisionFX@8"
dBodyGetCollisionFY#(body%, num%):"_KODE_dBodyGetCollisionFY@8"
dBodyGetCollisionFZ#(body%, num%):"_KODE_dBodyGetCollisionFZ@8"
dWorldCreate%(plane):"_KODE_dWorldCreate@4"
dWorldDestroy():"_KODE_dWorldDestroy@0"
dWorldSetGravity(x#, y#, z#):"_KODE_dWorldSetGravity@12"
dWorldSetERP(erp#):"_KODE_dWorldSetERP@4"
dWorldGetERP#():"_KODE_dWorldGetERP@0"
dWorldSetCFM(cfm#):"_KODE_dWorldSetCFM@4"
dWorldGetCFM#():"_KODE_dWorldGetCFM@0"
dWorldSetAutoDisableFlag(do_auto_disable%):"_KODE_dWorldSetAutoDisableFlag@4"
dWorldGetAutoDisableFlag%():"_KODE_dWorldGetAutoDisableFlag@0"
dWorldSetAutoDisableLinearThreshold(linear_threshold#):"_KODE_dWorldSetAutoDisableLinearThreshold@4"
dWorldGetAutoDisableLinearThreshold#():"_KODE_dWorldGetAutoDisableLinearThreshold@0"
dWorldSetAutoDisableAngularThreshold(linear_threshold#):"_KODE_dWorldSetAutoDisableAngularThreshold@4"
dWorldGetAutoDisableAngularThreshold#():"_KODE_dWorldGetAutoDisableAngularThreshold@0"
dWorldSetAutoDisableSteps(steps%):"_KODE_dWorldSetAutoDisableSteps@4"
dWorldGetAutoDisableSteps%():"_KODE_dWorldGetAutoDisableSteps@0"
dWorldSetAutoDisableTime(time#):"_KODE_dWorldSetAutoDisableTime@4"
dWorldGetAutoDisableTime#():"_KODE_dWorldGetAutoDisableTime@0"
dWorldImpulseToForce(stepsize#, ix#, iy#, iz#, fx#, fy#, fz#):"_KODE_dWorldImpulseToForce@28"
dCloseODE():"_KODE_dCloseODE@0"
dWorldStep(step#):"_KODE_dWorldStep@4"
dWorldQuickStep(step#):"_KODE_dWorldQuickStep@4"
dWorldSetQuickStepNumIterations(num%):"_KODE_dWorldSetQuickStepNumIterations@4"
dWorldGetQuickStepNumIterations%():"_KODE_dWorldGetQuickStepNumIterations@0"
dWorldSetContactMaxCorrectingVel(vel#):"_KODE_dWorldSetContactMaxCorrectingVel@4"
dWorldGetContactMaxCorrectingVel#():"_KODE_dWorldGetContactMaxCorrectingVel@0"
dWorldSetContactSurfaceLayer(depth#):"_KODE_dWorldSetContactSurfaceLayer@4"
dWorldGetContactSurfaceLayer#():"_KODE_dWorldGetContactSurfaceLayer@0"
dBodyCreate%():"_KODE_dBodyCreate@0"
dBodyDestroy(body%):"_KODE_dBodyDestroy@4"
dBodySetPosition(body%, x#, y#, z#):"_KODE_dBodySetPosition@16"
dBodySetRotation(body%, x#, y#, z#):"_KODE_dBodySetRotation@16"
dBodySetLinearVel(body%, x#, y#, z#):"_KODE_dBodySetLinearVel@16"
dBodySetAngularVel(body%, x#, y#, z#):"_KODE_dBodySetAngularVel@16"
dBodyGetPositionX#(body%):"_KODE_dBodyGetPositionX@4"
dBodyGetPositionY#(body%):"_KODE_dBodyGetPositionY@4"
dBodyGetPositionZ#(body%):"_KODE_dBodyGetPositionZ@4"
dBodyGetPitch#(body%):"_KODE_dBodyGetPitch@4"
dBodyGetYaw#(body%):"_KODE_dBodyGetYaw@4"
dBodyGetRoll#(body%):"_KODE_dBodyGetRoll@4"
dBodyGetLinearVelX#(body%):"_KODE_dBodyGetLinearVelX@4"
dBodyGetLinearVelY#(body%):"_KODE_dBodyGetLinearVelY@4"
dBodyGetLinearVelZ#(body%):"_KODE_dBodyGetLinearVelZ@4"
dBodyGetAngularVelX#(body%):"_KODE_dBodyGetAngularVelX@4"
dBodyGetAngularVelY#(body%):"_KODE_dBodyGetAngularVelY@4"
dBodyGetAngularVelZ#(body%):"_KODE_dBodyGetAngularVelZ@4"
dBodySetMass(body%, mass#):"_KODE_dBodySetMass@8"
dBodyTranslateMass(body%, x#, y#, z#):"_KODE_dBodyTranslateMass@16"
dBodyAddForce(body%, x#, y#, z#):"_KODE_dBodyAddForce@16"
dBodyAddTorque(body%, x#, y#, z#):"_KODE_dBodyAddTorque@16"
dBodyAddRelForce(body%, x#, y#, z#):"_KODE_dBodyAddRelForce@16"
dBodyAddRelTorque(body%, x#, y#, z#):"_KODE_dBodyAddRelTorque@16"
dBodyAddForceAtPos(body%, fx#, fy#, fz#, px#, py#, pz#):"_KODE_dBodyAddForceAtPos@28"
dBodyAddForceAtRelPos(body%, fx#, fy#, fz#, px#, py#, pz#):"_KODE_dBodyAddForceAtRelPos@28"
dBodyAddRelForceAtPos(body%, fx#, fy#, fz#, px#, py#, pz#):"_KODE_dBodyAddRelForceAtPos@28"
dBodyAddRelForceAtRelPos(body%, fx#, fy#, fz#, px#, py#, pz#):"_KODE_dBodyAddRelForceAtRelPos@28"
dBodyGetForceX#(body%):"_KODE_dBodyGetForceX@4"
dBodyGetForceY#(body%):"_KODE_dBodyGetForceY@4"
dBodyGetForceZ#(body%):"_KODE_dBodyGetForceZ@4"
dBodyGetTorqueX#(body%):"_KODE_dBodyGetTorqueX@4"
dBodyGetTorqueY#(body%):"_KODE_dBodyGetTorqueY@4"
dBodyGetTorqueZ#(body%):"_KODE_dBodyGetTorqueZ@4"
dBodySetForce(body%, x#, y#, z#):"_KODE_dBodySetForce@16"
dBodySetTorque(body%, x#, y#, z#):"_KODE_dBodySetTorque@16"
dBodyGetRelPointPosX#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointPosX@16"
dBodyGetRelPointPosY#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointPosY@16"
dBodyGetRelPointPosZ#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointPosZ@16"
dBodyGetRelPointVelX#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointVelX@16"
dBodyGetRelPointVelY#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointVelY@16"
dBodyGetRelPointVelZ#(body%, px#, py#, pz#):"_KODE_dBodyGetRelPointVelZ@16"
dBodyGetPointVelX#(body%, px#, py#, pz#):"_KODE_dBodyGetPointVelX@16"
dBodyGetPointVelY#(body%, px#, py#, pz#):"_KODE_dBodyGetPointVelY@16"
dBodyGetPointVelZ#(body%, px#, py#, pz#):"_KODE_dBodyGetPointVelZ@16"
dBodyGetPosRelPointX#(body%, px#, py#, pz#):"_KODE_dBodyGetPosRelPointX@16"
dBodyGetPosRelPointY#(body%, px#, py#, pz#):"_KODE_dBodyGetPosRelPointY@16"
dBodyGetPosRelPointZ#(body%, px#, py#, pz#):"_KODE_dBodyGetPosRelPointZ@16"
dBodyVectorToWorldX#(body%, px#, py#, pz#):"_KODE_dBodyVectorToWorldX@16"
dBodyVectorToWorldY#(body%, px#, py#, pz#):"_KODE_dBodyVectorToWorldY@16"
dBodyVectorToWorldZ#(body%, px#, py#, pz#):"_KODE_dBodyVectorToWorldZ@16"
dBodyVectorFromWorldX#(body%, px#, py#, pz#):"_KODE_dBodyVectorFromWorldX@16"
dBodyVectorFromWorldY#(body%, px#, py#, pz#):"_KODE_dBodyVectorFromWorldY@16"
dBodyVectorFromWorldZ#(body%, px#, py#, pz#):"_KODE_dBodyVectorFromWorldZ@16"
dBodyEnable(body%):"_KODE_dBodyEnable@4"
dBodyDisable(body%):"_KODE_dBodyDisable@4"
dGeomEnable(geom%):"_KODE_dGeomEnable@4"
dGeomDisable(geom%):"_KODE_dGeomDisable@4"
dGeomIsEnabled%(geom%):"_KODE_dGeomIsEnabled@4"
dBodyIsEnabled%(body%):"_KODE_dBodyIsEnabled@4"
dBodySetAutoDisableFlag(body%, do_auto_disable%):"_KODE_dBodySetAutoDisableFlag@8"
dBodyGetAutoDisableFlag%(body%):"_KODE_dBodyGetAutoDisableFlag@4"
dBodySetAutoDisableLinearThreshold(body%, linear_threshold#):"_KODE_dBodySetAutoDisableLinearThreshold@8"
dBodyGetAutoDisableLinearThreshold#(body%):"_KODE_dBodyGetAutoDisableLinearThreshold@4"
dBodySetAutoDisableAngularThreshold(body%, linear_threshold#):"_KODE_dBodySetAutoDisableAngularThreshold@8"
dBodyGetAutoDisableAngularThreshold#(body%):"_KODE_dBodyGetAutoDisableAngularThreshold@4"
dBodySetAutoDisableTime(body%, time#):"_KODE_dBodySetAutoDisableTime@8"
dBodyGetAutoDisableTime#(body%):"_KODE_dBodyGetAutoDisableTime@4"
dBodySetAutoDisableDefaults(body%):"_KODE_dBodySetAutoDisableDefaults@4"
dBodySetFiniteRotationMode(body%, mode%):"_KODE_dBodySetFiniteRotationMode@8"
dBodyGetFiniteRotationMode%(body%):"_KODE_dBodyGetFiniteRotationMode@4"
dBodySetFiniteRotationAxis(body%, x#, y#, z#):"_KODE_dBodySetFiniteRotationAxis@16"
dBodyGetFiniteRotationAxisX#(body%):"_KODE_dBodyGetFiniteRotationAxisX@4"
dBodyGetFiniteRotationAxisY#(body%):"_KODE_dBodyGetFiniteRotationAxisY@4"
dBodyGetFiniteRotationAxisZ#(body%):"_KODE_dBodyGetFiniteRotationAxisZ@4"
dBodyGetNumJoints%(body%):"_KODE_dBodyGetNumJoints@4"
dBodyGetJoint%(body%, index%):"_KODE_dBodyGetJoint@8"
dBodySetGravityMode(body%, mode%):"_KODE_dBodySetGravityMode@8"
dBodyGetGravityMode%(body%):"_KODE_dBodyGetGravityMode@4"
dJointCreateBall%():"_KODE_dJointCreateBall@0"
dJointCreateHinge%():"_KODE_dJointCreateHinge@0"
dJointCreateSlider%():"_KODE_dJointCreateSlider@0"
dJointCreateUniversal%():"_KODE_dJointCreateUniversal@0"
dJointCreateHinge2%():"_KODE_dJointCreateHinge2@0"
dJointCreateFixed%():"_KODE_dJointCreateFixed@0"
dJointCreateAMotor%():"_KODE_dJointCreateAMotor@0"
dJointDestroy(joint%):"_KODE_dJointDestroy@4"
dJointAttach(joint%, body1%, body2%):"_KODE_dJointAttach@12"
dJointSetData(joint%, data*):"_KODE_dJointSetData@8"
dJointGetData(joint%, data*):"_KODE_dJointGetData@8"
dJointGetType%(joint%):"_KODE_dJointGetType@4"
dJointGetBody%(joint%, index%):"_KODE_dJointGetBody@8"
dAreConnected%(body1%, body2%):"_KODE_dAreConnected@8"
dAreConnectedExcluding%(body1%, body2%, joint_type%):"_KODE_dAreConnectedExcluding@12"
dJointSetBallAnchor(joint%, x#, y#, z#):"_KODE_dJointSetBallAnchor@16"
dJointGetBallAnchorX#(joint%):"_KODE_dJointGetBallAnchorX@4"
dJointGetBallAnchorY#(joint%):"_KODE_dJointGetBallAnchorY@4"
dJointGetBallAnchorZ#(joint%):"_KODE_dJointGetBallAnchorZ@4"
dJointGetBallAnchor2X#(joint%):"_KODE_dJointGetBallAnchor2X@4"
dJointGetBallAnchor2Y#(joint%):"_KODE_dJointGetBallAnchor2Y@4"
dJointGetBallAnchor2Z#(joint%):"_KODE_dJointGetBallAnchor2Z@4"
dJointSetHingeAnchor(joint%, x#, y#, z#):"_KODE_dJointSetHingeAnchor@16"
dJointSetHingeAxis(joint%, x#, y#, z#):"_KODE_dJointSetHingeAxis@16"
dJointGetHingeAnchorX#(joint%):"_KODE_dJointGetHingeAnchorX@4"
dJointGetHingeAnchorY#(joint%):"_KODE_dJointGetHingeAnchorY@4"
dJointGetHingeAnchorZ#(joint%):"_KODE_dJointGetHingeAnchorZ@4"
dJointGetHingeAnchor2X#(joint%):"_KODE_dJointGetHingeAnchor2X@4"
dJointGetHingeAnchor2Y#(joint%):"_KODE_dJointGetHingeAnchor2Y@4"
dJointGetHingeAnchor2Z#(joint%):"_KODE_dJointGetHingeAnchor2Z@4"
dJointGetHingeAxisX#(joint%):"_KODE_dJointGetHingeAxisX@4"
dJointGetHingeAxisY#(joint%):"_KODE_dJointGetHingeAxisY@4"
dJointGetHingeAxisZ#(joint%):"_KODE_dJointGetHingeAxisZ@4"
dJointGetHingeAngle#(joint%):"_KODE_dJointGetHingeAngle@4"
dJointGetHingeAngleRate#(joint%):"_KODE_dJointGetHingeAngleRate@4"
dJointSetSliderAxis(joint%, x#, y#, z#):"_KODE_dJointSetSliderAxis@16"
dJointGetSliderAxisX#(joint%):"_KODE_dJointGetSliderAxisX@4"
dJointGetSliderAxisY#(joint%):"_KODE_dJointGetSliderAxisY@4"
dJointGetSliderAxisZ#(joint%):"_KODE_dJointGetSliderAxisZ@4"
dJointGetSliderPosition#(joint%):"_KODE_dJointGetSliderPosition@4"
dJointGetSliderPositionRate#(joint%):"_KODE_dJointGetSliderPositionRate@4"
dJointSetUniversalAnchor(joint%, x#, y#, z#):"_KODE_dJointSetUniversalAnchor@16"
dJointSetUniversalAxis1(joint%, x#, y#, z#):"_KODE_dJointSetUniversalAxis1@16"
dJointSetUniversalAxis2(joint%, x#, y#, z#):"_KODE_dJointSetUniversalAxis2@16"
dJointGetUniversalAnchorX#(joint%):"_KODE_dJointGetUniversalAnchorX@4"
dJointGetUniversalAnchorY#(joint%):"_KODE_dJointGetUniversalAnchorY@4"
dJointGetUniversalAnchorZ#(joint%):"_KODE_dJointGetUniversalAnchorZ@4"
dJointGetUniversalAnchor2X#(joint%):"_KODE_dJointGetUniversalAnchor2X@4"
dJointGetUniversalAnchor2Y#(joint%):"_KODE_dJointGetUniversalAnchor2Y@4"
dJointGetUniversalAnchor2Z#(joint%):"_KODE_dJointGetUniversalAnchor2Z@4"
dJointGetUniversalAxis1X#(joint%):"_KODE_dJointGetUniversalAxis1X@4"
dJointGetUniversalAxis1Y#(joint%):"_KODE_dJointGetUniversalAxis1Y@4"
dJointGetUniversalAxis1Z#(joint%):"_KODE_dJointGetUniversalAxis1Z@4"
dJointGetUniversalAxis2X#(joint%):"_KODE_dJointGetUniversalAxis2X@4"
dJointGetUniversalAxis2Y#(joint%):"_KODE_dJointGetUniversalAxis2Y@4"
dJointGetUniversalAxis2Z#(joint%):"_KODE_dJointGetUniversalAxis2Z@4"
dJointSetHinge2Anchor(joint%, x#, y#, z#):"_KODE_dJointSetHinge2Anchor@16"
dJointSetHinge2Axis1(joint%, x#, y#, z#):"_KODE_dJointSetHinge2Axis1@16"
dJointSetHinge2Axis2(joint%, x#, y#, z#):"_KODE_dJointSetHinge2Axis2@16"
dJointGetHinge2AnchorX#(joint%):"_KODE_dJointGetHinge2AnchorX@4"
dJointGetHinge2AnchorY#(joint%):"_KODE_dJointGetHinge2AnchorY@4"
dJointGetHinge2AnchorZ#(joint%):"_KODE_dJointGetHinge2AnchorZ@4"

dJointGetHinge2Anchor2X#(joint%):"_KODE_dJointGetHinge2Anchor2X@4"
dJointGetHinge2Anchor2Y#(joint%):"_KODE_dJointGetHinge2Anchor2Y@4"
dJointGetHinge2Anchor2Z#(joint%):"_KODE_dJointGetHinge2Anchor2Z@4"
dJointGetHinge2Axis1X#(joint%):"_KODE_dJointGetHinge2Axis1X@4"
dJointGetHinge2Axis1Y#(joint%):"_KODE_dJointGetHinge2Axis1Y@4"
dJointGetHinge2Axis1Z#(joint%):"_KODE_dJointGetHinge2Axis1Z@4"
dJointGetHinge2Axis2X#(joint%):"_KODE_dJointGetHinge2Axis2X@4"
dJointGetHinge2Axis2Y#(joint%):"_KODE_dJointGetHinge2Axis2Y@4"
dJointGetHinge2Axis2Z#(joint%):"_KODE_dJointGetHinge2Axis2Z@4"
dJointGetHinge2Angle1#(joint%):"_KODE_dJointGetHinge2Angle1@4"
dJointGetHinge2Angle1Rate#(joint%):"_KODE_dJointGetHinge2Angle1Rate@4"
dJointGetHinge2Angle2Rate#(joint%):"_KODE_dJointGetHinge2Angle2Rate@4"
dJointSetFixed(joint%):"_KODE_dJointSetFixed@4"
dJointSetAMotorMode(joint%, mode%):"_KODE_dJointSetAMotorMode@8"
dJointGetAMotorMode%(joint%):"_KODE_dJointGetAMotorMode@4"
dJointSetAMotorNumAxes(joint%, num%):"_KODE_dJointSetAMotorNumAxes@8"
dJointGetAMotorNumAxes%(joint%):"_KODE_dJointGetAMotorNumAxes@4"
dJointSetAMotorAxis(joint%, anum%, rel%, x#, y#, z#):"_KODE_dJointSetAMotorAxis@24"
dJointGetAMotorAxisX#(joint%, anum%):"_KODE_dJointGetAMotorAxisX@8"
dJointGetAMotorAxisY#(joint%, anum%):"_KODE_dJointGetAMotorAxisY@8"
dJointGetAMotorAxisZ#(joint%, anum%):"_KODE_dJointGetAMotorAxisZ@8"
dJointGetAMotorAxisRel%(joint%, anum%):"_KODE_dJointGetAMotorAxisRel@8"
dJointSetAMotorAngle(joint%, anum%, angle#):"_KODE_dJointSetAMotorAngle@12"
dJointGetAMotorAngle#(joint%, anum%):"_KODE_dJointGetAMotorAngle@8"
dJointGetAMotorAngleRate#(joint%, anum%):"_KODE_dJointGetAMotorAngleRate@8"
dJointSetHingeParam(joint%, parameter%, value#):"_KODE_dJointSetHingeParam@12"
dJointSetSliderParam(joint%, parameter%, value#):"_KODE_dJointSetSliderParam@12"
dJointSetHinge2Param(joint%, parameter%, value#):"_KODE_dJointSetHinge2Param@12"
dJointSetUniversalParam(joint%, parameter%, value#):"_KODE_dJointSetUniversalParam@12"
dJointSetAMotorParam(joint%, parameter%, value#):"_KODE_dJointSetAMotorParam@12"
dJointGetHingeParam#(joint%, parameter%):"_KODE_dJointGetHingeParam@8"
dJointGetSliderParam#(joint%, parameter%):"_KODE_dJointGetSliderParam@8"
dJointGetHinge2Param#(joint%, parameter%):"_KODE_dJointGetHinge2Param@8"
dJointGetUniversalParam#(joint%, parameter%):"_KODE_dJointGetUniversalParam@8"
dJointGetAMotorParam#(joint%, parameter%):"_KODE_dJointGetAMotorParam@8"
dJointAddHingeTorque(joint%, torque#):"_KODE_dJointAddHingeTorque@8"
dJointAddUniversalTorques(joint%, torque1#, torque2#):"_KODE_dJointAddUniversalTorques@12"
dJointAddSliderForce(joint%, force#):"_KODE_dJointAddSliderForce@8"
dJointAddHinge2Torques(joint%, torque1#, torque2#):"_KODE_dJointAddHinge2Torques@12"
dJointAddAMotorTorques(joint%, torque0#, torque1#, torque2#):"_KODE_dJointAddAMotorTorques@16"
dGeomDestroy(geom%):"_KODE_dGeomDestroy@4"
dGeomSetBody(geom%, body%):"_KODE_dGeomSetBody@8"
dGeomSetPosition(geom%, x#, y#, z#):"_KODE_dGeomSetPosition@16"
dGeomSetRotation(geom%, x#, y#, z#):"_KODE_dGeomSetRotation@16"
dGeomGetPositionX#(geom%):"_KODE_dGeomGetPositionX@4"
dGeomGetPositionY#(geom%):"_KODE_dGeomGetPositionY@4"
dGeomGetPositionZ#(geom%):"_KODE_dGeomGetPositionZ@4"
dGeomGetPitch#(geom%):"_KODE_dGeomGetPitch@4"
dGeomGetYaw#(geom%):"_KODE_dGeomGetYaw@4"
dGeomGetRoll#(geom%):"_KODE_dGeomGetRoll@4"
dHashSpaceCreate%(space%):"_KODE_dHashSpaceCreate@4"
dSimpleSpaceCreate%(space%):"_KODE_dSimpleSpaceCreate@4"
dSpaceSetCleanup(space%, mode%):"_KODE_dSpaceSetCleanup@8"
dSpaceAdd(space%, geom%):"_KODE_dSpaceAdd@8"
dSpaceRemove(space%, geom%):"_KODE_dSpaceRemove@8"
dCreateBox%(space%, width#, height#, depth#):"_KODE_dCreateBox@16"
dCreateSphere%(space%, radius#):"_KODE_dCreateSphere@8"
dCreateCCylinder%(space%, radius#, height#):"_KODE_dCreateCCylinder@12"
dGeomTriMeshDataCreate%():"_KODE_dGeomTriMeshDataCreate@0"
dGeomTriMeshDataDestroy(data%):"_KODE_dGeomTriMeshDataDestroy@4"
dGeomTriMeshDataBuildSimple(data%, Vertices*, VertexCount%, Indices*, IndexCount%):"_KODE_dGeomTriMeshDataBuildSimple@20"
dCreateTriMesh%(space%, data%):"_KODE_dCreateTriMesh@8"

;GEOM TRANSFORM
dCreateGeomTransform%(space%):"_KODE_dCreateGeomTransform@4"
dGeomTransformSetGeom(geom%, geomobj%):"_KODE_dGeomTransformSetGeom@8"
dGeomTransformGetGeom%(geom%):"_KODE_dGeomTransformGetGeom@4"
dGeomTransformSetCleanup(geom%,mode%):"_KODE_dGeomTransformSetCleanup@8"
dGeomTransformGetCleanup%(geom%):"_KODE_dGeomTransformGetCleanup@4"
dGeomTransformSetInfo(geom%,mode%):"_KODE_dGeomTransformSetInfo@8"
dGeomTransformGetInfo%(geom%):"_KODE_dGeomTransformGetInfo@4"

;MASAS TOTALES
dBodySetBoxMass(body%,lx#,ly#,lz#,mass#):"_KODE_dBodySetBoxMass@20"
dBodySetSphereMass(body%,r#,mass#):"_KODE_dBodySetSphereMass@12"
dBodySetCCylinderMass(body%,r#,h#,mass#):"_KODE_dBodySetCCylinderMass@16"
dBodySetCylinderMass(body%,r#,h#,mass#):"_KODE_dBodySetCylinderMass@16"

;MASAS DENSIDADES
dBodySetBoxMassDensity(body%,lx#,ly#,lz#,mass#):"_KODE_dBodySetBoxMassDensity@20"
dBodySetSphereMassDensity(body%,r#,mass#):"_KODE_dBodySetSphereMassDensity@12"
dBodySetCCylinderMassDensity(body%,r#,h#,mass#):"_KODE_dBodySetCCylinderMassDensity@16"
dBodySetCylinderMassDensity(body%,r#,h#,mass#):"_KODE_dBodySetCylinderMassDensity@16"

;OBTENER COLISION CON TRIMESH Y BODY
dBodyGetIfCollisionBody%(body%):"_KODE_dBodyGetIfCollisionBody@4"
dBodyGetCollisionTriMesh%(body%):"_KODE_dBodyGetCollisionTriMesh@4"
dBodyGetCollisionTriMeshX#(body%):"_KODE_dBodyGetCollisionTriMeshX@4"
dBodyGetCollisionTriMeshY#(body%):"_KODE_dBodyGetCollisionTriMeshY@4"
dBodyGetCollisionTriMeshZ#(body%):"_KODE_dBodyGetCollisionTriMeshZ@4"

;RAY GEOM
dCreateRay%(space%,length#):"_KODE_dCreateRay@8"
dGeomRaySetLength(ray%,length#):"_KODE_dGeomRaySetLength@8"
dGeomRayGetLength#(ray%):"_KODE_dGeomRayGetLength@4"
dGeomRaySet(ray%,px#,py#,pz#,dx#,dy#,dz#):"_KODE_dGeomRaySet@28"
dGeomRayGetPX#(ray%):"_KODE_dGeomRayGetPX@4"
dGeomRayGetPY#(ray%):"_KODE_dGeomRayGetPY@4"
dGeomRayGetPZ#(ray%):"_KODE_dGeomRayGetPZ@4"
dGeomRayGetDX#(ray%):"_KODE_dGeomRayGetDX@4"
dGeomRayGetDY#(ray%):"_KODE_dGeomRayGetDY@4"
dGeomRayGetDZ#(ray%):"_KODE_dGeomRayGetDZ@4"

dGeomGetCollisionsCount%(geom%):"_KODE_dGeomGetCollisionsCount@4"
dGeomGetCollisionX#(geom%, num%):"_KODE_dGeomGetCollisionX@8"
dGeomGetCollisionY#(geom%, num%):"_KODE_dGeomGetCollisionY@8"
dGeomGetCollisionZ#(geom%, num%):"_KODE_dGeomGetCollisionZ@8"

;SpaceCollide2 Solo para Rays (Bueno luego para cualquier geom)
dSpaceCollide2(g1%,g2%):"_KODE_dSpaceCollide2@8"

;QUATERNIONS
dBodyGetQuaternionS#(body%):"_KODE_dBodyGetQuaternionS@4"
dBodyGetQuaternionX#(body%):"_KODE_dBodyGetQuaternionX@4"
dBodyGetQuaternionY#(body%):"_KODE_dBodyGetQuaternionY@4"
dBodyGetQuaternionZ#(body%):"_KODE_dBodyGetQuaternionZ@4"
dBodySetQuaternion(body%,s#,x#,y#,z#):"_KODE_dBodySetQuaternion@20"

;PARAMETROS DE SUPERFICIE DE CADA BODY
dBodySetSurfaceMu(body%,mu#):"_KODE_dBodySetSurfaceMu@8"
dBodySetSurfaceSlip1(body%,slip1#):"_KODE_dBodySetSurfaceSlip1@8"
dBodySetSurfaceSlip2(body%,slip2#):"_KODE_dBodySetSurfaceSlip2@8"
dBodySetSurfaceBounce(body%,bounce#):"_KODE_dBodySetSurfaceBounce@8"

;GROUPID - Los Bodies del mismo GROUPID NO COLISIONAN
dBodySetGroupID(body%,groupid%):"_KODE_dBodySetGroupID@8"

;DISABLECOLLISIONBODY
dBodySetDisableBodyCollision(body%,status%):"_KODE_dBodySetDisableBodyCollision@8"

;CREATEPLANE
dCreatePlane%(space%, a#,b#,c#,d#):"_KODE_dCreatePlane@20"

;CREATE CYLINDER
dCreateCylinder%(space%, radius#, height#):"_KODE_dCreateCylinder@12"

Thanks again for your kind words. I forgot to mention that the color picker allows you to change the entity color, so the mesh,geom and entity has that color.

When you select an entity it becomes RED automatically, so if you change its color please unselected it to see the result.

KODE Editor Source is not available to customers, sorry for that. I am thinking in releasing the KODEPLAYER source, although it is very similar to the exported code + mesh picker.

You have posted the userlib without the KODE prefix, with is good. Now, when exporting, you only need to make a REPLACE (KODE_ for ""). Anyway, if you buy it, i will add a menu option to export without prefixes, ok?

Cheers, KuRi.

I'm ok with the entity colors.

I was looking thru the decls and saw a few things:

I didn't see this in the ODE documentation, what is it?
;GROUPID - Los Bodies del mismo GROUPID NO COLISIONAN
dBodySetGroupID(body%,groupid%):"_KODE_dBodySetGroupID@8"

This function seems to be missing (maybe not required):
dJointGroupID dJointGroupCreate (int max_size);

Create a joint group. The max_size argument is now unused and should be set to 0. It is kept for backwards compatibility.

Can you add a get version function call?
dGetVersion#()

"if you buy it, i will add a menu option to export without prefixes, ok?"

Yeah, let user choose a prefix or none at all, and set the default as KODE_.

I'll finish looking it over and see if I have any more questions, and be ready to purchase in couple of hours.

Sample export code be nice.
KODEPLAYER source would get people up to speed faster, so I hope you include it.

Thanks

KODE Editor Issues:

1. File, Load causes a dialog box indicating a path error when running under windows 98. Dialog box title 'Select Kode File to Load'. Path shown says: 'E:\New_DownLoads\kodedemo10\Kdemo10 is not accessible. This folder was moved or removed, OK'

Hitting Ok causes normal windows file dialog to appear, and selecting tutorial file from this dialog works as expected.

This is pretty annoying as Kode doesn't appear to know it's path. This could be a B3D long file path error that some people ignore or deny.

2. Pressing esc ends the editor without warning! Ending the simulation window with esc seems ok.

3. The dll step limit of 1000 is way too short, I'd like it too run for two minutes ( aprox 15,000 ). I like to pull stuff around.

4. Loading the vehicle I find it's chassis appears to be made of two blocks, but can't select the blocks seperatly. What if I don't want the second one ? How did it get there ?

-Update-
ODE properties, defines the body and the geoms attached to it. I saw some Basic ODE documentation on the web that defines this relationship clearly. I'm ok with it now.

5. Selecting entities with the mouse is nice, but I expected the entity name textbox to be a combo box so I could select from and available list.

Entities get in the way of each other, perhaps a layer system would help. Something so I can hide entities while working with others.

6. Examing wheel2, edit ode properties, shows body with cylinder checked, but Geom tab shows sphere! Is it just me or is that confusing!?

7. Simulation window has no camera zoom.

8. No graphics mode settings for KODE, or simulation window. I like full screen at times.

Pretty good first effort, needs some polish, and I still like it.

8)

Hi Kurix - still bit behind testing the full KODE, but few notes:

-Spanish-ism could be still reduced... BlitzKODE.decls for example is full of descriptions like ";MASAS DENSIDADES" which can be understud when you check the actual ODE function below, but since the explanation is meant to help and easily identfyi the ODE function in question it would be better to use english.

-Can we get some sort of "project" based settings? These would work so that when I save my "project" settings it would save every setup values from the "KODE config" window like ODE initialization values and all the export / import directories used. This would help to jump quickly between several WIP projects that are on different hard drives etc.

-"Automagic" ragdoll would be nice: you just load a boned mesh and KODE would automatically go through the bone chain and add (correct lenght and orientation) ODE entity... it could ask from the user during the creation what kind of entity is wanted (box, ball) and so on. Idea would be of course to make physics objects for boned chracters easily.

It would be nice to have also somekind of .bb demo for paying customers how to swap ragdoll in place of the normal animated entity (matching the limb orientations to the animation frame at that time of course)... like having a walking boned man/monster (pre-animated) that can be turned into ODE ragdoll whenever the user wants... I think that is the purpose of KODE ragdolls for most potential customers anyway?

Woww, lets give answers now!!!

FOR WAYNE:

- I don't have windows 98, so i don't know how to fix that :(

- I will ask when the user press esc, thanks for that.ç

- You can select you entity from a list if you use the menu Edit -> Search Entity. Anyway i will add a freeze Selection button.

- The body properties are basically the mass properties. So a wheel has Cylinder Mass Properties, Sphere Geom Properties, and Cylinder Mesh Properties. (This is the best aproximation so far)

- Changing to full screen when using GUI's is very difficult, cause they are static sized. I will add an option to use KODEPLAYER in Full Screen

FOR MUSTANG:
- Changing Userlibs to only English Now, i will send you later. Thanks.

- When you save a .kode you have all ODE Settings Saved, including perspective camera position.

- The automatic Ragdoll is something i am working on. The problem is that i can't get a good exporter from 3dsmax to b3d because 3dsmax has different rotation system, so i can't assign them automatically. Working on it anyway.

Thanks for all, Cheers, KuRiX.

Yes automagic ragdoll will be very usefull.
Try B3dPipeline exporter.
And when ShareIt will be available? I can't pay throught PayPal.

I have tried b3dpipeline. The rotation problem comes from 3dsmax. In 3dsmax, the bones, when rotated at 0,0,0 ar facing to the right :(

Registering with shareit now... will be available today (i hope)...

I am working on the 1.03 version. It will available later today. It has some bugs corrected and some new features. People are liking KODE. Thanks for your support!

EDIT:
OK People, SHAREIT Registered, but they activate accounts in 48h, so it will be available soon!.

Automatic Ragdolls: Please explain this more. Let's make som kind of standard, for example: all ragdolls with n Bodies, and m Joints. The name of the body1 will be "head", and so. Then in KODE when loading such models the ragdoll can be automatically created!

That won't work... some monsters for example have tail, wings or four arms, and even how ppl rig humans is not constant; some need fingers some don't, and so on... automagic to me would be reading in / parsing the bone info from the loaded (boned) mesh and asking what kind of limb it (bone from the bone hierachy) is and what kind of joint is wanted for that position.

Well maybe some name prefixes could be used as default values/choices like if the bone has "head" string in it KODE would suggest sphere/ball (diameter = bone lenght) and likewise "arm" or "leg" would use either box or cylinder (lenght = bone lenght, diameter user definable).

For the Bodies there are not problems. The difficult is with the joints. In bones animation, the joint is a point between two bones, but it is not an entity. So how we know when to create joints, where, and what rotation?

Wow, lot of posts in short time! Good to see you answereing them all KuRiX - this gives me great confidence in the future of KODE, I am 90% convinced to buy :)

A suggestion to people - read the ODE documentation ;) Here is a link to the ODE manual. Some stuff is irrelevant to wrapper, but 70% of manual is very useful. All the commands are explained.

http://ode.org/ode-docs.html


For me, the essential part of KODE is a 'stable' ODE wrapper for Blitz. I know this is cheeky, but can anyone compare KODE wrapper to previous ODE wrappers and also to Tokamak? ODE itself seems superior to Tokamak, but Tokamak wrapper has been the most stable for me so far.


I hope you are writing this stuff down KuRiX, because here come some more suggestions!! Very good work though, well done :)

WRAPPER
1) Keep wrapper up to date and above all STABLE ;)

2) Do you plan on implementing QuadTree spaces?

EDITOR
3) As mentioned, need more resolutions supported. The editor window is quite small on 1280 x 960 screen! I know scaling GUI's can be tricky, but personaly I would rather have larger window (fullscreen) and some 'empty space' where GUI used to be ie. don't worry too much about scaling it all properly. You could always say 'resoltion not officaily supported' or something ;)

4) Zoom Extents All/Selected would be VERY nice.

5) Option to 'Disable all joints/bodies' would be handy. Then you can easily enable one or two for testing a certain part of a model. Ofc, need option to enable all of them again.

6) Maybe configurable 'mouse sensitivity' for each operation? I find rotating camera is way too slow. Also, how do other editors work, do they 'speed up' as you zoom out?? Not exactly sure what I am asking here, just found it a bit slow to move around at times! The zoom extents would help ofc.

7) The .bb exporter is cool, but really need a .kode importer for blitz or something. Basicaly, so you can import a model and its physics - like using Pipeline for example. I understand ODE uses global coords for positioning joints, but the way I see an editor being used is to export physics for various models then import them one at a time (at 0,0,0), move to corrct world position, then import next model and physics etc.

8) Automating stuff is great :)

Rhy :o)

About positioning bone joints from MAX, here are a few suggestions which might or might not work.

1) Joints occur only 'between' bones, never at chain ends.

2) Joint is positioned at bone start location and rotated to face start of next bone (ie. the next joint).

3) I think max bones use relative coords, so u need to position/rotate bones based on previous bone.

4) You would have to enforce some standards, such as single chain skeletons only.

Perhaps just place a ball&pivot joint at each bone intersection then allow user to modify. Perhaps include some default joint types such as 'Elbow', 'Wrist' etc that user can choose from. This way, KODE places joints in correct positions then user can change 'ball&socket' joints to the correct joint (using one of the predefined joints where suitable).

Consider using other editors/methods as well as MAX bones, not everyone can afford MAX!

Rhy :)

"Changing to full screen when using GUI's is very difficult, cause they are static sized. I will add an option to use KODEPLAYER in Full Screen"

The KODE Editor window size is too small, please allow user to change the window size. My current desktop is 1280x1024. Is KODE set at 1024x768 ?


8)

Concerning editor screen size (again!).

Perhaps exclude your four cameras from the GUI itself so you can scale them seperatly using CameraViewport and 'select' them by checking mouse position (rather than current checkbox method). Then just position rest of GUI at edge of screen based on its width and 0,0 or using GraphicsWidth()/2 etc. Forget about making GUI 'fill the screen' properly, just leave an empty space if GUI only takes up half the screen height and say 'not offficialy supported'.

Maybe you would need to use a different GUI library for this - dunno. Just suggestions anyway ;)

Rhy :)

Oh my god, this is growing too fast!. I take note of all. I see that the GUI size is the main feature you need to be improved. I will work hard on it, ok?.

Now please give me some time to include lot of things people are asking. I will be sending new versions / updating demo as soon as possible. Of course i will tell you here when this occurs!

Thanks All.
Best Regards, KuRi.

P.D: Wayne, i didn't see you post about GROUPID function. It is not an ODE function. It is an extra feature i have added to the Wrapper. There is now a BlitzKODE.decls update with english version. I will update the demo to the version 1.03 with this .decls

Do customers receive the download at the point of purchase ?
Any really annoying bugs or limits we should be aware of ?

-Wayne

I could be semi-automatic, user assisted process... KODE parses through the boned model, comes across a bone named "whatever", and asks the user (using checkboxes or something similar) if there should be a joint in a, b or a+b (a being start of the bone, b the end) and below that what type, and depending the type what rotation axis to have. Same type of thing could be used for bone properties... and with few clicks you have a perfect KODE physics object ready for .bb exporting no matter how many arms it has!

KuRiX, never intended my suggestions to be demands. Don't burn yourself out, just make yourself a development plan and do what you can ;)

Wayne - to save KuRiX some time, I suggest checking out ODE itself for any limitations/bugs. Their are a few things which the author of ODE mentions to watch for, such as joints between bodies which have very dissimiliar masses. These are NOTHING to do with KODE, but limitations of ODE itself. Also, do not regard limitations as bugs - you would pay a LOT more for top end physics engines. As far as I can see, KODE offers 95% (or more) of the ODE command set and have not heard of any stability problems with the wrapper so far.

Not to mention that those big physics engines are hardly bug fee either... things I could tell without my NDAs... sometimes bugs and official suggested ways to get around them (because they can't fix them) makes me just laugh :)

Thanks again Friends.

WAYNE: The only bug i have been reported by now is about the bb exporter and it is fixed already, but i have not sent the patch yet, cause i am adding some little interesting features.

Here in Spain we are at 19:56 afternoon. Tonight (about eleven) i plan to have the demo upgraded to 1.03 and the 1.03 patch sent to customers ;)

Do customers receive the download at the point of purchase ?

/Alienforce

Hehe Mustang ;)

Hmmm, am I missing something with the .bb export of KODE? I have not purchased KODE yet and therefore have not seen any examples of bb code. Does the .bb export use some kind of import routine for loading the physics models rather than it being 'hard coded'? This would be a big plus for buying.

Rhy

ALIEN: Well, i check my email every hour, so you should receive it as soon as possible (it this is what you ask). So the sent is not automatic, i send the full version and future updates via email.

The exporter gives you a WYSIWYG .bb file. This is, the result is exact the same as the kodeplayer just exporting and compiling directly. I dont understand what you mean with "hard coded". The .bb file is ALL BlitzBasic + BlitzKODE.dll Commands.

Ok, here it is, a .bb exported sample file for vehicle.kode:

;---------------------------------------------------------------------------------
;BLITZBASIC [K]ODE FILE
;EXPORTED BY [K]ODE VERSION: 1.00
;You Will need the BlitzKODE.dll and the BlitzKODE.decls in your userlibs folder
;---------------------------------------------------------------------------------

Include "BlitzKODE.bb"
AppTitle "KODE BB FILE"

;GRAPHICS
Graphics3D 640,480,16,2
SetBuffer BackBuffer()
SeedRnd MilliSecs()

;ENTITIES
Dim Bodies(1000)
Dim Geoms(1000,1000)
Dim Meshes(1000,1000)
Dim Joints(1000)
;CAMERA
Camera = CreateCamera()
PositionEntity Camera,-314.32,71.4534,302.477
RotateEntity Camera,3.1,-117,0.0
CameraClsColor Camera,255,255,255

;LIGHT
light = CreateLight(2)
PositionEntity light,0,500,0
LightColor light,100,100,100
AmbientLight 100,100,100

;ODE INITIALIZATION
space = KODE_dWorldCreate(0)
KODE_dWorldSetGravity(0.0,-1.5,0.0)
KODE_dWorldSetERP 0.5
KODE_dWorldSetCFM 0.00001
KODE_dWorldSetContactSurfaceLayer (0.0)
KODE_dWorldSetQuickStepNumIterations(20)
KODE_dWorldSetAutoDisableFlag(0)

;DEFAULT CONTACT DATA
KODE_dSetMU(0.5)
KODE_dSetBOUNCE(0.1)
KODE_dSetBOUNCE_VEL(10.0)
KODE_dSetSOFT_ERP(0.5)
KODE_dSetSOFT_CFM(0.00001)
KODE_dSetSLIP1(0.001)
KODE_dSetSLIP2(0.001)

;ODE CREATION

;Entity: chassis
Bodies(27) = KODE_dBodyCreate()
KODE_dBodySetBoxMass(Bodies(27),70.0,20.0,120.0,120.0)
KODE_dBodySetPosition(Bodies(27),-16.9311,49.3359,-12.0415)
KODE_dBodySetRotation(Bodies(27),0.0,0.0,0.0)
Geoms(27,1) = KODE_dCreateBox(space,70.0,20.0,120.0)
KODE_dGeomSetBody Geoms(27,1),Bodies(27)
Geoms(27,2) = KODE_dCreateGeomTransform(space)
KODE_dGeomTransformSetCleanup(Geoms(27,2),1)
temp  = KODE_dCreateBox(0,40.0,20.0,80.0)
KODE_dGeomSetPosition temp,0.0,20.0,0.0
KODE_dGeomSetRotation temp,0.0,0.0,0.0
KODE_dGeomTransformSetGeom(Geoms(27,2),temp)
KODE_dGeomTransformSetInfo(Geoms(27,2),1)
KODE_dGeomSetBody Geoms(27,2),Bodies(27)
Meshes(27,1) = CreateCube()
FitMesh Meshes(27,1),-0.5,-0.5,-0.5,1,1,1
EntityColor Meshes(27,1),0,20,64
ScaleMesh Meshes(27,1),70.0,20.0,120.0
PositionMesh Meshes(27,1),0.0,0.0,0.0
RotateMesh Meshes(27,1),0.0,0.0,0.0
PositionEntity Meshes(27,1),-16.9311,49.3359,-12.0415
RotateEntity Meshes(27,1),0.0,0.0,0.0
Meshes(27,2) = CreateCube()
FitMesh Meshes(27,2),-0.5,-0.5,-0.5,1,1,1
EntityColor Meshes(27,2),0,20,64
ScaleMesh Meshes(27,2),40.0,20.0,80.0
PositionMesh Meshes(27,2),0.0,20.0,0.0
RotateMesh Meshes(27,2),0.0,0.0,0.0
PositionEntity Meshes(27,2),-16.9311,49.3359,-12.0415
RotateEntity Meshes(27,2),0.0,0.0,0.0

;Entity: wheel1
Bodies(28) = KODE_dBodyCreate()
KODE_dBodySetCylinderMass(Bodies(28),15.0,0.0,20.0)
KODE_dBodySetPosition(Bodies(28),-38.4365,37.0,31.4344)
KODE_dBodySetRotation(Bodies(28),0.0,0.0,0.0)
Geoms(28,1) = KODE_dCreateSphere(space,14.0)
KODE_dGeomSetBody Geoms(28,1),Bodies(28)
Meshes(28,1) = CreateCylinder(8)
FitMesh Meshes(28,1),-15.0,-5.0,-15.0,30.0,10.0,30.0
EntityColor Meshes(28,1),0,28,192
PositionMesh Meshes(28,1),0.0,0.0,0.0
RotateMesh Meshes(28,1),0.0,0.0,90.0
PositionEntity Meshes(28,1),-38.4365,37.0,31.4344
RotateEntity Meshes(28,1),0.0,0.0,0.0

;Entity: wheel4
Bodies(31) = KODE_dBodyCreate()
KODE_dBodySetCylinderMass(Bodies(31),15.0,0.0,20.0)
KODE_dBodySetPosition(Bodies(31),4.4863,37.0,-51.8248)
KODE_dBodySetRotation(Bodies(31),0.0,0.0,0.0)
Geoms(31,1) = KODE_dCreateSphere(space,14.0)
KODE_dGeomSetBody Geoms(31,1),Bodies(31)
Meshes(31,1) = CreateCylinder(8)
FitMesh Meshes(31,1),-15.0,-5.0,-15.0,30.0,10.0,30.0
EntityColor Meshes(31,1),0,28,192
PositionMesh Meshes(31,1),0.0,0.0,0.0
RotateMesh Meshes(31,1),0.0,0.0,90.0
PositionEntity Meshes(31,1),4.4863,37.0,-51.8248
RotateEntity Meshes(31,1),0.0,0.0,0.0

;Entity: wheel2
Bodies(32) = KODE_dBodyCreate()
KODE_dBodySetCylinderMass(Bodies(32),15.0,0.0,20.0)
KODE_dBodySetPosition(Bodies(32),6.03004,37.0,31.1949)
KODE_dBodySetRotation(Bodies(32),0.0,0.0,0.0)
Geoms(32,1) = KODE_dCreateSphere(space,14.0)
KODE_dGeomSetBody Geoms(32,1),Bodies(32)
Meshes(32,1) = CreateCylinder(8)
FitMesh Meshes(32,1),-15.0,-5.0,-15.0,30.0,10.0,30.0
EntityColor Meshes(32,1),0,28,192
PositionMesh Meshes(32,1),0.0,0.0,0.0
RotateMesh Meshes(32,1),0.0,0.0,90.0
PositionEntity Meshes(32,1),6.03004,37.0,31.1949
RotateEntity Meshes(32,1),0.0,0.0,0.0

;Entity: wheel3
Bodies(33) = KODE_dBodyCreate()
KODE_dBodySetCylinderMass(Bodies(33),15.0,0.0,20.0)
KODE_dBodySetPosition(Bodies(33),-40.0428,37.0,-51.9096)
KODE_dBodySetRotation(Bodies(33),0.0,0.0,0.0)
Geoms(33,1) = KODE_dCreateSphere(space,14.0)
KODE_dGeomSetBody Geoms(33,1),Bodies(33)
Meshes(33,1) = CreateCylinder(8)
FitMesh Meshes(33,1),-15.0,-5.0,-15.0,30.0,10.0,30.0
EntityColor Meshes(33,1),0,28,192
PositionMesh Meshes(33,1),0.0,0.0,0.0
RotateMesh Meshes(33,1),0.0,0.0,90.0
PositionEntity Meshes(33,1),-40.0428,37.0,-51.9096
RotateEntity Meshes(33,1),0.0,0.0,0.0

;Entity: FLOOR1
Geoms(65,1) = KODE_dCreateBox(space,400.0,1.0,400.0)
KODE_dGeomSetPosition Geoms(65,1),-31.5535,0.0,-8.30634
KODE_dGeomSetRotation Geoms(65,1),0.0,0,0.0
Meshes(65,1) = CreateCube()
FitMesh Meshes(65,1),-0.5,-0.5,-0.5,1,1,1
EntityColor Meshes(65,1),160,28,0
ScaleMesh Meshes(65,1),400.0,1.0,400.0
PositionMesh Meshes(65,1),0.0,0.0,0.0
RotateMesh Meshes(65,1),0.0,0.0,0.0
PositionEntity Meshes(65,1),-31.5535,0.0,-8.30634
RotateEntity Meshes(65,1),0.0,0.0,0.0

;Entity: FLOOR2
Geoms(66,1) = KODE_dCreateBox(space,400.0,1.0,400.0)
KODE_dGeomSetPosition Geoms(66,1),-31.5535,3.94791,269.795
KODE_dGeomSetRotation Geoms(66,1),0.0,0,0.0
Meshes(66,1) = CreateCube()
FitMesh Meshes(66,1),-0.5,-0.5,-0.5,1,1,1
EntityColor Meshes(66,1),160,28,0
ScaleMesh Meshes(66,1),400.0,1.0,400.0
PositionMesh Meshes(66,1),0.0,0.0,0.0
RotateMesh Meshes(66,1),0.0,0.0,0.0
PositionEntity Meshes(66,1),-31.5535,3.94791,269.795
RotateEntity Meshes(66,1),0.0,0.0,0.0

;Joint: joint1
Joints(34)= KODE_dJointCreateHinge2()
KODE_dJointAttach(Joints(34),Bodies(27),Bodies(28))
KODE_dJointSetHinge2Anchor(Joints(34),-38.4365,37.0,31.4344)
KODE_dJointSetHinge2Axis1(Joints(34),0.0,1.0,0.0)
KODE_dJointSetHinge2Axis2(Joints(34),-1.0,0.0,0.0000001)
KODE_dJointSetHinge2Param(Joints(34),dParamLoStop,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamHiStop,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamVel,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamVel2,600.0)
KODE_dJointSetHinge2Param(Joints(34),dParamFMax,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamFMax2,600.0)
KODE_dJointSetHinge2Param(Joints(34),dParamFudgeFactor,1.0)
KODE_dJointSetHinge2Param(Joints(34),dParamBounce,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamCFM,0.01)
KODE_dJointSetHinge2Param(Joints(34),dParamStopERP,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamStopCFM,0.0)
KODE_dJointSetHinge2Param(Joints(34),dParamSuspensionERP,0.5)
KODE_dJointSetHinge2Param(Joints(34),dParamSuspensionCFM,0.01)

;Joint: joint3
Joints(35)= KODE_dJointCreateHinge2()
KODE_dJointAttach(Joints(35),Bodies(27),Bodies(33))
KODE_dJointSetHinge2Anchor(Joints(35),-40.0428,37.0,-51.9096)
KODE_dJointSetHinge2Axis1(Joints(35),0.0,1.0,0.0)
KODE_dJointSetHinge2Axis2(Joints(35),-1.0,0.0,0.0000001)
KODE_dJointSetHinge2Param(Joints(35),dParamLoStop,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamHiStop,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamVel,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamVel2,600.0)
KODE_dJointSetHinge2Param(Joints(35),dParamFMax,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamFMax2,600.0)
KODE_dJointSetHinge2Param(Joints(35),dParamFudgeFactor,1.0)
KODE_dJointSetHinge2Param(Joints(35),dParamBounce,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamCFM,0.001)
KODE_dJointSetHinge2Param(Joints(35),dParamStopERP,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamStopCFM,0.0)
KODE_dJointSetHinge2Param(Joints(35),dParamSuspensionERP,0.5)
KODE_dJointSetHinge2Param(Joints(35),dParamSuspensionCFM,0.01)

;Joint: joint2
Joints(36)= KODE_dJointCreateHinge2()
KODE_dJointAttach(Joints(36),Bodies(27),Bodies(32))
KODE_dJointSetHinge2Anchor(Joints(36),5.47029,37.0,31.1949)
KODE_dJointSetHinge2Axis1(Joints(36),0.0,1.0,0.0)
KODE_dJointSetHinge2Axis2(Joints(36),-1.0,0.0,0.0000001)
KODE_dJointSetHinge2Param(Joints(36),dParamLoStop,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamHiStop,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamVel,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamVel2,600.0)
KODE_dJointSetHinge2Param(Joints(36),dParamFMax,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamFMax2,600.0)
KODE_dJointSetHinge2Param(Joints(36),dParamFudgeFactor,1.0)
KODE_dJointSetHinge2Param(Joints(36),dParamBounce,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamCFM,0.01)
KODE_dJointSetHinge2Param(Joints(36),dParamStopERP,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamStopCFM,0.0)
KODE_dJointSetHinge2Param(Joints(36),dParamSuspensionERP,0.5)
KODE_dJointSetHinge2Param(Joints(36),dParamSuspensionCFM,0.01)

;Joint: joint4
Joints(37)= KODE_dJointCreateHinge2()
KODE_dJointAttach(Joints(37),Bodies(27),Bodies(31))
KODE_dJointSetHinge2Anchor(Joints(37),4.4863,37.0,-51.8248)
KODE_dJointSetHinge2Axis1(Joints(37),0.0,1.0,0.0)
KODE_dJointSetHinge2Axis2(Joints(37),-1.0,0.0,0.0000001)
KODE_dJointSetHinge2Param(Joints(37),dParamLoStop,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamHiStop,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamVel,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamVel2,600.0)
KODE_dJointSetHinge2Param(Joints(37),dParamFMax,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamFMax2,600.0)
KODE_dJointSetHinge2Param(Joints(37),dParamFudgeFactor,1.0)
KODE_dJointSetHinge2Param(Joints(37),dParamBounce,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamCFM,0.01)
KODE_dJointSetHinge2Param(Joints(37),dParamStopERP,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamStopCFM,0.0)
KODE_dJointSetHinge2Param(Joints(37),dParamSuspensionERP,0.5)
KODE_dJointSetHinge2Param(Joints(37),dParamSuspensionCFM,0.01)

;MAIN LOOP
while (not keyhit(1))
KODE_dWorldQuickStep 0.1
For i=1 to 1000
	If (Bodies(i)<>0)
		For j=1 to 1000
			If (Meshes(i,j)<>0)
				PositionEntity Meshes(i,j),KODE_dBodyGetPositionX(Bodies(i)),KODE_dBodyGetPositionY(Bodies(i)),KODE_dBodyGetPositionZ(Bodies(i))
				RotateEntity Meshes(i,j),KODE_dBodyGetPitch(Bodies(i)),KODE_dBodyGetYaw(Bodies(i)),KODE_dBodyGetRoll(Bodies(i))
			EndIf
		Next
		;LINEAR AND ANGULAR DUMPING
		dump# = 0.99
		ax# = KODE_dBodyGetAngularVelX(Bodies(i))
		ay# = KODE_dBodyGetAngularVelY(Bodies(i))
		az# = KODE_dBodyGetAngularVelZ(Bodies(i))
		KODE_dBodySetAngularVel(Bodies(i),ax#*dump#,ay#*dump#,az#*dump#)
	EndIf
Next

;RenderWorld
RenderWorld()

Flip
Wend

;CLOSE ODE AND END
KODE_dWorldDestroy()
KODE_dCloseODE()
End

I see, thanks for answering that KuRiX - you must spend longer answering forum posts than coding atm!! ;)

Could you consider (put on your 'to do' list) writing an importer. So, for example, it would allow you to load a .kode file from within blitz (in the same way as the editor I expect).

I guess you could 'break up' your exported .bb code and create functions for each model, but an importer would be much nicer :)

Thanks,
Rhy :)

KODEPLAYER uses an importer for .kode files. The routine is already programmed, only it is not public source. It uses the types structures of the editor.

P.D: Look up, i have posted a .bb sample of the exporter!

Ok, I'm sold! The code generator will save me time as I setup more complex models. Working Trimesh is nice too. Keep up the good work.

Buying it now.

How about and English option on the buy page ?

Hey people, there is an option in Blitz so all the graphics in the window get scaled to the size of the window.

Graphics3D SX,SY,DEPTH,3

The option 3 is a scaled window. I know this is not the best way, because the resolution is not increased, but at least you will work in full screen. Do you want me to activate an option to do it?

EDIT: The problem is that if i change kode editor to full screen when running simulations problems occur...

I'd like to try the scaled windows option.

Can you add English version of your PAYPAL web page ?

Is it in Spanish? It should be different for every zone. Checking it now...

It's in Spanish.

Can you test it again, please?

yes! it's fixed now.
Thanks KuRix

I just got the PayPal confirmation. yay!
Keep the email running in the background and don't fall asleep. 8)

Sending Full Version to Wayne now!!!
Thanks for Buying!

P.D: don't Forget to check your emails in two hours, version 1.03 coming!

In the 1.02 version the plane object is bad exported, so be patient, it is already corrected!

Will I be able to load a blitz 3d model, have it display as semi transparent, and use it as a template to map out my ode primatives in KODE ? That sound possible?

At the beginning all models were semitransparent in editor. In fact, all primitives meshes are semitransparents.

Do you want semitransparent blitz 3d models? you will have it in V1.03. And i haven't forgotten your "Export without prefix request"! xDDD

Thank you sir

Version 1.03 Sent to All. Check your emails. Now i am packing the 1.03 Demo Version!

Code Export:

;MAIN LOOP
while (not keyhit(1))
KODE_dWorldQuickStep 0.1
For i=1 to 1000
	If (Bodies(i)<>0)
		For j=1 to 1000
			If (Meshes(i,j)<>0)
				PositionEntity Meshes(i,j),KODE_dBodyGetPositionX(Bodies(i)),KODE_dBodyGetPositionY(Bodies(i)),KODE_dBodyGetPositionZ(Bodies(i))
				RotateEntity Meshes(i,j),KODE_dBodyGetPitch(Bodies(i)),KODE_dBodyGetYaw(Bodies(i)),KODE_dBodyGetRoll(Bodies(i))
			EndIf
		Next
		;LINEAR AND ANGULAR DUMPING
		dump# = 0.99
		ax# = KODE_dBodyGetAngularVelX(Bodies(i))
		ay# = KODE_dBodyGetAngularVelY(Bodies(i))
		az# = KODE_dBodyGetAngularVelZ(Bodies(i))
		KODE_dBodySetAngularVel(Bodies(i),ax#*dump#,ay#*dump#,az#*dump#)
	EndIf
Next

;RenderWorld
RenderWorld()

Flip
Wend

The following lines don't seem right to me using 'KODE_dBodyGetPosition' shouldn't this be the geom position ??

PositionEntity Meshes(i,j),KODE_dBodyGetPositionX(Bodies(i)),KODE_dBodyGetPositionY(Bodies(i)),KODE_dBodyGetPositionZ(Bodies(i))
RotateEntity Meshes(i,j),KODE_dBodyGetPitch(Bodies(i)),KODE_dBodyGetYaw(Bodies(i)),KODE_dBodyGetRoll(Bodies(i))

I'm thinking types would clean up the use of arrays here. Maybe some clean up in a future version.

I'll be testing some more later.

PositionEntity Meshes(i,j),KODE_dBodyGetPositionX(Bodies(i)),KODE_dBodyGetPositionY(Bodies(i)),KODE_dBodyGetPositionZ(Bodies(i))
RotateEntity Meshes(i,j),KODE_dBodyGetPitch(Bodies(i)),KODE_dBodyGetYaw(Bodies(i)),KODE_dBodyGetRoll(Bodies(i))

In ODE, when you attach a geom to its body, both become one, so the position of the geom is EXACTLY the same as the position of the BODY. So you can use any of the functions.

And for the static meshes, they are positioned at the creation time, so no need to refresh its position and/or rotation.

I use types in the KodePlayer, but this is easier to understand. Of course this is a very inneficcient way to do this, because you are making a 1000x1000 loop although you have 5 bodies. the problem is that the types i use in the kodeplayer are complex, due to all the information they have. I think i will change to a simple type creation. Taking note!

By the way, ShareIt is Activated now!. With Shareit, The price has been raised 2€ to compensate ShareIt Fees.

Checkit here: www.lcuriel.arrakis.es/kode/buy.htm

Cheers!

ODE allows multiple geoms per body. One example would be a chair composed of one body defining it’s mass and orientation, and geoms for the chair back, seat, and legs. This configuration would allow the chair to tumble down stairs with the geoms providing collision detection.

Looking at your code I see it positioning each of the geoms at the position of the body, and clearly the meshes will NOT be in the same place as the body. I can understand the meshes being in a position relative to the body, but the meshes are not parented..

Have I missed something here ?

See the GeomTransform Sample. GeomTransform is the kernel of multiple geom at relative positions! This example shows chair and tables using several geoms for one body.

If you have any questions please ask me!

P.D: Mmm, i see what you say. The trick on the exporter is that i move the mesh position to the geom position. It is a similar result to parent.

The other way would be to set the position to the geom instead to the position of the body, but... what to do if there is no geom?. So i set to the body position and move the mesh if a geomtransform exists...

I ran GeomTransform Sample and it says ')' is missing.

;ODE CREATION

;Entity: Entity1
Geoms(1,1) = KODE_dCreatePlane(space,E\Geoms[i]\rx,1.0,0.0,0.00.0)


Looking at the code some more before I ask more questions.

I ran GeomTransform Sample and it works. I tried the Exported code and got ')' is missing.

;ODE CREATION

;Entity: Entity1
Geoms(1,1) = KODE_dCreatePlane(space,E\Geoms[i]\rx,1.0,0.0,0.00.0)


Looking at the code some more before I ask more questions.

You don't have the last version. Have you received the 1.03 version? Anyway the 1.03 version fails when it tries to positionmesh in a plane. I have the updated 1.04 version already finished. Sending it soon...

If you have received the 1.03, update your version, export the sample, the delete the line with positionmesh the plane.

Ask all you need!

The scaled window is a definite improvemnt. Its not perfect, but its a good short term solution. Thanks for implementing so quickly.

I noticed that 'new' primitives are not transparent?

I have played a little with the 1.03 demo and have the following suggestions. These are just my comments, so do with them what you will :)

1) Kode importer to load physics models into a blitz application. I guess the best way would be to load a heirarchical mesh (LoadAnimMesh) which contains all the various entities as children of associated parents. However, a custom import along with TYPE data would be ok too.

2) Allow user to create custom joint templates which can be quickly applied to new bodies (and automaticaly loaded when editor starts). Perhaps include some default templates such as 'Elbow'.

3) Automated placement of joint 'positions' using model with imported bones. User can change joint to correct type.

4) Ability to rotate objects using the mouse.

5) Perhaps I have not got used to the editor yet, but I found it hard to visualise the joint orientation. Perhaps more graphical feedback would be helpful, especialy if constraint limits could be graphicaly represented (this would be really nice).

6) Zoom extent options. These allow you to set view 'zoom' and 'position' to show the whole scene or the currently selected object with only a small amount of surrounding 'empty' space.

7) Allow 'Space' to toggle between camera and entity mode.

8) Save a 'default' simulation view screen resolution which is used for all models.

I can see a lot of work has gone into the editor and am sure it will benefit a lot of people in its current state. Its a really nice piece of work, but for myself, it really needs an importer and a few other tweaks before I buy. Maybe my suggestions make sense, maybe they dont! I will watch KODE with interest ;)

Rhy :)

Hi Rhy!

- Meshes are not transparent, except for imported meshes. Geom Meshes are always transparent. Perhaps all should be transparent... It was in the 0.99 version hehe

1) I think i really don't understand the importer idea. When you export in KODE you get a .bb that you can include in your soft. If you want anyway the .kode importer into Types to be free, i think i can manage to make a free version.

2) Templates can be done thanks to the magic MERGE function. Just make your .kode templates, then add them to your scene merging them, and use copy paste to make copies of the entities!

3) Working...
4) Thinking...
5) I know...
6) Working...
7) Good Idea...
8) Don't understand... can explaint it better please?
9) I am working on the XODE exporter too!

Thanks for the comments Rhy!

Glad you took my comments the right way :)

Good you seem to already have implemented some of them :)

Sorry for another long post, the last one was going to be my last one!! Oh well ;)

1) An importer is more flexible in my view for several reasons. You can easily change the physics of a model and simply import the new model (.kode file) rather than having to amend the code (or cut n paste from the 'new' exported .bb code into 'exisiting' code). Second, you do not have to create all models unless you actualy need them - you just import the .kode files you require. Third, you can easily add new models into the project by simply calling the importer with a different .kode filename.

For example, I am currently working on a project which allows the user to select one character from many varied character models. The user will only use one model out of many. It is much easier to simply import ONLY the model selected and will use less memory etc. Additionaly, as development of the project continues, many changes will be made to the physics and mesh of the character models (initialy they will be very simple). If an importer is used, NO changes to the code will be required to import the amended model - assuming the same file name is used.

Yes, I could use the exported .bb code and cut n paste into variuos function within my code (each time a change to the physics/mesh is made), but an importer will simplify and speed up the development process and hence make the investment in the editor worthwhile.

Also, I do not need the .bb code to actualy run the physics simulation as this is already done and includes many other functions required by the project.

So, what 'I' would need is an importer which reads a .kode file (or whatever) and setups an ODE body with a pointer to its ROOT and/or an associated TYPE. I would prefer it if the models MESH could be kept 'seperate' so that it could be replaced if required (we use the pipeline MAX exporter which supports additional features which may get 'lost' if loading MESH from KODE). However, I could probaly modify the import function myself if required (as its getting a bit 'specialised'). Sorry, getting a bit carried away!

2) True, joint templates could be done as you suggested and its a good idea. However, see (3) below.

3) Excellent - automated bones!! Using the MERGE function for joint templates would not work well, I think. You would loose the automated joints position when pasting. You would need a 'replace' command to substitute one joint for another keeping its original position and rotation.

4) For rotating entities. I noticed that the right mouse button still seems to move the camera even when in entity mode. Could you use right mouse to rotate instead, using the axis of the current view?

5) Ok :) Btw, took me ages to figure out the graphics were a 'J' for joints and an 'E' for entities ;)

6) Cool, zoom extents will really help. When will they be released?

7) I got the idea from another app, so no credit to me ;)

8) You can currently select the screen size for the simulation to run in for each .kode file (I presume this is saved with the model?). I would prefer a global screen size, perhaps which is just applied to new .kode files by default. Basicaly, I will always want to run 1024x768 99% of the time so would just want it to default to this. No big deal though, its towards the end of my list ;)

9) XODE - huh? What this?

10) Just kidding ;)

Thanks for the reply. The way it is going I guess I will be purchasing KODE sooner or later :)

Rhy

Ok, then let's work with the importer right now. The importer is the LoadWorld() function i use. It takes the .kode file and parse all the data into Types. Entity Type, Geom Type, Joint Type,Body Type and Mesh Type.

Of course an Entity Type has one Body Type, Zero or More Geoms, Zero or More Joints, Zero or More Meshes.

Then the Kode Editor Creates them all, or the KodePlayer Set ODE's and play them all.

Do you want me to make a specification file of the types and the .kode files and make the LoadWord() function to be public domain?

Then i could create the CREATEWORLD() function that load meshes, geoms, sets ODE, etc...

If this is what you need, i can make it.

Think about it and tell me what you need ;)

P.D: XODE is the XML - ODE Format. Some kind of standard that the odejava.org community has created and asking me to include!

I think it's worth mentioning that your website crashed Firefox (latest version).

Hm... neaters :)

Noel Cower: Thanks for the advise. I have removed every non standard html code. Could you test it again please?

One thing related to the exporter/importer. As you know i am working on XODE (XML - ODE).

John J has a very good parser for Blitz and XML. Perhaps this should be what you are looking for. I can generate an XML with all nodes with its joints, bodies, geoms, etc... so then, using the BlitzXml functions you can load and save, and then import and export in Kode should be really easy!.

The only thing about XODE is that Meshes are not included, but i can include them so if you need them you use it.

Think about it, i see it as a good thing for Rhy!

KuRiX, once again thanks for your helpfulness. Either of the methods you have suggested would be fine.

However, I think you are right, the BlitzXML method would be more suitable for my own requirements. If you can inlcude the associated meshes filename in the XML that would be great, it can always be ignored by those who do not want it. Using relative paths is best in my mind, like '/Models/<filename>'.

I think making the existing LOADWORLD and CREATEWORLD functions available would also be a good idea though.

If/when you implement joint placement based on meshes with imported bones, could you name the joint the same as the associated bone. And when changing the joint type, do not overwrite the joint name. This way you could have standard templates and use the joint names to position correctly on mesh ;)

Are you definelty implementing automated creation based on MAX bones? If so, its time to get out my credit card :)

Many thanks again,
Rhy :)

The automated creation is not definitive Rhy, because i am having troubles with max bones. Anyway i think i can create a body and a joint in the max bone position and rotation then later in the editor edit the rotation problems...

You can use relative paths for models in the editor now. Just type in the Search Box: "models/mysupermodel.x" :D

Exporter for XODE is finished. Working on the importer now...

Exported code has no dspacecollide, does this mean I can't examine the contacts before stepping the world ?

Also be nice to document all the wrapper functions that vary from standard ODE documentation ( quite a few of them ).

Well, the contact creation function is made trhough a callback in c++, and blitz has no callbacks, so it is an automated process.

In fact, my dWorldStep Function does:

dSpaceCollide(space, world, &nearCallback);
dWorldQuickStep(world, step);
dJointGroupEmpty (contactgroup);

The contacts can be examined later with all the functions to get body collisions. (collision point, collision normal, ray collisions, etc...). Look at the userlibs.

P.D: Yep, i want to document all the functions, but i have so many things in my "to do" list. So please, give me some time...

Why roll them all up into step world ?

"The contacts can be examined later with all the functions to get body collisions. (collision point, collision normal, ray collisions, etc...). Look at the userlibs."

The contact group is destroyed so there are no contacts for me to examine.

I'd like to insert my code as shown below..

dSpaceCollide(space, world, &nearCallback);
<== Like to insert : UpdateFriction
dWorldQuickStep(world, step);
dJointGroupEmpty (contactgroup);

I used this after step world to try and find contacts.

For i=1 To 1000
	If (Bodies(i)<>0)
		If KODE_dBodyIsEnabled(Bodies(i))
		numjoints=KODE_dBodyGetNumJoints(Bodies(i))
			If numjoints>0 
			DebugLog "joints=" + Str(numjoints)
				For jointn=0 To numjoints-1
					joint1=dBodyGetJoint(Bodies(i),jointn)
					If KODE_dJointGetType(joint1)=dJointTypeContact
						DebugLog "Contact"
					EndIf
				Next
			EndIf
		EndIf
	EndIf
Next

With JVODE it was much easier:

dSpaceCollide(Space,World,ContactGroup)
UpdateFriction
dWorldQuickStep(World,0.1)
dJointGroupEmpty(ContactGroup)

; ###################################################################################################

Function LinearDamp(body,damp#)
  dBodyAddForce body,dBodyGetLinearVelX(body)*-damp,dBodyGetLinearVelY(body)*-damp,dBodyGetLinearVelZ(body)*-damp
End Function

; ###################################################################################################

Function UpdateFriction()

For ode.ODEGeom=Each ODEGeom
	; color code if body enabled
	If dBodyIsEnabled(ode\body)=0
		EntityColor ode\mesh,255,0,0
	Else
		EntityColor ode\mesh,0,255,0
	End If
	
	; add friction force if body enabled  
	If dBodyIsEnabled(ode\body) And ode\body<>Car
		numjoints=dBodyGetNumJoints(ode\body)
		If numjoints>0 
		DebugLog "joints=" + Str(joints)
			For joints=0 To numjoints-1
				joint1=dBodyGetJoint(ode\body,joints)
				If dJointGetType(joint1)=dJointTypeContact
					
					; Get linear velocity vector
			  		ax#=dBodyGetLinearVelX#(ode\body)
			  		ay#=dBodyGetLinearVelY#(ode\body)
				    az#=dBodyGetLinearVelZ#(ode\body)
				
					; Get Angular velocity vector
			  		bx#=dBodyGetAngularVelX#(ode\body)
			  		by#=dBodyGetAngularVelY#(ode\body)
					bz#=dBodyGetAngularVelZ#(ode\body)
					
			  		; Calculate magnitudes
					ForceA#=Sqr(ax*ax+ay*ay+az*az)
					ForceB#=Sqr(bx*bx+by*by+bz*bz)
					
					If ForceA>.01
						LinearDamp(ode\body,.04)
					End If
					
					;If ForceA>2.5
					;	PositionEntity piv1,dGeomGetPositionX#(ode\geom),dGeomGetPositionY#(ode\geom),dGeomGetPositionZ#(ode\geom)
					;	EmitSound(snd1,piv1)
					;End If
										
					If ForceB>.01
						AngularDamp(ode\body,.04)
					End If
					
						
				End If
			Next
		End If
	End If
Next

End Function

Thanks

Sorry, double post... look down

Well, dspacecollide creates the contact joints, but they are not used until dworldquickstep, so inserting your updatefriction function in the middle is not so important.

In fact it is better to leave ode to make its job, and later make your dumping. With my dll you can make:

KODE_dworldquickstep(step)

and then:

For Every Body
n = KODE_dbodygetcollisionscount()
for j=1 to n
MakeWhatYouWantWithContactData()
next
next

You can access ALL the contact data Generated during the dspacecollide accesing every body contact data with:

KODE_dBodyGetCollisionsCount%(body%):"_KODE_dBodyGetCollisionsCount@4"
KODE_dBodyGetCollisionDepth#(body%, num%):"_KODE_dBodyGetCollisionDepth@8"
KODE_dBodyGetCollisionX#(body%, num%):"_KODE_dBodyGetCollisionX@8"
KODE_dBodyGetCollisionY#(body%, num%):"_KODE_dBodyGetCollisionY@8"
KODE_dBodyGetCollisionZ#(body%, num%):"_KODE_dBodyGetCollisionZ@8"
KODE_dBodyGetCollisionNX#(body%, num%):"_KODE_dBodyGetCollisionNX@8"
KODE_dBodyGetCollisionNY#(body%, num%):"_KODE_dBodyGetCollisionNY@8"
KODE_dBodyGetCollisionNZ#(body%, num%):"_KODE_dBodyGetCollisionNZ@8"
KODE_dBodyGetCollisionBody%(body%, num%):"_KODE_dBodyGetCollisionBody@8"
KODE_dBodyGetCollisionGeom%(body%, num%):"_KODE_dBodyGetCollisionGeom@8"
KODE_dBodyGetCollisionFX#(body%, num%):"_KODE_dBodyGetCollisionFX@8"
KODE_dBodyGetCollisionFY#(body%, num%):"_KODE_dBodyGetCollisionFY@8"
KODE_dBodyGetCollisionFZ#(body%, num%):"_KODE_dBodyGetCollisionFZ@8"

P.D: Why whould you like to examine the data before stepping?. In the worst case you have 1 frame of difference between both methods. Well anyway, i will add separate functions to step the world and collide the world if you really need.

Collision stuff is working for me as is so seems ok for now.

Is there a way to set max contacts ?

Thanks

Site works now, Kurix. Cheers.

Finishing Version 1.05 now. I have added a function to set max contacts. Sending soon.

Cheers.

1.05 Demo Version available to Download.
www.lcuriel.arrakis.es/kode/
:D
I have added water.kode in the library section. Check it!

KODE Player Crash
When exiting full screen player with water demo causes window named 'KODE-_temp' to remain on the screen, and KODE is rendered useless only option is to close window.

KODE not saving
KODE is not saving Player fullscreen setting. Kode will run the Player full screen, but if KODE is restarted it doesn't reload the Player full screen setting.

Water tutorial amusing but looks goofy.

8)

That was one hell of a license screw up. To the best of my knowledge you can't change the license after the fact. Now most buyers would respect this mistake but under the eariler license it said 'you are now allowed to distribute these files'

What I would do if this happened to me, I would offer something to those buyers in exchange for the license ammendment. Might be some textures, might be some models.

Check contracts carefully, can't stress this enough.

cheers

Checking those problems now...

Well the license mistake was only in the mail, not the README.txt which officially includes the license and was included in the first version too, so it was only a funny mistake...

EDITED: Well i have set KodePlayer Settings as Global for the version 1.06.

Perhaps it is time to start a new thread... this is growing too much...

Working on the Automatic Ragdoll Creation:

Now it is time to sleep.
Bye!

Hey - nice to know / see that automatic ragdolls are so far already!



What? Sleep is for wussies - we want upgrades and new features, get back to work! ;P

I am impressed with the progress KuRiX is making with this product. Finaly put my credit card where my mouth is and purchased KODE.

Keep up the good work - but limit yourself to 4 hours sleep a night please ;)

Rhy :)

New thread here:
http://www.blitzbasic.com/Community/posts.php?topic=47920