Raydium 3D Game Engine

/*
    Raydium - CQFD Corp.
    http://raydium.org/
    Released under both BSD license and Lesser GPL library license.
    See "license.txt" file.
*/
#include "raydium/index.c"

int modelo;
int instancia;
int status=0;
int movement=-1;
int dummy;
int debug=0;
float angle=0.0f;
float radius=0.2f;
float fadein=0.5;
float fadeout=0.5;
float f[3];
float velocity=40.9;
float mov_timer;
dReal *pos;
dReal *vel;

//create sphere->ode object as base of the model
int create_void(void)
{
   int a;
   a=raydium_ode_object_create("void_dummy");   
   raydium_ode_object_sphere_add("void_dummy_0",a,0.2,radius,RAYDIUM_ODE_STANDARD,0,"");   
   raydium_ode_element_rotfriction_name ("void_dummy_0",0.005f);
   raydium_ode_element_material_name("void_dummy_0",RAYDIUM_ODE_MATERIAL_SOFT2);
   return a;   
}

//create the instance model
void create_model(void)
{
   dummy=create_void();
   //load the model
   modelo=raydium_anim_model_load("trooper/trooper.cfg");
   //creates one instance of the model.
   //Cause models can NOT be used directly.
   instancia=raydium_anim_instance_new(modelo);
   //apply meshes to the instance.
   //You could change meshes of an instance   
   raydium_anim_instance_attach_meshes(instancia);
   //Aply materials to the instance
   //You could change the set of materials to apply.
   raydium_anim_model_materials_apply(instancia,0);
   status=1;
   movement=0;
}

//setting up instance as walking
void model_walk(void)
{
   //we destroy animation number 2
   raydium_anim_action_remove(instancia,2);
   //we fade out animation 0 during a time of "fadeout" seconds
   raydium_anim_loop_clear(instancia,0,fadeout);
   //we apply animation 1 at full influence(1)
   raydium_anim_loop_set(instancia,1,1,fadein);
   //we fade out animation 2 during a time of "fadeout" seconds
   raydium_anim_loop_clear(instancia,2,fadeout);   
}

//setting up instance as stand up/idle
void model_idle(void)
{
   //we destroy animation number 2
   raydium_anim_action_remove(instancia,2);
   //we apply animation 0 at full influence(1) in just "fadein" seconds
   raydium_anim_loop_set(instancia,0,1,fadein);
   //we fade out animation 1 during a time of "fadeout" seconds   
   raydium_anim_loop_clear(instancia,1,fadeout);   
   //we fade out animation 2 during a time of "fadeout" seconds
   raydium_anim_loop_clear(instancia,2,fadeout);   
}

//setting up a action (animation 2)
void model_die(void)
{      
   //we launch animation 2. Fadeing in for 0.2 seconds and
   //fading out for 0 seconds. The animation will be stucked at end
   //of animation(last param = 1).
   raydium_anim_action_set(instancia,2,0.2,0,1);   
}

void display(void)
{   
   //update models.
   //we have to tell how much time has passed betwen this and the
   //previous frame.
   raydium_anim_update_animation(instancia,raydium_frame_time);   
   
   //update forces for applying to the dummy object
   f[0]=raydium_trigo_cos(angle-90.0f)*velocity;
   f[1]=raydium_trigo_sin(angle-90.0f)*velocity;
   f[2]=0.0f;
   
   //more updates
   if(movement==1)
   {
      //testing
      //instead of applying a force constanly,
      //this code is just applying the force each 0.5 seconds
      mov_timer+=raydium_frame_time;      
      if(mov_timer>0.5)
      {
         raydium_ode_element_addforce_name_3f("void_dummy_0",f[0],f[1],f[2]);
         mov_timer=0;
      }
   }
   else if(movement==0 )
   {
      //model_idle();
      //get linear velocity of the dummy object
      vel=raydium_ode_element_linearvelocity_get_name("void_dummy_0");
      float total;      
      total=sqrt(vel[0]*vel[0]+vel[1]*vel[1]+vel[2]*vel[2]);
      raydium_log("total: %3.3f",total);
      //sett up animations according the quantity of movement of the dummy
      raydium_anim_loop_set(instancia,0,1.0f-raydium_math_min(1,sqrt(total/1.80f)),0);
      raydium_anim_loop_set(instancia,1,raydium_math_min(1,sqrt(total/1.8f)),0);
   }
   
   //joy emulation   
   raydium_joy_key_emul();

   //escape
   if(raydium_key_last==1027)      exit(0);
      
   //debug
   if(raydium_key_last==1000+'d')   debug=debug?0:1;
   
   //captures
   if(raydium_key_last==7)raydium_capture_frame_auto();
   
   //create model
   if(raydium_key_last==1000+'1')create_model();   
   
   //model walk
   if(raydium_key_last==1000+'2')model_walk();

   //model idel
   if(raydium_key_last==1000+'3')model_idle();
   
   //model die
   if(raydium_key_last==1000+'4')model_die();
   
   //LOD to middle of polygons(aprox.)
   if(raydium_key_last==1000+'l')raydium_anim_model_lod_set(instancia,0.5);
   
   //rotating model
   if(raydium_key[GLUT_KEY_RIGHT])angle-=0.7;
   if(raydium_key[GLUT_KEY_LEFT])angle+=0.7;
   
   //forward model
   if(raydium_key[GLUT_KEY_PAGE_UP])
   {
      movement=1;
      model_walk();
   }
   //leave walking
   if(raydium_key[GLUT_KEY_PAGE_DOWN])
   {
      //model_idle();
      movement=0;
   }
   
   //starting frame
   raydium_clear_frame();
   
   //setting camera
   if(status>0)
   {
      pos=(float*)raydium_ode_element_pos_get_name("void_dummy_0");
      raydium_camera_orbitmove(pos[0]+(0.4*(raydium_math_cos(angle))),pos[1]+(0.4*(raydium_math_sin(angle))),pos[2]+1.1);
   }
   else
      raydium_camera_orbitmove(0,0,0.5);         
   
   
   //draw model
   if(status>0)
   {
      pos=(float*)raydium_ode_element_pos_get_name("void_dummy_0");
      glTranslatef(pos[0],pos[1],pos[2]-radius);
      glRotatef(angle,0,0,1);      
      raydium_anim_mesh_render(instancia);      
      glRotatef(-angle,0,0,1);
      glTranslatef(-pos[0],-pos[1],-pos[2]);
   }
   
   //draw ode stuff
   if(!debug)raydium_ode_draw_all(0);
   else raydium_ode_draw_all(RAYDIUM_ODE_DRAW_DEBUG);   
   
   raydium_rendering_finish();
}


int main(int argc, char **argv)
{
raydium_init_args(argc,argv);
raydium_window_create(1024,768,RAYDIUM_RENDERING_WINDOW,"Cal3D Animation test");

raydium_texture_filter_change(RAYDIUM_TEXTURE_FILTER_TRILINEAR);
raydium_window_view_perspective(60,0.01,2500); // fov 60 + near and far planes

raydium_fog_disable();   
raydium_light_enable();
raydium_light_on(0);

raydium_light_conf_7f(0,50,150,200,1000000,1,0.9,0.7); // id, pos, intensity and color (RGB)
raydium_background_color_change(1,0.9,0.7,1);

raydium_sky_box_cache();

raydium_ode_ground_set_name("cocorobix.tri");

raydium_callback(&display);

//destroy model and instance
raydium_anim_instances_destroy();
raydium_anim_models_destroy();
return(0);
}

// EOF

Index: Makefile
===================================================================
--- Makefile   (revisión: 798)
+++ Makefile   (copia de trabajo)
@@ -7,9 +7,9 @@
 CC = gcc
 AR = ar
 RANLIB = ranlib
-SYSTEM_LIBS =  -lGL -lGLU -lXinerama -lm -ljpeg -lopenal -lalut -lvorbis -lvorbisfile -logg -lresolv -lcrypt -lz -lcurl -lxml2 -lGLEW
+SYSTEM_LIBS =  -lGL -lGLU -lXinerama -lm -ljpeg -lopenal -lalut -lvorbis -lvorbisfile -logg -lresolv -lcrypt -lz -lcurl -lxml2 -lGLEW -lcal3d
 OTHER_LIBS =  raydium/ode/ode/src/libode.a raydium/php/libs/libphp5.a
-INCLUDE_PATH =  -Iraydium/ode/include/ -Iraydium/php/ -Iraydium/php/include -Iraydium/php/main/ -Iraydium/php/Zend -Iraydium/php/TSRM -I/usr/include/curl
+INCLUDE_PATH =  -Iraydium/ode/include/ -Iraydium/php/ -Iraydium/php/include -Iraydium/php/main/ -Iraydium/php/Zend -Iraydium/php/TSRM -I/usr/include/curl -I/usr/include/
 LIBS_PATH =  -L/usr/X11R6/lib/
 CFLAGS=-W
 COMPILE_OPTIONS=-g -D LIBRAY
@@ -17,7 +17,7 @@
 LINKING_OPTIONS=-Wl,-soname,libraydium.so.0
 AR_OPTIONS=
 
-HEADERS=raydium/headers/background.h raydium/headers/callback.h raydium/headers/camera.h raydium/headers/capture.h raydium/headers/clear.h raydium/headers/console.h raydium/headers/file.h raydium/headers/file_tri.h raydium/headers/fog.h raydium/headers/init.h raydium/headers/cli.h raydium/headers/internal.h raydium/headers/joy.h raydium/headers/key.h raydium/headers/land.h raydium/headers/light.h raydium/headers/log.h raydium/headers/main.h raydium/headers/mouse.h raydium/headers/network.h raydium/headers/normal.h raydium/headers/object.h raydium/headers/ode.h raydium/headers/osd.h raydium/headers/parser.h raydium/headers/particle2.h raydium/headers/php.h raydium/headers/profile.h raydium/headers/random.h raydium/headers/rayphp.h raydium/headers/register.h raydium/headers/render.h raydium/headers/signal.h raydium/headers/sky.h raydium/headers/sound.h raydium/headers/texture.h raydium/headers/timecall.h raydium/headers/math.h raydium/headers/vertex.h raydium/headers/window.h raydium/headers/reg_api.h raydium/headers/gui.h raydium/headers/live.h raydium/headers/video.h raydium/headers/shadow.h raydium/headers/myglut.h raydium/headers/web.h raydium/headers/hdr.h raydium/headers/shader.h raydium/headers/atexit.h raydium/headers/path.h raydium/headers/sprites.h
+HEADERS=raydium/headers/background.h raydium/headers/callback.h raydium/headers/camera.h raydium/headers/capture.h raydium/headers/clear.h raydium/headers/console.h raydium/headers/file.h raydium/headers/file_tri.h raydium/headers/fog.h raydium/headers/init.h raydium/headers/cli.h raydium/headers/internal.h raydium/headers/joy.h raydium/headers/key.h raydium/headers/land.h raydium/headers/light.h raydium/headers/log.h raydium/headers/main.h raydium/headers/mouse.h raydium/headers/network.h raydium/headers/normal.h raydium/headers/object.h raydium/headers/ode.h raydium/headers/osd.h raydium/headers/parser.h raydium/headers/particle2.h raydium/headers/php.h raydium/headers/profile.h raydium/headers/random.h raydium/headers/rayphp.h raydium/headers/register.h raydium/headers/render.h raydium/headers/signal.h raydium/headers/sky.h raydium/headers/sound.h raydium/headers/texture.h raydium/headers/timecall.h raydium/headers/math.h raydium/headers/vertex.h raydium/headers/window.h raydium/headers/reg_api.h raydium/headers/gui.h raydium/headers/live.h raydium/headers/video.h raydium/headers/shadow.h raydium/headers/myglut.h raydium/headers/web.h raydium/headers/hdr.h raydium/headers/shader.h raydium/headers/atexit.h raydium/headers/path.h raydium/headers/sprites.h raydium/headers/anim.h
 
 OBJECTS      = $(HEADERS:raydium/headers/%.h=raydium/compile/%.o)
 
Index: anim-test1.c
===================================================================
--- anim-test1.c   (revisión: 0)
+++ anim-test1.c   (revisión: 0)
@@ -0,0 +1,213 @@
+/*
+    Raydium - CQFD Corp.
+    http://raydium.org/
+    Released under both BSD license and Lesser GPL library license.
+    See "license.txt" file.
+*/
+
+#include "raydium/index.c"
+
+int modelo,modelo2;
+int instancia,instancia2;
+float instancia2_walk=0;
+int instancia2_flag=0;
+int rendermesh=0;
+int renderskel=1;
+
+void display(void)
+{      
+   raydium_anim_instance_update(instancia,raydium_frame_time);
+   raydium_anim_instance_update(instancia2,raydium_frame_time);
+   
+   raydium_joy_key_emul();
+
+   //escape
+   if(raydium_key_last==1027)      exit(0);   
+   
+   //F7 capture screen
+   if(raydium_key_last==7)raydium_capture_frame_auto();
+   //switch meshes
+   if(raydium_key_last==1)rendermesh=rendermesh?0:1;
+   //switch skel
+   if(raydium_key_last==2)renderskel=renderskel?0:1;
+   //meshes attachment
+   if(raydium_key_last==3)
+   {
+      raydium_anim_instance_attach_meshes(instancia);
+      raydium_anim_instance_attach_meshes(instancia2);
+   }
+   //materials apply
+   if(raydium_key_last==4)
+   {
+      raydium_anim_model_materials_apply(instancia,0);
+      raydium_anim_model_materials_apply(instancia2,0);
+   }   
+   //LOD setting
+   if(raydium_key_last==5)
+   {
+      raydium_anim_model_lod_set(instancia,0.05);
+      raydium_anim_model_lod_set(instancia2,0.05);
+   }
+   if(raydium_key_last==6)
+   {
+      raydium_anim_model_lod_set(instancia,1);
+      raydium_anim_model_lod_set(instancia2,1);
+   }
+   
+   //loop
+   if(raydium_key_last==1000+'1')
+   {
+      //remove actions
+      raydium_anim_action_remove(instancia,1);
+      raydium_anim_action_remove(instancia,5);         
+      raydium_anim_action_remove(instancia2,2);
+      //clear loops
+      raydium_anim_loop_clear(instancia,0,0.5);
+      raydium_anim_loop_clear(instancia,1,0.5);
+      raydium_anim_loop_clear(instancia,2,0.5);
+      raydium_anim_loop_clear(instancia,3,0.5);
+      raydium_anim_loop_clear(instancia,4,0.5);
+      raydium_anim_loop_clear(instancia,5,0.5);
+      raydium_anim_loop_clear(instancia2,1,3);
+      //setup loops
+      raydium_anim_loop_set(instancia,3,1,3);      
+      raydium_anim_loop_set(instancia2,0,1,3);         
+   }
+   //loop
+   if(raydium_key_last==1000+'2')
+   {
+      //remove actions
+      raydium_anim_action_remove(instancia,1);
+      raydium_anim_action_remove(instancia,5);         
+      raydium_anim_action_remove(instancia2,2);         
+      //clear loops      
+      raydium_anim_loop_clear(instancia,0,0.5);
+      raydium_anim_loop_clear(instancia,1,0.5);
+      raydium_anim_loop_clear(instancia,2,0.5);
+      raydium_anim_loop_clear(instancia,3,0.5);
+      raydium_anim_loop_clear(instancia,4,0.5);
+      raydium_anim_loop_clear(instancia,5,0.5);
+      raydium_anim_loop_clear(instancia2,0,3);
+      //set up loops
+      raydium_anim_loop_set(instancia,4,1,3);            
+      raydium_anim_loop_set(instancia2,1,1,3);      
+   }
+      //loop
+   if(raydium_key_last==1000+'3')
+   {
+      //remove actions
+      raydium_anim_action_remove(instancia,1);
+      raydium_anim_action_remove(instancia,5);         
+      raydium_anim_action_remove(instancia2,2);         
+      //clear loops      
+      raydium_anim_loop_clear(instancia,0,0.5);
+      raydium_anim_loop_clear(instancia,1,0.5);
+      raydium_anim_loop_clear(instancia,2,0.5);
+      raydium_anim_loop_clear(instancia,3,0.5);
+      raydium_anim_loop_clear(instancia,4,0.5);
+      raydium_anim_loop_clear(instancia2,0,3);
+      //set up loops
+      raydium_anim_loop_set(instancia,0,1,3);            
+         
+   }
+   //loop
+   if(raydium_key_last==1000+'4')
+   {
+      //remove actions
+      raydium_anim_action_remove(instancia,1);
+      raydium_anim_action_remove(instancia,5);         
+      raydium_anim_action_remove(instancia2,2);         
+      //clear loops      
+      raydium_anim_loop_clear(instancia,0,0.5);
+      raydium_anim_loop_clear(instancia,1,0.5);
+      raydium_anim_loop_clear(instancia,2,0.5);
+      raydium_anim_loop_clear(instancia,3,0.5);
+      raydium_anim_loop_clear(instancia,4,0.5);
+      raydium_anim_loop_clear(instancia,5,0.5);   
+      //launch action
+      raydium_anim_action_set(instancia,5,0.5f, 0.1f, 0);      
+            
+   }
+   //action   
+   if(raydium_key_last==1000+'5')
+   {
+      raydium_anim_loop_clear(instancia,3,0.3);
+      raydium_anim_loop_clear(instancia,4,0.3);
+      raydium_anim_action_set(instancia,1,1.0f, 0.3f, 1);   
+      raydium_anim_loop_clear(instancia2,1,0.3);            
+      raydium_anim_loop_clear(instancia2,0,0.3);
+      raydium_anim_action_set(instancia2,2,1.0f, 0.3f, 1);      
+   }
+   
+   
+   raydium_clear_frame();
+   raydium_camera_orbitmove(0,0,0.5);
+   
+   raydium_ode_draw_all(0);
+   
+   //render instances   
+   if(rendermesh)
+   {
+   raydium_anim_instance_render(instancia,1);
+   raydium_anim_instance_render(instancia2,1);      
+   }
+   if(renderskel)
+   {
+   raydium_anim_instance_render(instancia,2);
+   raydium_anim_instance_render(instancia2,2);      
+   }
+   raydium_osd_printf(5,5,14,0.45,"bitstream.tga","Elapsed time: %5.5f",raydium_frame_time);   
+   raydium_osd_printf(5,95,15,0.45,"bitstream.tga","F1: switch Render Mesh");   
+   raydium_osd_printf(5,92,15,0.45,"bitstream.tga","F2: switch Render Skeleton");
+   raydium_osd_printf(5,89,15,0.45,"bitstream.tga","F3: Aplly meshes (needed to mesh render)");
+   raydium_osd_printf(5,86,15,0.45,"bitstream.tga","F4: Aplly materials/textures");
+   raydium_osd_printf(5,83,15,0.45,"bitstream.tga","F5: LOD(level of detail) 10%% for \"paladin\"");
+   raydium_osd_printf(5,80,15,0.45,"bitstream.tga","F6: LOD(level of detail) 100%% for \"paladin\"");
+   raydium_osd_printf(5,77,15,0.45,"bitstream.tga","F7: Screen capture");
+   raydium_osd_printf(5,74,15,0.45,"bitstream.tga","1,2,3,4,5: Various animation loops/actions");
+
+   raydium_rendering_finish();
+}
+
+
+int main(int argc, char **argv)
+{
+raydium_init_args(argc,argv);
+raydium_window_create(800,600,RAYDIUM_RENDERING_WINDOW,"Cal3D Animation test 1");
+
+raydium_texture_filter_change(RAYDIUM_TEXTURE_FILTER_TRILINEAR);
+raydium_window_view_perspective(60,0.01,2500); // fov 60 + near and far planes
+
+raydium_fog_disable();   
+raydium_light_enable();
+raydium_light_on(0);
+
+raydium_light_conf_7f(0,50,150,200,1000000,1,0.9,0.7); // id, pos, intensity and color (RGB)
+raydium_background_color_change(1,0.9,0.7,1);
+
+raydium_sky_box_cache();
+raydium_anim_init();
+raydium_ode_ground_set_name("cocorobix.tri");
+
+//loading models
+raydium_log("Stating models load...");
+modelo=raydium_anim_model_load("paladin.cfg");
+modelo2=raydium_anim_model_load("trooper.cfg");
+raydium_log("End of model load.");
+//creating instances
+instancia=raydium_anim_instance_new(modelo);
+instancia2=raydium_anim_instance_new(modelo2);
+//placing/rotating instances
+raydium_anim_instance_move(instancia,0,-1,-1.28);
+raydium_anim_instance_rotate(instancia,140,0,0);
+raydium_anim_instance_move(instancia2,0,1,-1.3);
+raydium_anim_instance_rotate(instancia2,110,0,0);
+
+
+raydium_callback(&display);
+raydium_anim_instances_destroy();
+raydium_anim_models_destroy();
+return(0);
+}
+
+// EOF
Index: raydium/init.c
===================================================================
--- raydium/init.c   (revisión: 798)
+++ raydium/init.c   (copia de trabajo)
@@ -95,6 +95,7 @@
 raydium_osd_fade_init();
 raydium_console_init();
 raydium_gui_init();
+raydium_anim_init();
 //#ifndef WIN32
 raydium_live_init();
 //#endif
@@ -290,6 +291,7 @@
 raydium_sound_init();
 raydium_viewport_init();
 raydium_callback_set();
+raydium_anim_init();
 #ifdef PHP_SUPPORT
 raydium_php_init();
 #endif
Index: raydium/anim.c
===================================================================
--- raydium/anim.c   (revisión: 0)
+++ raydium/anim.c   (revisión: 0)
@@ -0,0 +1,836 @@
+/*
+    Raydium - CQFD Corp.
+    http://raydium.org/
+    Released under both BSD license and Lesser GPL library license.
+    See "license.txt" file.
+*/
+
+#ifndef DONT_INCLUDE_HEADERS
+#include "index.h"
+#else
+#include "headers/anim.h"
+#endif
+
+//TODO: dont place these here
+#define RAYDIUM_ANIM_MAX_ANIMATIONS 32
+#define RAYDIUM_ANIM_MAX_INSTANCES 16
+#define RAYDIUM_ANIM_MAX_MESHES 30
+#define RAYDIUM_ANIM_MAX_MATERIALS 30
+
+//usage of coremodels
+int raydium_anim_model_use   [RAYDIUM_ANIM_MAX_MODELS];
+int raydium_anim_animations   [RAYDIUM_ANIM_MAX_MODELS];
+int raydium_anim_meshes      [RAYDIUM_ANIM_MAX_MODELS];
+int raydium_anim_materials  [RAYDIUM_ANIM_MAX_MODELS];
+int raydium_anim_animationid   [RAYDIUM_ANIM_MAX_MODELS][RAYDIUM_ANIM_MAX_ANIMATIONS];
+int raydium_anim_instance_use   [RAYDIUM_ANIM_MAX_INSTANCES];
+int raydium_anim_instance_model   [RAYDIUM_ANIM_MAX_INSTANCES];
+int raydium_anim_mesh_use   [RAYDIUM_ANIM_MAX_MESHES];
+int raydium_anim_meshid      [RAYDIUM_ANIM_MAX_MODELS][RAYDIUM_ANIM_MAX_MESHES];
+int raydium_anim_material_use   [RAYDIUM_ANIM_MAX_MESHES];
+int raydium_anim_materialid      [RAYDIUM_ANIM_MAX_MODELS][RAYDIUM_ANIM_MAX_MATERIALS];
+float raydium_anim_instance_pos_rot[RAYDIUM_ANIM_MAX_INSTANCES][6];
+
+//instances
+struct CalModel *raydium_anim_instance[RAYDIUM_ANIM_MAX_INSTANCES];
+//coremodels
+struct CalCoreModel *raydium_anim_model[RAYDIUM_ANIM_MAX_MODELS];
+//instances, beware with the non-friendly name
+struct CalModel* model;
+
+/*********************************************************************/
+/*******************  ANIM FUNCTIONS           ***********************/
+/*********************************************************************/
+   
+void raydium_anim_init(void)
+{
+   int a,b;
+   for(a=0;a<RAYDIUM_ANIM_MAX_MODELS;a++)
+   {
+      raydium_anim_model_use[a]=0;
+      raydium_anim_animations[a]=0;
+      raydium_anim_meshes[a]=0;
+      for(b=0;b<RAYDIUM_ANIM_MAX_ANIMATIONS;b++)
+      {
+         raydium_anim_animationid[a][b]=-1;
+      }
+      for(b=0;b<RAYDIUM_ANIM_MAX_MESHES;b++)
+      {         
+         raydium_anim_meshid[a][b]=-1;
+      }
+      for(b=0;b<RAYDIUM_ANIM_MAX_MATERIALS;b++)
+      {
+         raydium_anim_materialid[a][b]=-1;
+      }
+   }
+   for(a=0;a<RAYDIUM_ANIM_MAX_INSTANCES;a++)
+   {
+      raydium_anim_instance_use[a]=0;
+      raydium_anim_instance[a]=NULL;
+      raydium_anim_instance_model[a]=-1;
+      raydium_anim_instance_pos_rot[a][0]=0;
+      raydium_anim_instance_pos_rot[a][1]=0;
+      raydium_anim_instance_pos_rot[a][2]=0;
+      raydium_anim_instance_pos_rot[a][3]=0;
+      raydium_anim_instance_pos_rot[a][4]=0;
+      raydium_anim_instance_pos_rot[a][5]=0;
+   }
+   for(a=0;a<RAYDIUM_ANIM_MAX_MESHES;a++)
+   {
+      raydium_anim_mesh_use[a]=0;      
+   }
+   for(a=0;a<RAYDIUM_ANIM_MAX_MATERIALS;a++)
+   {
+      raydium_anim_material_use[a]=0;      
+   }
+   //TODO:This path_Ext be placed here?
+   raydium_path_ext("./data/anims/","cfg");   
+}
+void raydium_anim_model_destroy(int a)
+{   
+   CalCoreModel_Delete(raydium_anim_model[a]);
+   //WARNING:!!!
+   raydium_log("CAL3D:The instances using this model should be already destroy");   
+}
+void raydium_anim_models_destroy(void)
+{
+   int a;
+   for(a=0;a<RAYDIUM_ANIM_MAX_MODELS;a++)
+   {
+      if(raydium_anim_model_use[a])
+      {
+         raydium_anim_model_destroy(a);
+      }
+   }
+}
+int raydium_anim_model_load(char *filename)
+{
+   int a;
+   for(a=0;a<RAYDIUM_ANIM_MAX_MODELS;a++)
+   {
+      if(raydium_anim_model_use[a]==0)
+      {         
+         #ifdef RAYDIUM_ANIM_CAL3D
+         raydium_log("using cal3d specifics");
+         //raydium_anim_cal3d_model_load_internal return (int)boolean
+         if(raydium_anim_cal3d_model_load_internal(a,filename))
+            {
+            raydium_anim_model_use[a]=1;
+            return a;         
+            }         
+         #endif
+         break;
+      }
+   }
+   return -1;
+}
+void raydium_anim_instance_destroy(int instance)
+{
+   if(raydium_anim_instance_use[instance])
+   {
+      raydium_anim_cal3d_instance_destroy(instance);
+   }   
+}
+void raydium_anim_instances_destroy()
+{
+   int a;
+   for(a=0;a<RAYDIUM_ANIM_MAX_INSTANCES;a++)
+   {
+      raydium_anim_instance_destroy(a);
+   }
+}
+int raydium_anim_instance_new(int model)
+{
+   int a;
+   for(a=0;a<RAYDIUM_ANIM_MAX_INSTANCES;a++)
+   {
+      if(raydium_anim_instance_use[a]==0)
+      {         
+         if(raydium_anim_cal3d_instance_new_internal(a,model))
+         {
+            raydium_anim_instance_use[a]=1;
+            raydium_anim_instance_model[a]=model;
+            raydium_log("Created a new instance(%d) of model %d",a,model);
+            
+            return a;
+         }
+         else
+         {
+            raydium_log("ANIM:ERROR: creating instance %d",a);
+            return -1;
+         }
+      }
+   }
+   return -1;
+}
+void raydium_anim_instance_attach_meshes(int instance)
+{
+   if(!raydium_anim_instance_use[instance])
+   {
+      raydium_log("ANIM:ERROR: Instance index %d not valid. ",instance);
+   }
+   else
+   {
+      raydium_anim_cal3d_instance_attach_meshes(instance);
+   }
+}
+void raydium_anim_instance_render_skeleton(int instance)
+{
+   if(raydium_anim_instance_use[instance])
+      raydium_anim_cal3d_instance_render_skeleton(instance);
+   else
+      raydium_log("ANIM:ERROR: Not such instance %d. Nothing to render.",instance);
+}
+void raydium_anim_instance_update(int instance,float delta_time)
+{
+   if(raydium_anim_instance_use[instance] && delta_time>=0.0f)
+      raydium_anim_cal3d_instance_update(instance,delta_time);
+}
+void raydium_anim_animation_scale(int model,int animation,float scale)
+{
+   if(raydium_anim_model_use[model])
+      raydium_anim_cal3d_animation_scale(model,animation,scale);
+   else
+      raydium_log("ANIM:ERROR: Invalid model index");
+}
+void raydium_anim_skeleton_scale(int model,float scale)
+{
+   if(raydium_anim_model_use[model])
+      raydium_anim_cal3d_skeleton_scale( model, scale);
+}
+void raydium_anim_loop_set(int instance,int animation, float influence, float delay_seconds)
+{   
+   raydium_anim_cal3d_loop_set( instance, animation, influence, delay_seconds);
+}
+void raydium_anim_action_remove(int instance,int animation)
+{
+   raydium_anim_cal3d_action_remove(instance,animation);
+}
+void raydium_anim_instance_render(int instance, int type)
+{
+   glPushMatrix();
+   glTranslatef(   raydium_anim_instance_pos_rot[instance][0],
+               raydium_anim_instance_pos_rot[instance][1],
+               raydium_anim_instance_pos_rot[instance][2]);
+   glRotatef(   raydium_anim_instance_pos_rot[instance][3],0,0,1);
+   glRotatef(   raydium_anim_instance_pos_rot[instance][4],0,1,0);
+   glRotatef(   raydium_anim_instance_pos_rot[instance][5],1,0,0);
+   
+   switch(type)
+   {
+      case RAYDIUM_ANIM_RENDER_NONE:
+         //do nothing
+      break;
+      case RAYDIUM_ANIM_RENDER_MESH:
+         raydium_anim_instance_render_mesh(instance);
+      break;
+      case RAYDIUM_ANIM_RENDER_SKELETON:
+         raydium_anim_instance_render_skeleton(instance);
+      break;
+   }
+   glPopMatrix();   
+}
+void raydium_anim_instance_move(int instance,float x, float y, float z)
+{
+   if(raydium_anim_instance_use[instance])
+   {
+      raydium_anim_instance_pos_rot[instance][0]=x;
+      raydium_anim_instance_pos_rot[instance][1]=y;      
+      raydium_anim_instance_pos_rot[instance][2]=z;   
+   }      
+}
+void raydium_anim_instance_move_relative(int instance,float x, float y, float z)
+{
+   if(raydium_anim_instance_use[instance])
+   {
+      raydium_anim_instance_pos_rot[instance][0]+=x;
+      raydium_anim_instance_pos_rot[instance][1]+=y;      
+      raydium_anim_instance_pos_rot[instance][2]+=z;   
+   }      
+}
+void raydium_anim_instance_rotate(int instance,float x, float y, float z)
+{
+   if(raydium_anim_instance_use[instance])
+   {
+      raydium_anim_instance_pos_rot[instance][3]=x;
+      raydium_anim_instance_pos_rot[instance][4]=y;      
+      raydium_anim_instance_pos_rot[instance][5]=z;   
+   }      
+}
+void raydium_anim_instance_rotate_relative(int instance,float x, float y, float z)
+{
+   if(raydium_anim_instance_use[instance])
+   {
+      raydium_anim_instance_pos_rot[instance][3]+=x;
+      raydium_anim_instance_pos_rot[instance][4]+=y;      
+      raydium_anim_instance_pos_rot[instance][5]+=z;   
+   }      
+}
+
+void raydium_anim_instance_render_mesh(int instance)
+{
+   if(raydium_anim_instance_use[instance])
+      raydium_anim_cal3d_instance_render_mesh(instance);
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+void raydium_anim_model_materials_apply(int instance, int set)
+{
+   raydium_anim_cal3d_model_materials_apply(instance,set);
+}
+void raydium_anim_model_lod_set(int instance, float lod_level)
+{
+   raydium_anim_cal3d_model_lod_set(instance,lod_level);
+}
+void raydium_anim_action_set(int instance,int animation, float fadein_seconds, float fadeout_seconds, int autolock)
+{
+   raydium_anim_cal3d_action_set(instance,animation, fadein_seconds, fadeout_seconds,autolock);
+}
+void raydium_anim_loop_clear(int instance,int animation, float delay_seconds)
+{
+   raydium_anim_cal3d_loop_clear(instance,animation, delay_seconds);
+}
+
+/*********************************************************************/
+/*******************  CAL3D FUNCTIONS           **********************/
+/*********************************************************************/
+
+void raydium_anim_cal3d_instance_render_skeleton(int instance)
+{
+float lines[1024][2][3];
+int nrLines;
+float points[1024][3];
+int nrPoints;
+struct CalSkeleton *tmpskel;
+if(!raydium_anim_instance_use[instance])
+   {
+   raydium_log("ANIM:ERROR: Instance index %d not valid. ",instance);
+   }
+else
+   {
+   // draw the bone lines
+   //tmpskel=(struct CalSkeleton *)CalModel_GetSkeleton(raydium_anim_instance[instance]);
+   //nrLines=CalSkeleton_GetBoneLines(tmpskel,&lines[0][0][0]);
+   nrLines=CalSkeleton_GetBoneLines(CalModel_GetSkeleton(raydium_anim_instance[instance]),&lines[0][0][0]);
+
+   glLineWidth(3.0f);
+   glColor3f(1.0f, 1.0f, 1.0f);
+   glBegin(GL_LINES);
+   int currLine;
+   for(currLine = 0; currLine < nrLines; currLine++)
+      {
+      glVertex3f(lines[currLine][0][0], lines[currLine][0][1], lines[currLine][0][2]);
+      glVertex3f(lines[currLine][1][0], lines[currLine][1][1], lines[currLine][1][2]);
+      }
+   glEnd();
+   glLineWidth(1.0f);
+
+   // draw the bone points
+   nrPoints = CalSkeleton_GetBonePoints(CalModel_GetSkeleton(raydium_anim_instance[instance]),&points[0][0]);
+
+   glPointSize(4.0f);
+   glBegin(GL_POINTS);
+   glColor3f(0.0f, 0.0f, 1.0f);
+   int currPoint;
+   for(currPoint = 0; currPoint < nrPoints; currPoint++)
+      {
+      glVertex3f(points[currPoint][0], points[currPoint][1], points[currPoint][2]);
+      }
+   glEnd();
+   glPointSize(1.0f);
+   }
+}
+
+void raydium_anim_cal3d_instance_update(int instance,float delta_time)
+{   
+   if(raydium_anim_instance_use[instance] && delta_time>0.0f)
+      CalModel_Update(raydium_anim_instance[instance],delta_time);
+}
+
+void raydium_anim_cal3d_animation_scale(int model,int animation,float scale)
+{   
+   if(raydium_anim_model_use[model])
+      CalCoreAnimation_Scale(CalCoreModel_GetCoreAnimation(raydium_anim_model[model],animation),scale);
+   else
+      raydium_log("ANIM:ERROR: Invalid model index");
+}
+
+void raydium_anim_cal3d_skeleton_scale(int model,float scale)
+{
+   if(raydium_anim_model_use[model])
+      CalCoreSkeleton_Scale(CalCoreModel_GetCoreSkeleton(raydium_anim_model[model]),(float)scale);
+   else
+      raydium_log("ANIM:ERROR: Invalid model index");
+}
+
+void raydium_anim_cal3d_instance_render_mesh(int instance)
+{
+   if(raydium_anim_instance[instance])
+   {      
+      int bWireframe=0;
+      // get the renderer of the model
+      struct CalRenderer *pCalRenderer;      
+      pCalRenderer = CalModel_GetRenderer(raydium_anim_instance[instance]);
+
+      // begin the rendering loop      
+      if(!CalRenderer_BeginRendering(pCalRenderer)) return;
+
+      // set wireframe mode if necessary
+      if(bWireframe)
+      {
+         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+      }
+
+      // set the global OpenGL states
+      //glEnable(GL_DEPTH_TEST);
+      glShadeModel(GL_SMOOTH);
+      
+
+      // we will use vertex arrays, so enable them
+      glEnableClientState(GL_VERTEX_ARRAY);
+      glEnableClientState(GL_NORMAL_ARRAY);
+
+      // get the number of meshes
+      int meshCount;      
+      meshCount = CalRenderer_GetMeshCount(pCalRenderer);
+
+      // render all meshes of the model
+      int meshId;
+      for(meshId = 0; meshId < meshCount; meshId++)
+         {
+         // get the number of submeshes
+         int submeshCount;      
+         submeshCount = CalRenderer_GetSubmeshCount(pCalRenderer,meshId);
+
+         // render all submeshes of the mesh
+         int submeshId;
+         for(submeshId = 0; submeshId < submeshCount; submeshId++)
+            {
+            // select mesh and submesh for further data access       
+            if(CalRenderer_SelectMeshSubmesh(pCalRenderer,meshId,submeshId))
+               {
+               unsigned char meshColor[4];
+               GLfloat materialColor[4];
+
+               // set the material ambient color         
+               CalRenderer_GetAmbientColor(pCalRenderer, &meshColor[0]);
+               materialColor[0] = meshColor[0] / 255.0f;  materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
+               //glMaterialfv(GL_FRONT, GL_AMBIENT, materialColor);
+
+               // set the material diffuse color         
+               CalRenderer_GetDiffuseColor(pCalRenderer,&meshColor[0]);
+               materialColor[0] = meshColor[0] / 255.0f;  materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
+               //glMaterialfv(GL_FRONT, GL_DIFFUSE, materialColor);
+
+               // set the vertex color if we have no lights
+               if(1)
+               {
+                  glColor4fv(materialColor);
+               }
+
+               // set the material specular color         
+               CalRenderer_GetSpecularColor(pCalRenderer,&meshColor[0]);
+               materialColor[0] = meshColor[0] / 255.0f;  materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
+               //glMaterialfv(GL_FRONT, GL_SPECULAR, materialColor);
+
+               // set the material shininess factor
+               float shininess;
+               shininess = 50.0f; //TODO: pCalRenderer->getShininess();
+               shininess = CalRenderer_GetShininess(pCalRenderer);
+               //glMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
+
+               // get the transformed vertices of the submesh
+               static float meshVertices[30000][3];
+               int vertexCount;         
+               vertexCount = CalRenderer_GetVertices(pCalRenderer,&meshVertices[0][0]);
+
+               // get the transformed normals of the submesh
+               static float meshNormals[30000][3];         
+               CalRenderer_GetNormals(pCalRenderer, &meshNormals[0][0]);
+
+               // get the texture coordinates of the submesh
+               static float meshTextureCoordinates[30000][2];
+               int textureCoordinateCount;
+               textureCoordinateCount = CalRenderer_GetTextureCoordinates(pCalRenderer,0,&meshTextureCoordinates[0][0]);
+
+               // get the faces of the submesh
+               static CalIndex meshFaces[50000][3];
+               int faceCount;
+               faceCount = CalRenderer_GetFaces(pCalRenderer,&meshFaces[0][0]);
+
+               // set the vertex and normal buffers
+               glVertexPointer(3, GL_FLOAT, 0, &meshVertices[0][0]);
+               glNormalPointer(GL_FLOAT, 0, &meshNormals[0][0]);
+
+               // set the texture coordinate buffer and state if necessary
+               if(CalRenderer_GetMapCount(pCalRenderer)>0 && (textureCoordinateCount > 0))
+                  {
+                  glEnable(GL_TEXTURE_2D);
+                  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                  glEnable(GL_COLOR_MATERIAL);
+
+                  // set the texture id we stored in the map user data          
+                  glBindTexture(GL_TEXTURE_2D, (GLuint)CalRenderer_GetMapUserData(pCalRenderer,0));
+                  // set the texture coordenates buffer
+                  glColor4f(1.0f, 1.0f, 1.0f,1.0f);
+                  glTexCoordPointer(2, GL_FLOAT, 0, &meshTextureCoordinates[0][0]);
+                  glColor4f(1.0f, 1.0f, 1.0f,1.0f);
+                  }
+
+               // draw the submesh
+
+               if(sizeof(CalIndex)==2)
+               glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]);
+               else
+               glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_INT, &meshFaces[0][0]);
+
+               // disable the texture coordinate state if necessary
+               if(CalRenderer_GetMapCount(pCalRenderer)>0  && (textureCoordinateCount > 0))
+                  {
+                  glDisable(GL_COLOR_MATERIAL);
+                  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+                  glDisable(GL_TEXTURE_2D);
+                  }
+               ////////////////////////////////////////////////////////////////////////////////
+               //to show vertex normals do if(1)
+               if(0)
+                  {
+                  glBegin(GL_LINES);
+                  glColor3f(1.0f, 1.0f, 1.0f);
+                  int vertexId;
+                  for(vertexId = 0; vertexId < vertexCount; vertexId++)
+                  {
+                  const float scale = 0.3f;
+                  glVertex3f(meshVertices[vertexId][0], meshVertices[vertexId][1], meshVertices[vertexId][2]);
+                  glVertex3f(meshVertices[vertexId][0] + meshNormals[vertexId][0] * scale, meshVertices[vertexId][1] + meshNormals[vertexId][1] * scale, meshVertices[vertexId][2] + meshNormals[vertexId][2] * scale);
+                  }
+                  glEnd();
+                  }
+               ////////////////////////////////////////////////////////////////////////////////
+               GLfloat one[]={0.8f, 0.8f, 0.8f, 1.f};
+                 GLfloat zero[]={0.0,0.0,0.0,0.0};
+               glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, one);
+               glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, zero);
+               glEnable(GL_TEXTURE_2D);
+               glBindTexture(GL_TEXTURE_2D,0);
+               }
+            }
+         }
+
+      // clear vertex array state
+      glDisableClientState(GL_NORMAL_ARRAY);
+      glDisableClientState(GL_VERTEX_ARRAY);
+
+      // reset wireframe mode if necessary
+      if(bWireframe)
+      {
+         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+      }
+
+      // end the rendering
+      CalRenderer_EndRendering(pCalRenderer);
+   }
+}
+
+void raydium_anim_cal3d_loop_set(int instance,int animation, float influence, float delay_seconds)
+{
+   if(raydium_anim_instance_use[instance])
+      if(delay_seconds>=0)
+         if(influence>=0 && influence<=1   )         
+            CalMixer_BlendCycle(CalModel_GetMixer(raydium_anim_instance[instance]),raydium_anim_animationid[raydium_anim_instance_model[instance]][animation],influence,delay_seconds);   
+         else
+            raydium_log("ANIM:ERROR: Influence must be betwen 0 and 1");
+      else
+         raydium_log("ANIM:ERROR: invalid delay time for setting loop in instance %d",instance);
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index");
+}   
+
+void raydium_anim_cal3d_loop_clear(int instance,int animation, float delay_seconds)
+{
+   if(raydium_anim_instance_use[instance])   
+      if(delay_seconds>=0)         
+         CalMixer_ClearCycle(CalModel_GetMixer(raydium_anim_instance[instance]),raydium_anim_animationid[raydium_anim_instance_model[instance]][animation],delay_seconds);   
+      else
+         raydium_log("ANIM:ERROR: invalid delay time for clearing loop in instance %d",instance);
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+
+void raydium_anim_cal3d_action_set(int instance,int animation, float fadein_seconds, float fadeout_seconds, int autolock)
+{
+   if(raydium_anim_instance_use[instance])
+      if(fadein_seconds>=0 && fadeout_seconds>=0)
+         CalMixer_ExecuteAction(CalModel_GetMixer(raydium_anim_instance[instance]),raydium_anim_animationid[raydium_anim_instance_model[instance]][animation],fadein_seconds, fadeout_seconds,autolock);
+      else
+         raydium_log("ANIM:ERROR: Fadein_seconds and fadeout seconds must be positive");
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+
+void raydium_anim_cal3d_model_lod_set(int instance, float lod_level)
+{
+   if(raydium_anim_instance_use[instance])
+      CalModel_SetLodLevel(raydium_anim_instance[instance],lod_level);
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+
+void raydium_anim_cal3d_model_materials_apply(int instance, int set)
+{
+   if(raydium_anim_instance_use[instance])
+      CalModel_SetMaterialSet(raydium_anim_instance[instance],set);
+   else
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+
+void raydium_anim_cal3d_action_remove(int instance, int animation)
+{   
+   if(raydium_anim_instance_use[instance])
+      CalMixer_RemoveAction((CalModel_GetMixer(raydium_anim_instance[instance])),animation);
+   else   
+      raydium_log("ANIM:ERROR: Invalid instance index.");
+}
+
+int raydium_anim_cal3d_instance_new_internal(int num,int model)
+{
+   if(!raydium_anim_instance_use[num])
+   {
+      raydium_anim_instance[num]=CalModel_New(raydium_anim_model[num]);
+      
+      if(raydium_anim_instance[num])
+         {
+         
+         return 1;
+         }
+      else
+         {
+         return 0;
+         }
+   }
+   else
+   {
+      raydium_log("ANIM:ERROR: that instance alread in use. Bad index");
+      return 0;
+   }
+}
+void raydium_anim_cal3d_instance_destroy(int instance)
+{
+   CalModel_Delete(raydium_anim_instance[instance]);
+}
+
+void raydium_anim_cal3d_instance_attach_meshes(int instance)
+{
+   int b;
+   int model;
+   if(raydium_anim_instance[instance])
+      {
+      model   =   raydium_anim_instance_model[instance];   
+      for(b=0;b<raydium_anim_meshes[model];b++)
+      {
+         CalModel_AttachMesh(raydium_anim_instance[instance], raydium_anim_meshid[model][b]);      
+      }
+      raydium_log("Added %d meshes to model %d for instancde %d",raydium_anim_meshes[model],model,instance);
+      }
+   else
+      {
+      raydium_log("ANIM:ERROR: Instance index %d not valid. ",instance);
+      }   
+}
+
+int raydium_anim_cal3d_model_load_internal(int a,char *filename)
+{
+   FILE *file;
+   char str[RAYDIUM_MAX_NAME_LEN];
+   char strpath[RAYDIUM_MAX_NAME_LEN];
+   char filename2[RAYDIUM_MAX_NAME_LEN];
+   char newstr[RAYDIUM_MAX_NAME_LEN];
+   int ret;
+   int error;
+   char var[RAYDIUM_MAX_NAME_LEN];
+   char val_s[RAYDIUM_MAX_NAME_LEN];
+   GLfloat val_f[5];
+   int size;   
+   //   counters
+   int ani_count;
+   int mesh_count;
+   int mat_count;   
+   float scale;
+   
+   ani_count=0;
+   mesh_count=0;
+   mat_count=0;
+   scale=1.0f;
+   error=0;
+   
+   //check if a is available
+   if(!raydium_anim_model[a])
+   {
+      sprintf(str,"raydium_model_%d",a);
+      
+      raydium_anim_model[a]=(struct CalCoreModel*)CalCoreModel_New(str);
+      //the filename should be a cfg!!!
+      //TODO:check 4 last letters
+      //convert filename into ray-path-compatible format
+      raydium_path_resolv(filename,filename2,'r');
+      if(file=raydium_file_fopen(filename2,"r"))
+      {
+         raydium_log("readed file cfg");
+         while( (ret=raydium_parser_read(var,val_s,val_f,&size,file))!=RAYDIUM_PARSER_TYPE_EOF)
+            {
+               
+               //*** PATH ***
+               if(!strcasecmp(var,"path"))
+               {
+                  raydium_file_dirname(strpath,filename2);
+                  strcat(strpath,val_s);
+                  raydium_log("The path will be: \"%s\"",strpath);
+               }
+               
+               //*** SKELETON ***
+               if(!strcasecmp(var,"skeleton"))
+               {
+                  raydium_log("Readed: %s",(char*)val_s);
+                  sprintf(newstr,"%s%s",strpath,val_s);   
+                  //load the skeleton
+                  if(CalCoreModel_LoadCoreSkeleton(raydium_anim_model[a],newstr))
+                  {
+                     //aply scale
+                     CalCoreSkeleton_Scale(CalCoreModel_GetCoreSkeleton(raydium_anim_model[a]),scale);
+                     raydium_log("Successfully loaded %s",newstr);
+                  }   
+                  else
+                  {
+                     raydium_log("ANIM:ERROR: Loading file %s",newstr);
+                     error=1;
+                  }               
+               }
+               
+               //*** SCALE ***
+               if(!strcasecmp(var,"scale"))
+               {   
+                  scale=val_f[0];
+               }
+               
+               //*** ANIMS ***
+               if(!strcasecmp(var,"animation"))
+               {
+                  
+                  raydium_log("Readed: %s",(char*)val_s);
+                  sprintf(newstr,"%s%s",strpath,val_s);   
+                  //load the animation
+                  raydium_anim_animationid[a][ani_count]=CalCoreModel_LoadCoreAnimation(raydium_anim_model[a],newstr);                  
+                  if(raydium_anim_animationid[a][ani_count]!=-1)
+                  {
+                     CalCoreAnimation_Scale(CalCoreModel_GetCoreAnimation(raydium_anim_model[a],raydium_anim_animationid[a][ani_count]),scale);                        
+                     ani_count++;
+                     raydium_log("Successfully loaded animation: %s",newstr);
+                     raydium_anim_animations[a]++;
+                  }         
+                  else
+                  {
+                     error=1;
+                  }                  
+               }
+               
+               //*** MESH ***
+               if(!strcasecmp(var,"mesh"))
+               {   
+                  raydium_log("Readed: %s",(char*)val_s);
+                  sprintf(newstr,"%s%s",strpath,val_s);
+                  raydium_anim_meshid[a][mesh_count]=CalCoreModel_LoadCoreMesh(raydium_anim_model[a],newstr);   
+                  if(raydium_anim_meshid[a][mesh_count]!=-1)
+                  {
+                     CalCoreMesh_Scale(CalCoreModel_GetCoreMesh(raydium_anim_model[a],raydium_anim_meshid[a][mesh_count]),scale);
+                     mesh_count++;
+                     raydium_log("Successfully loaded mesh:%s",newstr);
+                     raydium_anim_meshes[a]++;                     
+                  }      
+                  else
+                  {
+                     error=1;
+                  }            
+               }
+               
+               //*** MATERIALS ***
+               if(   !strcasecmp(var,"material"))
+               {
+                  raydium_log("Readed: %s",(char*)val_s);
+                  sprintf(newstr,"%s%s",strpath,val_s);
+                  raydium_anim_materialid[a][mat_count]=CalCoreModel_LoadCoreMaterial(raydium_anim_model[a],newstr);   
+                  if(raydium_anim_materialid[a][mat_count]!=-1)
+                  {                     
+                     mat_count++;
+                     raydium_log("Successfully loaded material:%s",newstr);
+                     raydium_anim_materials[a]++;                                       
+                  }
+                  else
+                  {
+                     error=1;
+                  }                  
+               }      
+            }                  
+         fclose(file);   
+         int c;
+         for(c=0;c<(raydium_anim_materials[a]);c++)
+         {
+            //load textures, if any
+            // get the current core material
+            struct CalCoreMaterial *pCoreMaterial;
+            //pCoreMaterial = myCoreModel.getCoreMaterial(materialId);
+            pCoreMaterial=CalCoreModel_GetCoreMaterial(raydium_anim_model[a],raydium_anim_materialid[a][c]);
+            
+            // dont use, just helper -> CalCoreMaterial_GetMapCount(CalCoreModel_GetCoreMaterial(raydium_anim_model[a]))
+            // loop through all the maps of the current core material
+            int mapid;
+            for(mapid = 0; mapid < CalCoreMaterial_GetMapCount(pCoreMaterial); mapid++)
+            {
+               // get the filename of the map
+               char strFilename[RAYDIUM_MAX_NAME_LEN];
+               strcpy(strFilename,CalCoreMaterial_GetMapFilename(pCoreMaterial,mapid));
+
+               // load the texture from the file
+               //Cal::UserData textureId;
+               //struct CalUserData textureid;
+               GLuint textureid;
+               //textureId = (Cal::UserData)myTextureLoadingFunction(strFilename);
+               //TODO:Ugly way to allow this path for textures
+               sprintf(newstr,"%s%s",strpath,strFilename);
+               raydium_path_add(strpath);
+               textureid=raydium_texture_load(strFilename);
+
+               // store the texture id in the user data of the map
+               //pCoreMaterial->setMapUserData(mapId, textureId);
+               //CalCoreMaterial_SetMapUserData(mapid,textureid);
+               CalCoreMaterial_SetMapUserData(pCoreMaterial,mapid,(int*)textureid);         
+            
+            }
+            
+            CalCoreModel_CreateCoreMaterialThread(raydium_anim_model[a],c);
+            
+            CalCoreModel_SetCoreMaterialId(raydium_anim_model[a],c,0,c);
+            
+            //CalCoreModel_SetCoreMaterialId(raydium_anim_model[a],c,0,c);
+            
+            //m_calCoreModel->createCoreMaterialThread(materialId);
+            // initialize the material thread
+            //m_calCoreModel->setCoreMaterialId(materialId, 0, materialId);
+         }      
+      }
+      else
+      {
+         raydium_log("ANIM:ERROR: Couldn't open file \"%s\".",filename);
+         error=1;
+      }
+   }
+   else
+   {
+      raydium_log("ANIM:ERROR:raydium_anim_model[%d] was not unset",a);
+      error=1;
+   }
+   
+   if(error)
+      return 0;
+   else      
+      return 1;      
+}
Index: raydium/index.c
===================================================================
--- raydium/index.c   (revisión: 798)
+++ raydium/index.c   (copia de trabajo)
@@ -63,6 +63,7 @@
 #include "hdr.c"
 #include "shader.c"
 #include "register.c"
+#include "anim.h"
 #ifdef PHP_SUPPORT
 #include "php.c"
 #include "rayphp.c"
Index: raydium/index.h
===================================================================
--- raydium/index.h   (revisión: 798)
+++ raydium/index.h   (copia de trabajo)
@@ -57,6 +57,7 @@
 #include "headers/hdr.h"
 #include "headers/shader.h"
 #include "headers/register.h"
+#include "headers/anim.h"
 #ifdef PHP_SUPPORT
 #include "headers/php.h"
 #include "headers/rayphp.h"
Index: raydium/headers/anim.h
===================================================================
--- raydium/headers/anim.h   (revisión: 0)
+++ raydium/headers/anim.h   (revisión: 0)
@@ -0,0 +1,227 @@
+#ifndef _ANIM_H
+#define _ANIM_H
+#include <cal3d/cal3d_wrapper.h>
+
+//TODO:This should be in other place
+#define RAYDIUM_ANIM_CAL3D
+#define RAYDIUM_ANIM_MAX_MODELS 20
+#define RAYDIUM_ANIM_RENDER_NONE 0
+#define RAYDIUM_ANIM_RENDER_MESH 1
+#define RAYDIUM_ANIM_RENDER_SKELETON 2
+
+//-----------------------------------------------------------
+//Doxygen testing doc
+/*! \page animatedmodels Animated Models
+
+Raydium allows you to use Animated Models in Cal3D(http://home.gna.org/cal3d/) format.
+It's important to know well how cal3d animation works before starting to suing it.
+
+A common cal3d model is compound of:
+
+-.cfg file with a few parameters and a list of used files
+-.csf file with the unique skeleton per model
+-.caf or .xaf files, each one is 1 animation loop/action for the current model
+-.crf or .xrf files, each one is a material
+-.cmf or .xmf files, each one is a mesh to apply in the model
+*
+Note: "x-starting" files are XML files and easy to edit. By other side "c-starting" files are binary compiled files. They can not be edited but are faster to load.
+
+
+So raydium will load the cfg file an, internally, it will load all needed subfiles.
+The models can NOT be used directly so, once loaded the model you MUST create instances of the model for your application.
+Then you can apply loops or actions to each instance independently.
+
+
+Types of animations:
+
+Even if the animation files are the same, you can apply that animation as a loop or as an action.
+Loops: the animation loops forever (until you deactivate it)
+Actions: The animation will play just once, and you can set a lock. If the action is locked, the instance will be keep in the last frame of the animation, else it will return to the previous animation fame(if any).
+
+Mixing:
+
+To achieve good animations you will have to mix diferent animations at time.
+For example your model could be walking and sometimes it could throw an arrow.
+
+TODO: more explanation about mixing
+*/
+
+//-----------------------------------------------------------
+
+
+/*=
+Animation System
+2200
+Raydium allows you to use Animated Models in Cal3D(http://home.gna.org/cal3d/) format.
+It's important to know well how cal3d animation works before starting to suing it.
+
+A common cal3d model is compound of:
+
+-.cfg file with a few parameters and a list of used files
+-.csf file with the unique skeleton per model
+-.caf or .xaf files, each one is 1 animation loop/action for the current model
+-.crf or .xrf files, each one is a material
+-.cmf or .xmf files, each one is a mesh to apply in the model
+*
+Note: "x-starting" files are XML files and easy to edit. By other side "c-starting" files are binary compiled files. They can not be edited but are faster to load.
+
+
+So raydium will load the cfg file an, internally, it will load all needed subfiles.
+The models can NOT be used directly so, once loaded the model you MUST create instances of the model for your application.
+Then you can apply loops or actions to each instance independently.
+
+
+Types of animations:
+
+Even if the animation files are the same, you can apply that animation as a loop or as an action.
+Loops: the animation loops forever (until you deactivate it)
+Actions: The animation will play just once, and you can set a lock. If the action is locked, the instance will be keep in the last frame of the animation, else it will return to the previous animation fame(if any).
+
+Mixing:
+
+To achieve good animations you will have to mix diferent animations at time.
+For example your model could be walking and sometimes it could throw an arrow.
+
+TODO: more explanation about mixing
+
+**/
+
+// Introduction
+/**
+EXPERIMENTAL: DONT USE!
+Animation system
+Based on Cal3D.
+**/
+
+
+__rayapi int raydium_anim_model_load(char *filename);
+/**
+EXPERIMENTAL: DONT USE!
+This function loads a model.
+Currently only Cal3D models are allowed. So you have to specify a *.cfg file in
+the ##filename##.
+
+##Parameters:##
+##model##:the index of the model to instanciate
+
+##Returns:##
+the index of the new model, or -1 if fails
+
+##Example:##
+%%(c)
+int paladin_model;
+int create_model_paladin(void)
+   {
+   paladin_model=raydium_anim_model_load("paladin.cfg");
+   return
+   }
+%%
+**/
+
+__rayapi int raydium_anim_cal3d_model_load_internal(int a,char *filename);
+/**
+EXPERIMENTAL: DONT USE!
+Internal.
+**/
+
+__rayapi void raydium_anim_models_destroy(void);
+/**
+EXPERIMENTAL: DONT USE!
+Destroy all models used in raydium.
+Beware. You should destroy all instances BEFORE call this function.
+**/
+
+__rayapi void raydium_anim_init(void);
+/**
+EXPERIMENTAL: DONT USE!
+Init the animation system of raydium.
+**/
+
+
+__rayapi int raydium_anim_instance_new(int model);
+/**
+EXPERIMENTAL: DONT USE!
+Creates a new instance from a ##model##.
+
+##Parameters:##
+##model##:the index of the model to instanciate
+
+##Returns:##
+The index of the new instance
+
+##Example:##
+%%(c)
+int paladin_instance[2];
+int paladin_model;
+void create_paladin_instances(void)
+   {
+      paladin_model=create_model_paladin();
+      paladin_instance[0]=raydium_anim_instance_new(paladin_model);
+      paladin_instance[1]=raydium_anim_instance_new(paladin_model);      
+   }
+%%
+**/
+
+__rayapi void raydium_anim_instance_update(int instance,float time);
+/**
+EXPERIMENTAL: DONT USE!
+This function is a must if you want to animate you models(instances).
+
+##Parameters:##
+##instance##:the index of the instance
+##time##: The time betwen the last call to thin function and this call.
+Commonly this value is equal to ##raydium_frame_time##
+
+##Returns:##
+
+##Example:##
+%%(c)
+void display(void)
+   {
+   if(raydium_key_last==1027)
+   exit(0);
+   raydium_clear_frame();
+   raydium_camera_freemove(RAYDIUM_CAMERA_FREEEMOVE_NORMAL);   
+   raydium_ode_draw_all(0);
+   raydium_anim_instance_update(character,raydium_frame_time);   
+   raydium_anim_instance_render_mesh(character);
+   raydium_rendering_finish();
+   }
+%%
+**/
+__rayapi void raydium_anim_instance_update(int instance,float delta_time);
+__rayapi void raydium_anim_instance_render_skeleton(int instance);
+__rayapi int raydium_anim_model_load(char *filename);
+__rayapi int raydium_anim_instance_new(int model);
+__rayapi void raydium_anim_instances_destroy();
+__rayapi void raydium_anim_models_destroy(void);
+__rayapi void raydium_anim_instance_attach_meshes(int instance);
+__rayapi void raydium_anim_cal3d_instance_attach_meshes(int instance);
+__rayapi void raydium_anim_cal3d_instance_render_mesh(int instance);
+__rayapi void raydium_anim_loop_set(int instance,int animation, float influence, float delay_seconds);
+__rayapi void raydium_anim_cal3d_loop_set(int instance,int animation, float influence, float delay_seconds);
+__rayapi void raydium_anim_loop_clear(int instance,int animation, float delay_seconds);
+__rayapi void raydium_anim_cal3d_loop_clear(int instance,int animation, float delay_seconds);
+__rayapi void raydium_anim_action_set(int instance,int animation, float fadein_seconds, float fadeout_seconds, int autolock);
+__rayapi void raydium_anim_cal3d_action_set(int instance,int animation, float fadein_seconds, float fadeout_seconds, int autolock);
+__rayapi void raydium_anim_cal3d_model_lod_set(int instance, float lod_level);
+__rayapi void raydium_anim_model_lod_set(int instance, float lod_level);
+__rayapi void raydium_anim_cal3d_model_materials_apply(int instance, int set);
+__rayapi void raydium_anim_model_materials_apply(int instance, int set);
+__rayapi void raydium_anim_instance_render_mesh(int instance);
+__rayapi void raydium_anim_cal3d_action_remove(int instance, int animation);
+__rayapi void raydium_anim_action_remove(int instance,int animation);
+__rayapi void raydium_anim_cal3d_instance_render_skeleton(int instance);
+__rayapi void raydium_anim_skeleton_scale(int model,float scale);
+__rayapi void raydium_anim_cal3d_instance_update(int instance, float time);
+__rayapi void raydium_anim_cal3d_animation_scale(int model,int animation,float scale);
+__rayapi void raydium_anim_cal3d_skeleton_scale(int model,float scale);
+__rayapi void raydium_anim_cal3d_instance_destroy(int instance);
+__rayapi void raydium_anim_instance_render(int instance, int type);
+__rayapi void raydium_anim_instance_move(int instance,float x, float y, float z);
+__rayapi void raydium_anim_instance_move_relative(int instance,float x, float y, float z);
+__rayapi void raydium_anim_instance_rotate(int instance,float x, float y, float z);
+__rayapi void raydium_anim_instance_rotate_relative(int instance,float x, float y, float z);
+
+#endif
+