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.
Guau!!! tiene buena pinta XD, muy bueno. de momento te adelanto el karma.
Karma++;
Suerte con el port.
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.
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
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
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