Tutorial programacion Megadrive - SGDK

Archivado
1, 2, 3, 4, 5…7
Soed escribió:Estoy pensando en hacerme una herramienta yo mismo... alguien sabe los valores RGB de los 512 colores de Megadrive?

http://en.wikipedia.org/wiki/List_of_mo ... #9-bit_RGB

Supongo que puedo fiarme de esto...

¿Alguien se anima a trabajar en el proyecto? D:



Yo me animaria pero con el Tile Studio.
Porque no aprovechar el tremendo potencial de ese editor? Es abierto y permite crear scripts de salida, hay documentacion...
Por ejemplo hay un script para crear tileset y mapas para GBA, en ASM o en C. Yo lo usé y es una maravilla.
Cuando programab para GB/GBC usaba herramientas similares, con herramientas asi puedes optimizar al maximo la VRAM, ya que optimizas el uso de tiles, podrias ahorrate la mitad de los tiles que el GenRes te genera
Suena muy bien. Me he bajado el programa y el pdf de ayuda, a ver cuando le echo un ojo. Espero que no sea demasiado complicado, si fuera así se agradecería un tutorial de cómo usarlo para la Megadrive [beer]
Lo unico malo del tilestudio es que no permite metatiles (conjuntos de tiles) porque hacer mapas tile a tile ocupa mucha memoria, pero se puede hacer externamente, hacer un programilla para hacer metatiles (de 16x16 o 32x32) e importar estos tiles en el tilestudio.
bertobp escribió:Yo me animaria pero con el Tile Studio.
Porque no aprovechar el tremendo potencial de ese editor? Es abierto y permite crear scripts de salida, hay documentacion...
Por ejemplo hay un script para crear tileset y mapas para GBA, en ASM o en C. Yo lo usé y es una maravilla.


Vaya, esto suena muy interesante.
Manveru Ainu escribió:Suena muy bien. Me he bajado el programa y el pdf de ayuda, a ver cuando le echo un ojo. Espero que no sea demasiado complicado, si fuera así se agradecería un tutorial de cómo usarlo para la Megadrive [beer]


Como ya he dicho, necesitamos hacer un script, hace 1 año lo intenté pero no me salió... en este tutorial dice como hacer los scripts *.tsd.
Buscar el apartado: Creating a Tile Studio Definition (.tsd) file

http://tilestudio.sourceforge.net/tutor.html

Pido ayuda a los que sabeis programar aplicaciones, seguro que lo sacais rapido :)
Yo le he echado un ojo y de momento no me he enterado de mucho, ni siquiera he sabido poner una paleta de 16 colores [+risas] , si alguien se lo curra y quiere hacer algún tutorial se le agradecería, pero por ahora lo dejo de lado.

Por cierto una duda, ¿cómo hago para mover los objetos a nivel de píxel en lugar de a nivel de tiles? Estoy haciendo los distintos planos de profundidad del background pero claro al moverlos a tiles (VDP_setTileMap) no va fluido, va a saltitos y queda muy feo. Los sprites del GenRes traen un atributo x que lo modificas y sí se mueve a nivel de píxel, pero para los mapas de tiles no sé cómo hacerlo.
Manveru Ainu escribió:Yo le he echado un ojo y de momento no me he enterado de mucho, ni siquiera he sabido poner una paleta de 16 colores [+risas] , si alguien se lo curra y quiere hacer algún tutorial se le agradecería, pero por ahora lo dejo de lado.



Antes de hacer tutoriales de uso del TS, hayq ue saber si lo podemos usar para megadrive y currarse el script ;)
Ah vale vale, pensaba que ya se sabía que se podía.

Lo del scroll del fondo que comenté antes veo que está relacionado con la función void VDP_setHorizontalScroll(u16 plan, u16 line, u16 value);, voy a toquetearla un poco según he visto en un post a ver que tal.
Me imagino yo en los años 90 con todas estas herramientas gratuitas y programando un juego. Seguro q el kit de desarrollo oficial era carisimo y solo grandes productoras podian permitirselo
agppro escribió:Me imagino yo en los años 90 con todas estas herramientas gratuitas y programando un juego. Seguro q el kit de desarrollo oficial era carisimo y solo grandes productoras podian permitirselo

La verdad es que si, en mi caso hubiera dado cualquier cosa por haber conocido estas cosas hace 10 años, aunque ahora también es cierto que no me parece lo más correcto que, al menos en el caso del sgdk, saquen unas librerías para cualquier cosa y no incluyan algún tipo de manual básico para manejarlas, y tengamos que depender de gente como pocket_lucho que se lo tengan que currar para ayudarnos. Tampoco tienen que sacar una biblia, con hacer por ejemplo lo del allegro y poner cada una de las funciones con un par de líneas explicando lo que hacen va que chuta. Ya si hacen como con fénix/bennu que sacan un pedazo de pdf super completo pues minipunto para ellos jejeje
Hola gente! Discupad la ausencia pero es que estoy a tope con el oh mummy, espero en breve poder seguir con estos tutos!!

La ayuda de las sgdk la verdad es que es poco escasita y sus ejemplos ni digamos, pero bueno, ya vereis que como cuando acabemos se pueden hacer cosas decentes ;)

Lo que decis de las herramientas... es que simplemente en su epoca no existian xD Ni una internet donde bajarlas... aparte, debias pagar royalties a sega para poder desarrollar para su consola, de hecho, tiene una protección, chorra, pero la tiene. Y al saltartela, pues te podian denunciar, como paso con EA o el famoso juicio con Accoladde por ejemplo.

Las sgdk no usan NADA de ese kit oficial, ya que yo sepa, ni siquiera está filtrado, la documentación oficial de sega si que anda por ahi. El compilador que usamos no es que genere tampoco un código fabuloso pero es lo que hay, además en su dia se hacia todo con ensamblador, que es la forma óptima de aprovechar el hard, pero yo al menos no tengo tiemo ni ganas de ponerme a programar de esa forma [+risas]
Los tutos ya vendrán cuando se pueda... ;) pero el Oh Mummy quiero "clavarlo" en mi Megadrive estas navidades!!!! [sonrisa]
Lo 'clavarás' antes ;)
este tutorial mola no?
felicito al administrador :)
daniopolis escribió:este tutorial mola no?
felicito al administrador :)


Felicita a los que lo hicieron, no al administrador.. [+risas]
Como te comente me ando mirando las librerias y los tutos y bastante bien de momento, que ademas tenia ganas de repasar C que ya hacia bastante tiempo que ni lo tocaba :-|

Tengo una sugerencia, que mas que nada es para gustos, y es en relacion a la deteccion de pulsaciones (o liberaciones) pues soy de los que se suele decantar por un codigo mas legible y claro a simple vista aunque sea un poco mas largo. A ver si con el ejemplo se me entiende mejor [+risas]

void myJoyHandler ( u16 joy, u16 changed, u16 state )
{
    if (joy == JOY_1)
    {
        if ( state & BUTTON_START )
        {
            VDP_drawText("START button 1", 5, 13);
        }
        else if ( changed & BUTTON_START )
        {
            VDP_drawText("START button 0", 5, 13);
        }
        if ( state & BUTTON_MODE )
        {
            VDP_drawText("MODE button 1", 5, 14);
        }
        else if ( changed & BUTTON_MODE )
        {
            VDP_drawText("MODE button 0", 5, 14);
        }
    }
}


Y esta es mi propuesta.

void myJoyHandler ( u16 joy, u16 changed, u16 state )
{
    if (joy == JOY_1)
    {
        unsigned int esElBoton ( u16 _b ) { if ( _b & changed ) return 1; return 0; }
        unsigned int estaPulsado ( u16 _b ) { if ( _b & state ) return 1; return 0; }

        if ( esElBoton ( BUTTON_START ) )
            if ( estaPulsado ( BUTTON_START ) )
            {
                VDP_drawText("START button 1", 5, 13);
            }
            else
            {
                VDP_drawText("START button 0", 5, 13);
            }
        if ( esElBoton ( BUTTON_MODE ) )
            if ( estaPulsado ( BUTTON_MODE ) )
            {
                VDP_drawText("MODE button 1", 5, 14);
            }
            else
            {
                VDP_drawText("MODE button 0", 5, 14);
            }
    }
}


Ya me comentaras que te parece. Lo siguiente que me pondre sera con los tiles que ya me lei anoche la teoria pero me falta probarlo y buscar mejoras/cambios...manias de programador xDDD
KFR lo que propones te va ahorrar texto a la larga, pero no creo que mucho, aparte de eso has "Españolizado" el código o sea que hace lo mismo [jaja]
Hombre lo he españolizado porque si el proyecto va a ser llevado solo por españoles me parece mas practico, luego cada cual con sus manias. Y como comente, propongo esta idea no por ahorra texto e incluso podria suponer algunas lineas mas, sino por el hecho de claridad y legibilidad, pues es mas comodo leer algo como " estaPulsado ( BUTTON_START ) " que " state & BUTTON_START ". Pero como siempre, es una sugerencia ;)

Edit: Pero vamos, que si quieres ingles es tan facil como...
esElBoton => isButton
estaPulsado => isPressed
Dios, el primer ejmplo es mucho mas esquematico y claro al menos para mi... :)
Para gustos, como comente, es una sugerencia [oki]
Para mi es mucho mas logico y ordenado el segundo pues mismamente las librerias traen los metodos/funciones con terminos que ayudan a un rapido entendimiento de para que es cada una.
Buenas, estoy preparando mi portatil con Windows 7 para seguir los pasos de este tutorial.
Lo malo es que siempre me tiene que pasar algo que me impida llevarlo a cabo. A ver si me podeis ayudar.
Tengo instalado el code::blocks 10.05 y llegado al paso de crear una nueva configuración de compilador a partir de una copia del compilador GNU GCC básico, no me sale la pantalla que está en el tutorial. Me aparece una con menos opciones y no sé que hacer ahí.
Es ésta:
Imagen
En un buen aporte, porque seguro que a mas de uno le viene bien ;)
bertobp escribió:En un buen aporte, porque seguro que a mas de uno le viene bien ;)
Es eso, para quien le resulte mas claro pues evidentemente para quien le sea todo lo contrario seria una tonteria xDDD y le sera mas practico decantarse por la otra forma.

Edit: jrll yo ya siento no poder ayudarte pero no he sido muy amigo de cb y ahora lo uso porque el tutorial me lo da mascado que sino... [360º]
jrll escribió:Buenas, estoy preparando mi portatil con Windows 7 para seguir los pasos de este tutorial.
Lo malo es que siempre me tiene que pasar algo que me impida llevarlo a cabo. A ver si me podeis ayudar.
Tengo instalado el code::blocks 10.05 y llegado al paso de crear una nueva configuración de compilador a partir de una copia del compilador GNU GCC básico, no me sale la pantalla que está en el tutorial. Me aparece una con menos opciones y no sé que hacer ahí.
Es ésta:
Imagen



Parece que has instalado el CB sin el GCC, por eso no salen las opciones del compilador..
Pues era eso, si señor. Había instalado la versión que no debía. Si es que soy un caso [carcajad]
Muchas gracias.
¡Hola!

Gran hilo que os habéis preparado como tutorial para "enrear" en la Megadrive :D

Me muero de ganas de ir a casa a probar todo esto. Prlf. :p :p :p
jebiman escribió:¡Hola!

Gran hilo que os habéis preparado como tutorial para "enrear" en la Megadrive :D

Me muero de ganas de ir a casa a probar todo esto. Prlf. :p :p :p


Con calma, no te atragantes jajaja ánimo!!
Aqui ire anotando los codigos que voy sacando de los tutoriales pero de forma unificada que pueden venir bien para quien quiera ver el codigo de un vistazo que no a cachos.

Control pulsaciones pad..
#include <genesis.h>

void myJoyHandler( u16, u16, u16);

int main( )
{
   JOY_init();                               // Inicializacion joystick
   JOY_setSupport(PORT_1, JOY_SUPPORT_6BTN); // En el puerto 1 se controlara un pad de 6 botones
   JOY_setEventHandler( &myJoyHandler );     // Puntero a la clase que controlara el evento disparado
                                             // por cada cambio de estado en algun boton/direccion del pad

    while(1)
    {
        VDP_waitVSync(); // Sincronizacion vertical para evitar parpadeo/flickering
    }
    return (0);
}

// joy    : Puede tomar valor JOY_1 o JOY_2
// changed: Siempre tomara el valor del boton/direccion que haya disparado el evento (pulsado o no)
// state  : En caso de ser una pulsacion tomara el mismo valor que changed, caso contrario 0
// La comparacion que se efectua con el operador "&" es sobre bits (binaria)
void myJoyHandler ( u16 joy, u16 changed, u16 state )
{
    if (joy == JOY_1)
    {
        unsigned int esElBoton ( u16 _b ) { if ( _b & changed ) return 1; return 0; }
        unsigned int estaPulsado ( u16 _b ) { if ( _b & state ) return 1; return 0; }

        if ( esElBoton ( BUTTON_START ) )
            if ( estaPulsado ( BUTTON_START ) )
            {
                VDP_drawText("START button 1", 5, 13);
            }
            else
            {
                VDP_drawText("START button 0", 5, 13);
            }
        if ( esElBoton ( BUTTON_MODE ) )
            if ( estaPulsado ( BUTTON_MODE ) )
            {
                VDP_drawText("MODE button 1", 5, 14);
            }
            else
            {
                VDP_drawText("MODE button 0", 5, 14);
            }
    }
}


Creacion y dibujado de un tile "a mano"..
#include <genesis.h>

const u32 tile[8]=
{
    0x00111100,
    0x01144110,
    0x11244211,
    0x11244211,
    0x11222211,
    0x11222211,
    0x01122110,
    0x00111100
};

int main( )
{
    // Puntero al array/tile o al primero del listado de tiles
    // Indice VRAM a partir del cual comenzar a almacenar
    // Cuantos tiles son a guardar, 1 o mas
    // Modo de acceso directo a memoria o no/0
    VDP_loadTileData ( ( const u32 * )tile, 1, 1, 0 );

    // Plano A o B, indice en VRAM, coordenadas 5 horizontal 5 vertical
    // Al no haber especificado se usa por defecto la paleta 0, escala de grises
    VDP_setTileMap ( APLAN, 1, 5, 5 );

    // La misma forma de dibujar pero ayudandose de una macro con varios parametros
    // Plano, prioridad (0 la mas baja), vflip (1si/0no), hflip, indice VRAM
    VDP_setTileMap ( BPLAN, TILE_ATTR_FULL ( PAL2, 0, 1, 0, 1 ), 6, 5 );

    while(1)
    {
        VDP_waitVSync();
    }
    return (0);
}


Lo mismo pero dando importancia a las prioridades..
#include <genesis.h>

const u32 tile[8]=
{
    0x00111100,
    0x01144110,
    0x11244211,
    0x11244211,
    0x11222211,
    0x11222211,
    0x01122110,
    0x00111100
};

int main( )
{
    // Puntero al array/tile o al primero del listado de tiles
    // Indice VRAM a partir del cual comenzar a almacenar
    // Cuantos tiles son a guardar, 1 o mas
    // Modo de acceso directo a memoria o no/0
    VDP_loadTileData ( ( const u32 * )tile, 1, 1, 0 );

    // Comprobacion del funcionamiento del parametro prioridad
    // Se usa todo el rato el mismo tile en el mismo plano pero con diferente prioridad
    // Parametros de la macro:  Plano, prioridad (0 la mas baja), vflip, hflip, indice VRAM
    VDP_setTileMap ( APLAN, TILE_ATTR_FULL ( PAL1, 1, 0, 0, 1 ), 7, 7 ); // [ 1 ] Tile paleta tonos rojos
    VDP_setTileMap ( BPLAN, TILE_ATTR_FULL ( PAL2, 0, 0, 0, 1 ), 7, 7 ); // [ 2 ] ..verdes
    VDP_setTileMap ( APLAN, TILE_ATTR_FULL ( PAL1, 0, 0, 0, 1 ), 8, 7 ); // [ 3 ] ..rojos
    VDP_setTileMap ( BPLAN, TILE_ATTR_FULL ( PAL2, 1, 0, 0, 1 ), 8, 7 ); // [ 4 ] ..verdes
    // El tile 1 y 2 estan en la misma coordenada (7,7) pero 1 tiene priridad mayor con respecto a 2
    // y por eso al ejecutar la rom solo se vera el tile en tonos rojos. En cambio en el caso de 3 y 4
    // el que tiene mayor prioridad es 4 y se vera el tile en tonos verdes

    while(1)
    {
        VDP_waitVSync();
    }
    return (0);
}


Y ahora pintando un area determinada repitiendo el tile..
#include <genesis.h>

const u32 tile[8]=
{
    0x00111100,
    0x01144110,
    0x11244211,
    0x11244211,
    0x11222211,
    0x11222211,
    0x01122110,
    0x00111100
};

int main( )
{
    // Puntero al array/tile o al primero del listado de tiles
    // Indice VRAM a partir del cual comenzar a almacenar
    // Cuantos tiles son a guardar, 1 o mas
    // Modo de acceso directo a memoria o no/0
    VDP_loadTileData ( ( const u32 * )tile, 1, 1, 0 );

    // Se rellenara un area de 8 tile horizontales por 4 verticales comenzando
    // desde las coordenadas 12,12
    VDP_fillTileMapRect(BPLAN, TILE_ATTR_FULL(PAL2, 0, 0, 0, 1), 12, 12, 8, 4);

    while(1)
    {
        VDP_waitVSync();
    }
    return (0);
}


Creacion y dibujado de un tile "con sgdk"..
#include <genesis.h>

// Crear carpeta "res" en el raiz del proyecto y meter ahi el grafico/bmp a cargar
#include "moon.h"

int main( )
{
    u16 w = moon[0]; // Ancho del tile
    u16 h = moon[1]; // Alto del tile

    // Sustituir la paleta precargada en PAL1 por la del grafico
    VDP_setPalette ( PAL1, &moon[2] );

    // Puntero a la informacion del tile/s, indice VRAM, ancho y alto en tiles a guardar
    // El ultimo parametro es obligatorio y se ha de indicar el ancho total del bitmap porque igual
    // se podria querer cargar solo parte del bitmap que no entero
    VDP_loadBMPTileData ( ( u32* ) &moon[18], 2, w / 8, h / 8, w/8 );

    // Plano, macro con atributos (paleta, prioridad, vflip, hflip, ind.VRAM), coord.23-6
    // Los dos ultimos parametros son el numero de tiles a dibujar en horizontal y en vertical
    VDP_fillTileMapRectInc ( BPLAN, TILE_ATTR_FULL ( PAL1, 0, 0, 0, 2 ), 23, 6, w / 8, h / 8 );

    while(1)
    {
        VDP_waitVSync();
    }
    return (0);
}


Creacion y dibujado de un tile "con genres"..
#include <genesis.h>

// Los graficos se pueden poner en la carpeta que se quiera (en el raiz) pero hay que crear un archivo
// resource.rc en el que la primera y ultima lineas se dejen en blanco o con ";" y en las otras
// se especifiquen los graficos a convertir tal que: BITMAP luna "data/luna.bmp" 0

// Estructura a usar para tratar las imagenes convertidas
struct genresTiles
{
    u16 *pal;         // puntero a los datos de la paleta
    u32 *tiles;        // puntero a los datos de los tiles
    u16 width;        // ancho en tiles
    u16 height;        // alto en tiles
    u16 compressedSize;  // 0 en esta demo, mas proximamente
};
extern struct genresTiles luna;

int main( )
{
    // Sustituir la paleta precargada por la del grafico
    VDP_setPalette ( PAL2, luna.pal );

    // Informacion de los tiles del bitmap, indice del primer tile, tiles a cargar, DMA o no
    VDP_loadTileData ( luna.tiles, 100, luna.width*luna.height, 0 );

    // Plano, macro con atributos (paleta, prioridad, vflip, hflip, ind.VRAM), coord.23-6
    // Los dos ultimos parametros son el numero de tiles a dibujar en horizontal y en vertical
    VDP_fillTileMapRectInc ( BPLAN, TILE_ATTR_FULL ( PAL2, 0, 0, 0, 100 ), 23, 12, luna.width, luna.height );

    while(1)
    {
        VDP_waitVSync();
    }
    return (0);
}


Edit: Por cierto, dudita y es que probando con mis propios graficos me va todo de perlas menos el metodo de sgdk mediante la carpeta res. El .h ha de aparecer solo o hay algun paso previo?
Edit 2: Solucionado...ha sido borrar el contenido de out y volver a compilar y listo...me lo apunto pero raro raro xD
KFR escribió:Edit: Por cierto, dudita y es que probando con mis propios graficos me va todo de perlas menos el metodo de sgdk mediante la carpeta res. El .h ha de aparecer solo o hay algun paso previo?
Edit 2: Solucionado...ha sido borrar el contenido de out y volver a compilar y listo...me lo apunto pero raro raro xD

A mí me pasaba lo mismo. Cuando modificas el main.c basta con compilar con F9, pero cuando tocas otro archivo o cambias el contenido de una carpeta hay que darle a Rebuild Proyect o Ctrl+F11.

Por cierto veo que han actualizado el z80 VGM player y ahora trae algunas novedades como soporte para archivos PCM y trae ejemplos para usarlo con el SGDK. A ver cuando saco un rato y lo trasteo.
Muy interesante y currado, cuando tenga algo de tiempo, seguro el fin de semana, me pongo que ya tengo el Codeblocks y todo.
Estos días para quitarme el gusanillo he estado mejorando el código un poco y probando el z80 VGM player. La verdad es que no está mal, excepto algunas ralentizaciones con algunas pistas de audio funciona bastante bien y es sencillo de usar. Lo que no sé es si es mejor el reproductor que trae el SGDK (porque no he encontrado ayuda alguna para probarlo) o si hay algún otro mejor, así que bueno tenía pensado hacer un pequeño tutorial pero mejor esperar a saber cuál es la mejor opción.
Hey gente a ver si me podéis ayudar. He tenido que formatear y me he bajado el último Code Blocks, el 12.11 y resulta que a la hora de configurar el nuevo compilador no me deja meter el archivo del Debugger. Cuando configuro todo lo demás del compilador y le doy a aceptar me salta un mensaje: "can't find compiler executable in your configured search path's for GNU GCC Compiler". De hecho en esta versión viene por separado para configurar el compilador y el debugger y en "compilador" no te deja escribir gdb.exe ni nada (por defecto GDB/CDF Debugger), sólo puedes elegir uno de una lista a la que se pueden añadir nuevas configuraciones de debugger desde otro menú, pero no sé hacerlo para el SGDK.

Gracias y un saludo.

EDITO: Tras actualizar windows ya me funciona, no me pregunten cómo pero ya va [360º]
Pues entonces bien xD

Ya pasada la voragine del oh mummy más o menos, en breve retomo los tutos ;)
Muy buena informacion, y muy bien explicada!

Mas que nada, con este entorno C, quizá tendremos mas facilidades para trabajar con el APU (audio processing unit) que con BEX (BasieEgaXorz)?

[oki]
Buenas de nuevo. Quería preguntaros si hay forma si hay una forma de dibujar los sprites sin que las posiciones de memoria de sus tiles estén colocadas de forma consecutivas en la VRAM, cargando posiciones salteadas. Con el Imagenesis al optimizar imágenes se eliminan los tiles en blanco(trasparentes) y los duplicados con lo que algunos sprites no tienen sus tiles colocados de forma consecutiva, de hecho al cargar la tabla de sprites en la VRAM no están los tiles de forma correlativa. He intentado cargando toda la tabla de sprites en la VRAM e ir cogiendo los tiles uno a uno, pero claro el número de sprites está limitado a 80 con lo que se me van en nada y no puedo hacer lo que necesito.
A ver si me ayudáis, un saludo y felices fiestas.
A favoritos!!! :)
Lo siento tio, pero para sprites tienen que ser secuenciales.
pocket_lucho escribió:Lo siento tio, pero para sprites tienen que ser secuenciales.

Oks gracias pocket_lucho, sacaré el código del imagenesis sin optimizar. Por cierto, ¿sabes por qué el Imagénesis "clarea" las imágenes? Todas las tablas de sprites que meto (sin pasar los 16 colores) me transforma los colores en los mismos pero un poco más claros, como si encendiese una luz sobre los sprites...
Una currada de tutorial, a ver si saco un tiempo y hago alguna chorrada XD
Manveru Ainu escribió:
pocket_lucho escribió:Lo siento tio, pero para sprites tienen que ser secuenciales.

Oks gracias pocket_lucho, sacaré el código del imagenesis sin optimizar. Por cierto, ¿sabes por qué el Imagénesis "clarea" las imágenes? Todas las tablas de sprites que meto (sin pasar los 16 colores) me transforma los colores en los mismos pero un poco más claros, como si encendiese una luz sobre los sprites...

Probablemente sea al usar la paleta de la megadrive.
Si, el imagenesis, si no detecta que un color es de la paleta de la consola, lo adapta al más cercano/que le venga en gana, incluso a veces usando colores de la paleta, da el efecto que los cambia aunque luego en el codigo son los que deberian ;)
wave escribió:
Manveru Ainu escribió:Oks gracias pocket_lucho, sacaré el código del imagenesis sin optimizar. Por cierto, ¿sabes por qué el Imagénesis "clarea" las imágenes? Todas las tablas de sprites que meto (sin pasar los 16 colores) me transforma los colores en los mismos pero un poco más claros, como si encendiese una luz sobre los sprites...

Probablemente sea al usar la paleta de la megadrive.

Eso había pensado pero cuando cargo las imágenes de Gimp con el Genres no cambian, o eso creo... la verdad es que no lo he probado y seguramente sea eso que comentas pero no lo habré notado. En cualquier caso no importa demasiado la verdad. Gracias.
Me ha dado por mirar y he visto que hace un mes sacaron la versión 0,93 del SGDK con varias mejoras:
* Simplified memory set/copy methods :
- 'Fastxxx' methods are now deprecated as basic generic methods are now optimized.
- 'memcpy' is now the only memory copy method.
* Added Z80 VGM driver (thanks to Sigflup which originally wrote it and to kubilus1 which improved it).
* Added SRAM support (thanks to Chilly Willy)
* Added preliminary support for ROM > 4MB (you can at least compile them now).
* Improved support for waitTick(..) and waitSubTick(..) calls during VBlank (still inaccurate).
* Added methods to get/set scrolling mode :
- VDP_getHorizontalScrollingMode()
- VDP_getVerticalScrollingMode()
- VDP_setScrollingMode(u16 hscroll, u16 vscroll)
- VDP_setHorizontalScroll(u16 plan, u16 value)
- VDP_setHorizontalScrollTile(u16 plan, u16 tile, u16* values, u16 len)
- VDP_setHorizontalScrollLine(u16 plan, u16 line, u16* values, u16 len)
- VDP_setVerticalScroll(u16 plan, u16 value)
- VDP_setVerticalScrollTile(u16 plan, u16 tile, u16* values, u16 len)
* Added methods to set/fill tile by index :
- VDP_clearTileMapRectByIndex(u16 plan, u16 ind, u16 num, u8 use_dma)
- VDP_fillTileMapRectIncByIndex(u16 plan, u16 basetile, u16 ind, u16 num)
- VDP_fillTileMapRectByIndex(u16 plan, u16 tile, u16 ind, u16 num)
- VDP_setTileMapByIndex(u16 plan, u16 tile, u16 ind)
- VDP_setTileMapRectByIndex(u16 plan, const u16 *data, u16 ind, u16 num, u8 use_dma)
- VDP_setTileMapRectExByIndex(u16 plan, const u16 *data, u16 baseindex, u16 baseflags, u16 ind, u16 num)
* Improved boot code so it should now init correctly on real hardware.
* Fixed Z80 driver uploading which may fails on real hardware in some condition.
* Modified 'sound' sample to add VGM play example.
* Minors fixes, improvements and cleanup.
* Some refactoring.


Y unos días después sacaron la 0.93b para añadir alguna función y corregir algún bug:
* Fixed a stupid bug in deprecated memory functions.
* Added Bitmap structure for easier bitmap manipulation (created from .bmp resources).
* Modified Plan A & Plan B location in VRAM.
* Added methods to modify Plan A, Plan B, Window, Sprites list and H Scroll table location in VRAM.
Note that doing that you may have troubles with SGDK methods which use hardwired locations.
* VDP_setSpritesDirect(..) method so you can now send a SpriteDef array buffer directly to the VDP.
* Handle a new resource type : WAVPCM (.wavpcm)
The file is transformed to adpcm data and can be played directly through the 2 channels ADPCM driver.
Note that WAV sample rate should be at least equals to 22050 Hz.
* Fixed a bug in bintos tool.
* New wavtoraw tool, source is provided.
* Added tools sources.
* Fixed Z80 driver uploading which may fails on real hardware in some condition.

A buenas horas xDD (lo notareis en el oh mummy...)
Ahora que leo lo del scroll... en SGDK que tal se manejan los planos de fondo y scroll. Que mapa maximo coge en la VRAM?
Tiene librerias ya para manejar mapas de mas tamaño que la VRAM e ir actualizando segun va avanzando el scroll?
Pues que yo sepa no, vamos, yo me estoy haciendo una [+risas]

Son mapas de 256x256 hasta 512x512 y sus combinaciones (256x512 etc.)
pocket_lucho escribió:Pues que yo sepa no, vamos, yo me estoy haciendo una [+risas]

Son mapas de 256x256 hasta 512x512 y sus combinaciones (256x512 etc.)



Yo es que estoy intentando hacer lo mismo en GameBoy jejejeje con el agravante de tener que gestionar bancos de memoria :(
Yo estaba haciendo mis primeros pinitos con los scrolls, en particular tratando de mover un scroll horizontal forzado (con varios planos distintos que se mueven independientemente) y un scroll vertical que te sigue, y de momento estoy teniendo unos resultados un poco raros. Es como si los distintos planos de scroll "temblaran". Leí algo de que llamar a la función por cada fila de tiles era un poco costoso así que investigando un poco me hice yo una función propia, aunque da el mismo resultado y para colmo existía ya la nueva versión del SGDK que trae su propia versión para eso. Así que nada a seguir probando e investigando.
Buenas acabo de empezar con tu manual, quiero ir investigando poco a poco nada más empezar me surgen un par de dudas...

#include <genesis.h>
int main()
{
       VDP_drawText("Hola Mundo!", 10, 13);
       return (0);
}


Hay algun sitio donde ver que hace y que argumentos necesita cada funcion?? por ejemplo

VDP_drawText No se como poner una ñ por ejemplo ni se que valores puede tomar el segundo tercer argumento es decir va desde 0 hasta 99 hasta 192 ?? nose si me explico que significan esos numero y que limite tienen???
nolddor escribió:Buenas acabo de empezar con tu manual, quiero ir investigando poco a poco nada más empezar me surgen un par de dudas...

#include <genesis.h>
int main()
{
       VDP_drawText("Hola Mundo!", 10, 13);
       return (0);
}


Hay algun sitio donde ver que hace y que argumentos necesita cada funcion?? por ejemplo

VDP_drawText No se como poner una ñ por ejemplo ni se que valores puede tomar el segundo tercer argumento es decir va desde 0 hasta 99 hasta 192 ?? nose si me explico que significan esos numero y que limite tienen???


Supongo que no has leido la WIKI oficial del SGDK...
http://code.google.com/p/sgdk/wiki/SGDKTutorial

Printing on screen is a VDP task so you need to call VDP_drawText(<your_text>, <x>, <y>).

Remember, x and y are in tile unit, not pixel unit with 1 tile = 8 pixels.


Aparte la documentacion que viene en el SGDK y las librerias de lacarpeta include
343 respuestas
Archivado
1, 2, 3, 4, 5…7
Volver a Consolas clásicas