código del día

Dado que muchas veces tengo código suelto y no tengo demasiado tiempo para comentarlo, qué mejor que una sección donde pegar el código sin tener que dar explicaciones a nadie ? XD

Este code lo he visto en los foros de stratos , aunque ya me sonaba de la web de perlin. La verdad que este código es un guiño al pasado, solo hay que ver esto (después de ejecutar el código en C que os pongo lo entendereis).

El code:

main(k){float i,j,r,x,y=-16;while(puts(""),y++<15)
for(x=0;x++<84;putchar(" .:-;!/>)|&IH%*#"[k&15]))
for(i=k=r=0;j=r*r-i*i-2+x/25,i=2*r*i+y/10,j*j+i*i<11&&k++<111;r=j);}

saludos

4k synth

Hace ya tiempo que estaba detrás de codear un synth para 4k. Para el que lea esto y no sepa de lo que estoy hablando, en pocas palabras le puedo decir que es una forma de crear música sintetizando y mezclando sonidos muy básicos.
Después del pequeño juego (4k, ojo, solo windows) que hice para el concurso de stratos, me picó la curiosidad y empecé a buscar recursos relacionados con las 4k. Entre los más destacados encontré esta recopilación, dentro de la cual hay códigos de algunas 4k's y un par de ellas con synth. Después de mirar los códigos, hablar con algunas personas (KILE, shash, slash) hacer prubecillas con matlab, etc he obtenido una serie de pasos que más o menos generan un sonido medianamente pasable.

Se puede decir que un sintetizador está compuesto por 3 elementos:
- oscilador
- filtro paso bajo
- generador de envolvente

El oscilador genera una señal, más o menos pura frecuencialmente, como un seno, señal cuadrada (square), triangular (saw) o, aunque al principio no daba crédito, ruido (un rand() de toda la vida, menudos platos que genera XD).

El filtro (yo uso uno de orden 2) es un paso bajo con frecuencia de corte y resonancia configurables, de esa esta forma podemos quitar los armónicos que queramos de señales como la square o la saw.

El generador de envolventes es un señal que "da forma" a la nota. En función de unos parámetros la nota suena de formas muy diferentes. En este caso es mucho mejor ver una foto:



El siguiente paso es generar una melodía. Para ello a partir de las notas (do,re, mi...) de toda la vida se calcula la frecuencia de oscilación. Con ella se hace vibrar a uno de los tipos de oscilador (el sonido depende mucho del tipo de oscilador) y después de pasar esa señal por el filtro (con los parámetros de frecuencia de corte y resonancia que queramos) se pasa por la envolvente. Esto lógicamente se hace por cada canal y finalmente se mezclan. Cada canal,normalmente, tiene diferentes parámetros en la envolvente y de frecuencia de corte del filtro.

El mayor problema de todo esto surge al generar señales no limitadas en banda. La señales square, noise y saw tienen un espectro infinito, aunque bien es cierto que desciende la potencia de los armónicos a medida que aumenta la frecuencia, muestreandolos a 41000 Hz sigue habiendo un aliasing notable (para el que no sepa que es aliasing, en pocas palabras es el solapamiento del espectro de la señal con réplicas de si mismo). Para solucionar este problema lo ideal es hacer oversampling (tomar más muestras por segundo de las necesarias) y después procesar en discreto, esto es, bajar la frecuencia con un diezmador previo paso por un filtro paso bajo que elimine las componentes no deseadas.

Ahora mismo estoy en fase de coding de una pequeña herramienta para la composión de música, una screen:


Unos links:
- [1] : un editor que se basa más o menos en lo explicado.
- [2] : página con un montón de recursos, sobretodo relacionados con procesado de señal
- [3] : código fuente de una 4k (participó en la breakpoint de este año) liberado hace poco.
- [4] página personal de kb, uno de los miembros de farbrausch. En ella explica conceptos del synth usado en muchas de sus producciones, todo a nivel teórico, nada de coding.

En otro orden de cosas he añadido los links de dos blog que frecuento, pertenecen a dos chavales de la asociación de software libre de la EUP. El blog a Aloriel y el de mario , a que estoy ayudando con su distribución de linux portándole unos scripts de Ruby a python con GTK. Espero que en poco tiempo además de portar creemos cosas interesantes, GTK es potente y simple, pero eso ya en otro post :)
-

un saludo, menuda chapa, ya pegaré el code cuando lo tenga completo.

GNU/Linux

Precisamente ayer estuve en la antigua escuela viendo como los chicos de soleup daban sus conferencias del ciclo de software libre que había ayer y hoy. Legué tarde a la primera charla, trataba sobre lo que era el soft libre en general, sin embargo escuché todo lo que tenía que escuchar. Presidiendo, y parece ser que como invitado especialísimo había un personaje de hispalinux, el cual, haciendo su trabajo, alardeó de que linux era mucho mejor que windows, etc. Mi mayor sorpresa fue cuando preguntó si alguno de los presentes NO había usado soft libre, uno de los que allí estaban levantó la mano y, tirando de guión, el tío en cuestión pregunto: "tú nunca has usado google?" el chaval, lógicamente, respondió que sí. Es posible que el chaval hubiera usado soft libre, pero desde luego el ejemplo de google no es para nada representativo. Es posible que llegara a google usando IE, pasando a través de routers CISCO, etc. Además, qué coño, google no deja el código, por mucho que use linux y herramientas libres no significa que el que use google está usando herramientas libres. Es igual que si abuela haciera tortilla de patata y yo dijera que la he cocinado. Lo peor de todo fue su reacción arrogante cuando se lo fui a comentar después de la charla, se me quitaron todas las ganas de debatir con él. Mi opinión sobre el señor me la quedo para mi.

Lo siguiente fue una presentación de la distribución que están relizando con el objetivo de proveer a los alumnos de herramientas libres para el desarrollo de las prácticas en la carrera. La distribución es SOLEUPIX, tiene un aspecto bastante bueno y los contenidos, teniendo en cuenta mi experiencia en la facultad, son muy apropiados, aunque hay que ver qué tal se suple a herramientas como microsim, matlab, labview, etc.

Cosas que me gustaron:
- El ponente (no penseis mal). me gustó la forma en la que contó las cosas, pecaba de inexperiencia haciendo presentaciones (se repitió bastante), pero lo hizo tranquilo y pausado, no se hacía pesado escucharle y salvo bien los dos cuelgues.
- Los contenidos de la distro: muy apropiados.
- Blender: fue uno de los pocos programas que arrancaron. No hicieron nada, pero rocks.
- El logo: se lo había currado uno de los presentes en la sala. Ruborizado el tío dijo que estaba a medio terminar, aunque tenía muy buen aspecto y encajaba.

lo malo:

- los dos cuelgues: problemas con el entorno gráfico. Una pena, manchó un poco la presentación
- Las constantes alusiones a windows y MS: parece que el mundo libre no ve más allá de MS, otra pena.


Espero que vaya muy bien la distro, es una idea muy buena. Estaría bien poder echar una manita.


PD: estoy bastante desilusionado con el blog, resulta que el post más chorra es el que más comentarios ha generado. Y lo peor, me acaban de pasar otro igual : http://misandanzas.blogcindario.com/

unas risas

Me acaban de pasar este link: http://www.livejournal.com/users/bakala007/

Quiero pensar que es una historia de ficción bien montada. La verdad es que cada post tiene un huevo de respuestas.

Nintenderos vs segueros

Recuerdo cuando mis amigos y yo (de igual nivel de frikismo por aquellos tiempos) nos peleabamos por quien era mejor, mario o sonic, que si el puto gordo del fontanero, que si el cerdo de mierda..., todo con absoluta pureza y sin la malicia presente en los jóvenes de hoy. En mi caso defendía a Sonic, no tenía ninguna razón lógica, símplemente tenía la master system y debía que defender a toda costa mi compra, que por otro lado, mis meses de ahorro me costo (por aquel entonces me costó 13 mil pesetas).

Recientemente he estado jugando a algunos juegos de nintendo64 en un emulador (aunque tengo la N64 real me resulta más cómodo arrancar el emulador) con el objetivo de sacar algunas ideas para un pequeño proyecto que tengo en mente. A nivel gráfico se puede decir que, comparado con los gráficos de aquella época, eran bastante simplones y poco realistas si los comparamos con, sin ir más lejos, el gran turismo de playstation. Las texturas son simples, los mallas son tochas, los escenarios repetitivos... sin embargo hay algo que es diferente al resto de juegos para distintas plataformas, es la jugabilidad, los detalles insignificantes para el jugador pero que hacen que ese juego sea realmente atractivo, que sea un juego.

Es por esto que ahora recuerdo aquellas peleas y me doy cuenta de que nintendo ha seguido una linea que espero que sigan muchos años, que es la de hacer videojuegos para jugar y no simuladores para ver. Esto demuestra que aunque alguien no siga las directrices marcadas por quién sabe quien, aunque vaya contracorriente, si el producto es de calidad, se puede mantener y seguir adelante.

saludos

PD: Hoy no me apetece mucho hablar de programación aunque me quedo las ganas reservadas para hablar otro día de algunos detalles técnicos de los juegos de N64.

Formateador de código

En un post de hace tres días comenté que me vengaría del formato del código que puse. Por casualidad visitando el weblog de Sencillo encontré un artículo sobre formateo de código. Con este código, un par de herramientas (CPP2HTML y python2html) he creado un script que exporta un código formateado y con sintaxis coloreada (de momento python y C++, mis dos amores, bueno... sin contar a mi novia XD ). Como muestra que mejor que el programa origen:

html = """ <table class="ContenedorCodigo"> <tr> <td class="Codigo"> <div class="Embalaje"> <table class="FondoCode"> <tr> <td class="Codigo"> <pre> %s </pre> </td> </tr> </table> </div> </td> </tr> </table> """; css = """<style type="text/css"> .ContenedorCodigo { table-layout: fixed; width: 90%; padding: 0px; } .Embalaje { width: 100%; overflow: auto; } .FondoCode { border: 1px solid black; background-color: #efefef; width: 100%; padding: 7px; } .Codigo { width: 100%; } </style> """ import sys; import os; def CPP(file): os.popen("c:\\bin\\formats\\cpp2html.exe %s" % file); lines = open(file +".html","r").readlines(); css_cpp = """<style type="text/css">""" + open("c:\\bin\\formats\\cpp.css").read() + "</style>"; lines[0] = "<pre>"; lines[-1] = "<pre>"; return css_cpp + "".join(lines); def Python(file): os.popen("c:\\bin\\formats\\python2html.1.py %s" % file); return open(file +".html","r").read(); class Format: def __init__(self,formats): """ ["py",fn]; """ self._formats = {}; for x in formats: self._formats[x[0]] = x[1]; def get_ext(self,file): try: return file.split(".")[1]; except: return ""; def Do(self,fich): code = []; for x in fich: ext = self.get_ext(x); if(self._formats.has_key(ext)): code.append(self._formats[ext](x)); c = open("code.txt.html","w"); c.write(css); for x in code: c.write(html % x); c.close(); formats = [("py",Python), ("cpp",CPP), ("h",CPP),("c",CPP)]; if __name__ == "__main__": if(len(sys.argv) < 2): sys.exit(); f = Format(formats); f.Do(sys.argv[1:]);

un saludo

PD: después de tener problemas con blogger ya que añade unos cuantos br's "by the face", gracias a la ayuda de Sencillo y un poco de ñapeo he consiguido que quede decentillo. Trataré de mejorarlo.

Reflexiones sobre C++

Siempre me había gustado, entusiasmado diría yo, C++, su notación (probablemente porque venía de C), el que esté orientado a objetos, las excepciones, los templates, la herencia, las funciones virtuales... y mucho más después de leerme (effective c++, more effective c++ y modern c+ design). No es que me haya dejado de gustar, pero quizás es que haya abierto los ojos, me explico, el otro día en clase de Sistemas de tiempo real, estabamos dando una introducción a ADA95. En un primer momento se parecía a VHDL (un lenguaje de descripción HW) en su notación, aunque según avanzó la exposión del profesor me di cuenta de que tenía mucho más puntos en común, y lo mejor, orientados al software. ADA 95 tiene implementada concurrencia builtin, sistemas para la gestión de las contiendas, tareas, además de disponer de características propias de los lenguajes orientados a objetos, tanto las "standard" (herencia, etc), como las de facto (paquetes, operadores de rango, tipos algo más completos). La característica que más me gustó es la implementación de task, puedes tener una tarea con su código y tener ejecutando varias concurrentemente sin tener que preocuparte por threads o fork's y lo mejor, un sistema para la sincronización muy agradable y eficaz. Quizás ADA95 por ser un lenguaje orientado al tiempo real y por tener una notación muy distinta a C puede que no sea el preferido de muchos (me incluyo) pero me parece un lenguaje bastante potente y muy apropiado para las máquinas que vienen con varios cores. En conclusión, C++ quizás se haya quedado un poco desfasado con respecto a lenguajes como C#, java, python que implementan herramientas mucho más agradecidas y manejables para el programador, aunque para mi sigue siendo el lenguaje más potente :)

En otro orden de cosas, esta mañana me sobraron un par de horas que pude invertir en perder el tiempo en internet. Entre mis búsquedas encontré algunas cosas interesantes:

- Texturas procedurales: visitando http://www.sorgonet.com/modules.php?name=News&file=article&sid=103 encontré un enlace a una página que ya conocía, pero de la cual desconocía el artículo siguiente: "texturas procedurales"
Es posible que no sepas de qué van las texturas procedurales, seguro que google te puede ayudar más que yo pero en resumen son texturas generadas mediante artefactos matemáticos. Quizás algún día ponga mi código de mi generador de texturas. Para ver algún ejemplo de texturas procedurales lo mejor es visitar páginas como esta

GLSL: si no estás muy familiarizado te preguntarás qué es esa puñeta, pues se trata d eun lenguaje que soportan ciertas tarjetas gráficas para poder realizar operaciones a medida en los render con OpenGL. Buscando un tutorial he encontrado el de lighthouse3d, (revisad la página porque tiene detallados tutoriales de opengl), que además de ser bastante buena calidad y comprensible, utiliza un Shader Designer, un programa creado por la empresa de un cyberamigo y del cual he visto su evolución. Me alegra ver como el trabajo duro tiene sus frutos.

saludos

Bueno, dos shots de la herramienta en la que estoy trabajando últimamente. La verdad es que apenas hay nada de momento debido a que he tenido que ir codeando algunas cosas referentes al ruido y otras cosas. Sin más:




La pena es la calidad de las imágenes que no puede ser mayor ya que el servidor donde las alojo no tengo demasiado espacio, aunque eso sí, es muy fiable ;)




Es tarde, sí, y mañana tengo que levantarme pronto, pero creo que este post merece la pena. En el post anterior comentaba que estaba haciendo una aplicación para generación de contenidos procedurales. Llegado un punto de la aplicación me veo en el aprieto de tener que exportar e importar un montón de variables y, la verdad, es una pesadez. Esto me recordó que hace tiempo viendo la web de chaos - componente de farbrauch - y en concreto un artículo sobre, textualmente, "Load&Save" , había una forma interesante de serializar los structs/clases. La verdad que el método es cutre, mejor dicho, poco elegante, incluso leyendo un poco comenta que reserva de entrada 64mb - ahora la memoria es barata -. Aún así el método es efetivo y simple y deduzco por sus comentarios que lo usa en su demo editor .werkkzeug1 - este editor merece un post aparte en mi opinión -.

Con todo esto pensé en crear un serializer basado en esto lo más simple posible y aquí está:

#define SERIALIZER(var,type,ser) do { if(ser.rw) { (var) = *(type*)(ser.mem); ((unsigned char*)ser.mem)+= sizeof(type); } else { *(type*)(ser.mem) = var;((unsigned char*)ser.mem)+= sizeof(type); } } while(0)
struct serializer
{

serializer(bool _rw):
rw(_rw)
{
// 6 megas está bien
if(!rw) base = mem = new unsigned char [ 6*1024*1024];
}
bool rw;
unsigned char *base;
unsigned char *mem;

void Save(const char* file){ }
void Load(const char* file) {}

void debug_dump()
{
int len = mem - base;

unsigned char *p = base;
while(len--)
{
printf("0x%x ",*p++);
if(!len%20) printf("\n");
}
}

};

El código está codeado en poco tiempo y poco testeado. Tiene dos métodos para cargar y guardar en fichero que aún no están implementados y que de momento no he implementado. Tampoco sigo las típicas reglas de código elegante y bien diseñado pero estoy hasta las pelotas, me dedico a hacer cosas que funcionen, y en este caso parece que funciona, y para muestra, un botón:


struct A
{
int a;
int b;
short c;
char d;

A(int seed)
{
a = seed++;
b = seed++;
c = seed++;
d = seed++;
}
void Serialize(serializer& s)
{

SERIALIZER(a,int,s);
SERIALIZER(b,int,s);
SERIALIZER(c,short,s);
SERIALIZER(d,char,s);
}
void print()
{
printf("%d %d %d %d\n",a,b,c,d);
}
};
struct B
{
A a;
A b;
B(int o)
:a(o),b(o+1)
{}
void Serialize(serializer& s)
{
a.Serialize(s);
b.Serialize(s);

}
void print()
{
a.print();
b.print();
}
};
int _tmain(int argc, _TCHAR* argv[])
{
serializer s(false);
B a(1);
a.Serialize(s);
s.debug_dump();
a.print();

serializer s2(true);
s2.base = s2.mem = s.base;
printf("\n");
B b(0);
b.print();
printf("\n");
b.Serialize(s2);
b.print();
return 0;
}


da como salida por pantalla:

C:\temp\serialize\Debug>serialize.exe
0x1 0x0 0x0 0x0 0x2 0x0 0x0 0x0 0x3 0x0 0x4 0x2 0x0 0x0 0x0 0x3 0x0 0x0 0x0 0x4
0x0 0x5
1 2 3 4
2 3 4 5

0 1 2 3
1 2 3 4

1 2 3 4
2 3 4 5

Como conclusión decir que a buen entendedor, pocos printf's bastan y que tengo que encontrar algún método para que el código quede bien y no me joda los identados

Hey! hacía ya muchísimo que no posteaba, curiosamente coincide con la fecha en la que dejé de trabajar, bien pensado y a toro pasado es posible que lo que decía mi jefe fuera cierto: pierdo demasiado el tiempo ( espero que ningún jefe lea nunca esto :P).

Repasando un poco los post del blog la verdad es que en poco tiempo las cosas avanzan muchísimo. Empezando por wxPython tengo que decir que ahora windows forms me dan toda la facilidad y además en mi lenguaje favorito, C++ (bueeeno, managed C++), en cuanto a las intros/demos que comentaba ahora hay algunas que pasan con creces a las comentadas y mucho más viendo las ganadoras de scene awards (especial atención a las españolas arise y paradise) o las ganadoras de las breakpoint 2005. Otra cosa que ha cambiado han sido los links que tengo, creo, en la parte derecha. Seguramente no funcionen pero ¿ acaso no dan carisma unos cuantos 404 ?

Lo único que hasta ahora no ha cambiado ha sido mi interés por las demos/intros y en concreto la generación de contenidos procedurales. Precisamente ahora estoy programando una pequeña herramienta, que es con la que he recordado este blog con un tema que trataré en breve, que sirve para generar terrenos - y algo más :) -. Cuando tenga un poco de tiempo subiré alguna imagen.

PD: Ahora da gusto postear desde el portátil, ya no tengo que andar sincronizando varios pc's con mi - valiosa - información, AH! y sobretodo, con estas teclitas tan suaves xD