[OrganicMotionLIB] Librería para interpolación orgánica.

[Erkosone]

Estos días he estado programando algo de sonido para mi placa de Arduino, y leyendo en algunas web vi que el trabajo que estaba portando a arduino era útil también para programación de juegos, así que en breve publicaré un ejemplo de uso y la librería en su versión 1.0.


La he probado en otro divLike y parece que funciona bastante bien, así que en BennuGD debería funcionar también.
Supongo que esta misma tarde tendré lista la primera versión, creo que os gustará, sirve para casi cualquier cosa, movimiento, animación, size..


La librería de formulas no es mía por supuesto, es un port a este lenguaje desde lo que he encontrado en la web para C++.


Lo mejor, que está el lenguaje nativo BennuGD y es completamente visible/modificable y es extremadamente sencilla de usar.
En unas horas intentaré que esté ya publicada "junto con los tutoriales de iniciación a Schism Tracker que se están compilando ahora mismo".
Un saludo.

[alex]

Guau!!! tiene buena pinta XD, muy bueno. de momento te adelanto el karma.
Karma++;
Suerte con el port.

[Erkosone]

Creo que no va a haber ningún contratiempo.. bennu creo que tiene todas las funciones básicas de trigonometría que necesito, lo que pasa es que estas formulas funcionan con radianes y en bennu la cosa va con angulos escalados "como en div", pero vaya.. que supongo que no será demasiado problema, estoy en ello, en cuanto lo tenga terminado lo cuelgo.

[KeoH]

Estas ultimamente q te sales de la pelleja compartiendo cosas xDDD Gracias y mas karmas! xD

PD: En cuanto me deje el sistema ponerte otro karma xD

[Erkosone]

Gracias hombre.


Bueno ahí va, el caso es que estas formulas están pensadas para trabajar con radianes, lo cual debería ser compatible con los grados pero no estoy seguro por que se que algunos números de los que aparecen son factores de conversión.


Algunas no funcionan por el tema de la unidad con la que se trabaja pero otras si "las mas sencillas".
Os pego el source y el link a la web donde se puede ver el efecto que debería dar en bennu, debería ser exactamente igual.


Si alguien sabe como arreglar esto que no se corte, así aprendemos todos  ;D

Code Select Expand


Import "mod_text";
Import "mod_video";
Import "mod_key";
Import "mod_proc";
Import "mod_mouse";
Import "mod_map";
Import "mod_screen";
Import "mod_math";
Import "mod_grproc";
Import "mod_sound";
Import "mod_wm";






process main();
private
    float var_1;
    float var_2;
    float var_3;
   
    int tween_1;
    int tween_2;
    int tween_3;
   
begin
    set_mode(600,400,32);
    set_fps(60,0);
write(0,300,10,4,"ORGANIC MOTION TWEEN LIB TEST");
for(x=0; x<15; x++)
test( x );
end
frame;
end




process Test(int mode_);
private
float var_;
int tween_id;
begin
// colocar al objeto en pantalla..
x = 100 + (100 * mode_);
y = 100;
if(mode_ => 5)
x -= 500;
y += 100;
end
if(mode_ => 10)
x -= 500;
y += 100;
end
// crearle un gráfico..
graph = new_map(50,50,16);
map_clear(file, graph, rgb(200,100,100));

loop
// organic tween loop control..
        if(!exists(tween_id))
            tween_id = organicTween_new( &var_, 50.0, 100.0, mode_, 2.0 );
        end
size = var_;
frame;
end
end











// ADVANCED ORGANIC TWEEN MODULATOR v1.0
// Parameters:                     &variable   min value     max value     mode     time in secs.. 
process organicTween_new( float * container_, float min_, float max_, int mode_, float time_ )
private
    float delta_ = 0.0;
    float size_  = 0.0;
    float steep_ = 0.0;
    float fps_;
    float rango_;

begin
    fps_ = fps;
    //steep_ = (2.0 * PI) /(time_ * 60.0);
steep_ = 360000.0 / ( time_ * 60.0 );
    rango_ = max_ - min_;
    loop
        delta_ += steep_;
       
switch(mode_)
            case 0:
                size_ = cos(delta_);
            end
            case 1:
                size_ = sin(delta_);
            end
            case 2:
                size_ = cos(delta_) * sin(delta_);
            end
            case 3:
                size_ = sin(delta_) * sin(delta_ * 1.5 );
            end
            case 4:
                size_ = sin(tan( cos(delta_) * 1.2 ));
            end
            case 5:
                size_ = sin(tan(delta_) * 0.05);
            end
            case 6:
                size_ = cos(sin(delta_ * 3.0)) * sin(delta_ * 0.2);
            end
            case 7:
                size_ = sin(pow(8.0, sin(delta_)));
            end
            case 8:
                size_ = sin(exp(cos(delta_ * 0.8)) * 2.0);
            end
            case 9:
                size_ = sin(delta_ - PI * tan(delta_) * 0.01);
            end
            case 10:
                size_ = pow(sin(delta_ * pi), 12.0);
            end
            case 11:
                size_ = cos(sin(delta_) * tan(delta_ * pi) * pi / 8.0);
            end
            case 12:
                size_ = sin(tan(delta_) * pow(sin(delta_), 10.0));
            end
            case 13:
                size_ = cos(sin(delta_ * 3.0) + delta_ * 3.0);
            end
            case 14:
                size_ = pow(abs(sin(delta_ * 2.0)) * 0.6, sin(delta_ * 2.0)) * 0.6;
            end
        end
        //if( delta_ > (2.0 * PI) )
if(delta_ > 360000.0)
            break;
        end
        *container_ = (min_ + (rango_* size_));
        frame;
    end
end
   
   


function float exp(float exponente)
private
   int i = 0;
   int ret = 1;
begin
   for (i=0;i<exponente;i++)
      ret = ret *  2.71828;
  end
  return ret;
end



El link para previsualizar el resultado que debe dar: http://codepen.io/soulwire/full/kqHxB