neocore.h

Go to the documentation of this file.

/*
  David Vandensteen
*/
 
  //--------------------------------------------------------------------------//
 //                             DEFINE                                       //
//--------------------------------------------------------------------------//
 
#ifndef NEOCORE_H
#define NEOCORE_H
 
#include <DATlib.h>
#include <math.h>
 
#define SHRUNK_TABLE_PROP_SIZE 0x2fe
 
#define MANUALBOX 0
#define AUTOBOX 1
 
#define DISPLAY_GFX_WITH_SPRITE_ID_AUTO 0xFFFF
#define SPRITE_INDEX_NOT_FOUND 0xFFFF
 
enum Direction { NONE, UP, DOWN, LEFT, RIGHT };
enum Sound_state { IDLE, PLAYING };
 
  //--------------------------------------------------------------------------//
 //                          STRUCTURE                                       //
//--------------------------------------------------------------------------//
 
typedef struct Position { short x; short y; } Position;
 
//void mask_display(picture pic[], Position vec[], BYTE vector_max); // todo (minor) - rename ? (vectorsDisplay)
void nc_update_mask(short x, short y, Position vec[], Position offset[], BYTE vector_max); // todo (minor) - rename ? (vectorsDebug)
 
typedef struct Box {
  Position p0;
  Position p1;
  Position p2;
  Position p3;
  Position p4;
  short width;
  short height;
  short widthOffset;
  short heightOffset;
} Box;
 
typedef struct GFX_Animated_Sprite {
  aSprite aSpriteDAT;
  const spriteInfo *spriteInfoDAT;
  const paletteInfo *paletteInfoDAT;
} GFX_Animated_Sprite;
 
typedef struct GFX_Picture {
  picture pictureDAT;
  const pictureInfo *pictureInfoDAT;
  const paletteInfo *paletteInfoDAT;
  WORD pixel_height;
  WORD pixel_width;
} GFX_Picture;
 
typedef struct GFX_Animated_Sprite_Physic {
  GFX_Animated_Sprite gfx_animated_sprite;
  Box box;
  BOOL physic_enabled;
} GFX_Animated_Sprite_Physic;
 
typedef struct GFX_Picture_Physic {
  GFX_Picture gfx_picture;
  Box box;
  BOOL autobox_enabled;
  BOOL physic_enabled;
} GFX_Picture_Physic;
 
typedef struct GFX_Scroller {
  scroller scrollerDAT;
  const scrollerInfo *scrollerInfoDAT;
  const paletteInfo *paletteInfoDAT;
} GFX_Scroller;
 
typedef struct Adpcm_player {
  enum Sound_state state;
  DWORD remaining_frame;
} Adpcm_player;
 
typedef struct RGB16 {
  BYTE dark : 4, r : 4, g : 4, b : 4;
} RGB16;
 
  //--------------------------------------------------------------------------//
 //                                   GFX                                    //
//--------------------------------------------------------------------------//
 
  /*------------------*/
 /*  GFX INIT        */
/*------------------*/
 
void nc_init_gfx_animated_sprite(
  GFX_Animated_Sprite *gfx_animated_sprite,
  const spriteInfo *spriteInfo,
  const paletteInfo *paletteInfo
);
 
void nc_init_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  const spriteInfo *spriteInfo,
  const paletteInfo *paletteInfo,
  short box_witdh,
  short box_height,
  short box_width_offset,
  short box_height_offset
);
 
void nc_init_gfx_picture(
  GFX_Picture *gfx_picture,
  const pictureInfo *pictureInfo,
  const paletteInfo *paletteInfo
);
 
void nc_init_gfx_picture_physic(
  GFX_Picture_Physic *gfx_picture_physic,
  const pictureInfo *pi,
  const paletteInfo *pali,
  short box_witdh,
  short box_height,
  short box_width_offset,
  short box_height_offset,
  BOOL autobox_enabled
);
 
void nc_init_gfx_scroller(
  GFX_Scroller *gfx_scroller,
  const scrollerInfo *scrollerInfo,
  const paletteInfo *paletteInfo
);
 
  /*------------------*/
 /*  GFX DISPLAY     */
/*------------------*/
 
void nc_display_gfx_with_sprite_id(WORD sprite_id);
 
WORD nc_display_gfx_animated_sprite(
  GFX_Animated_Sprite *gfx_animated_sprite,
  short x,
  short y,
  WORD anim
);
 
WORD nc_display_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  short x,
  short y,
  WORD anim
);
 
WORD nc_display_gfx_picture(GFX_Picture *gfx_picture, short x, short y);
 
WORD nc_display_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic, short x, short y);
 
WORD nc_display_gfx_scroller(GFX_Scroller *gfx_scroller, short x, short y);
 
  /*-----------------------*/
 /*  GFX INIT DISPLAY     */
/*-----------------------*/
 
WORD nc_init_display_gfx_animated_sprite(
  GFX_Animated_Sprite *gfx_animated_sprite,
  const spriteInfo *spriteInfo,
  const paletteInfo *paletteInfo,
  short x,
  short y,
  WORD anim
);
 
WORD nc_init_display_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  const spriteInfo *spriteInfo,
  const paletteInfo *paletteInfo,
  short x,
  short y,
  short box_witdh,
  short box_height,
  short box_width_offset,
  short box_height_offset,
  WORD anim
);
 
WORD nc_init_display_gfx_picture(
  GFX_Picture *gfx_picture,
  const pictureInfo *pictureInfo,
  const paletteInfo *paletteInfo,
  short x,
  short y
);
 
WORD nc_init_display_gfx_picture_physic(
  GFX_Picture_Physic *gfx_picture_physic,
  const pictureInfo *pictureInfo,
  const paletteInfo *paletteInfo,
  short x,
  short y,
  short box_witdh,
  short box_height,
  short box_width_offset,
  short box_height_offset,
  BOOL autobox_enabled
);
 
WORD nc_init_display_gfx_scroller(
  GFX_Scroller *gfx_scroller,
  const scrollerInfo *scrollerInfo,
  const paletteInfo *paletteInfo,
  short x,
  short y
);
 
  /*------------------*/
 /*  GFX VISIBILITY  */
/*------------------*/
 
void nc_hide_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite);
 
void nc_hide_gfx_picture(GFX_Picture *gfx_picture);
void nc_hide_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic);
void nc_hide_gfx_animated_sprite_physic(GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic);
 
void nc_show_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite);
void nc_show_gfx_animated_sprite_physic(GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic);
void nc_show_gfx_picture(GFX_Picture *gfx_picture);
void nc_show_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic);
 
  /*------------------*/
 /*  GFX POSITION    */
/*------------------*/
 
/* GFX POSITION GETTER */
 
void nc_get_position_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite, Position *position);
void nc_get_position_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  Position *position
);
void nc_get_position_gfx_picture(GFX_Picture *gfx_picture, Position *position);
void nc_get_position_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic, Position *position);
void nc_get_position_gfx_scroller(GFX_Scroller *gfx_scroller, Position *position);
 
/* GFX POSITION SETTER */
 
void nc_set_position_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic, short x, short y);
 
void nc_set_position_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  short x,
  short y
);
 
void nc_set_position_gfx_scroller(GFX_Scroller *gfx_scroller, short x, short y);
void nc_set_position_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite, short x, short y);
void nc_set_position_gfx_picture(GFX_Picture *gfx_picture, short x, short y);
 
/* GFX POSITION MOVE*/
 
void nc_move_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic, short x_offset, short y_offset);
 
void nc_move_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  short x_offset,
  short y_offset
);
 
void nc_move_gfx_animated_sprite(
  GFX_Animated_Sprite *gfx_animated_sprite,
  short x_offset,
  short y_offset
);
 
void nc_move_gfx_picture(GFX_Picture *gfx_picture, short x, short y);
void nc_move_gfx_scroller(GFX_Scroller *gfx_scroller, short x, short y);
 
  /*-------------------*/
 /*  GFX SHRUNK       */
/*-------------------*/
 
#define nc_shrunk_extract_x(value) value >> 8
#define nc_shrunk_extract_y(value) (BYTE)value
 
void nc_shrunk_centroid_gfx_picture(
  GFX_Picture *gfx_picture,
  short center_x,
  short center_y,
  WORD shrunk_value
);
 
  /*-------------------*/
 /*  GFX ANIMATION    */
/*-------------------*/
 
void nc_set_animation_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite, WORD anim);
 
void nc_set_animation_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic,
  WORD anim
);
 
void nc_update_animation_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite);
 
void nc_update_animation_gfx_animated_sprite_physic(
  GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic
);
 
  /*-------------------*/
 /*  GFX DESTROY      */
/*-------------------*/
 
void nc_destroy_gfx_scroller(GFX_Scroller *gfx_scroller);
void nc_destroy_gfx_picture(GFX_Picture *gfx_picture);
void nc_destroy_gfx_animated_sprite(GFX_Animated_Sprite *gfx_animated_sprite);
 
void nc_destroy_gfx_picture_physic(GFX_Picture_Physic *gfx_picture_physic);
void nc_destroy_gfx_animated_sprite_physic(GFX_Animated_Sprite_Physic *gfx_animated_sprite_physic);
 
  //--------------------------------------------------------------------------//
 //                                   GPU                                    //
//--------------------------------------------------------------------------//
 
void nc_init_gpu();
void nc_clear_display();
 
  /*------------------------------*/
 /* GPU VBL                      */
/*------------------------------*/
 
#define nc_wait_vbl() waitVBlank();
void nc_update();
DWORD nc_wait_vbl_max(WORD nb);
 
  /*------------------------------*/
 /* GPU SPRITE INDEX MANAGEMENT  */
/*------------------------------*/
 
void nc_clear_sprite_index_table();
WORD nc_get_max_free_sprite_index();
WORD nc_get_max_sprite_index_used();
 
  /*---------------*/
 /* GPU PALETTE   */
/*---------------*/
 
void nc_destroy_palette(const paletteInfo* paletteInfo);
void nc_clear_palette_index_table();
WORD nc_get_free_sprite_index();
WORD nc_get_max_free_palette_index();
WORD nc_get_max_palette_index_used();
void nc_read_palette_rgb16(BYTE palette_number, BYTE palette_index, RGB16 *rgb_color);
void nc_packet_color16_to_rgb16(WORD packed_color, RGB16 *rgb_color);
 
#define nc_rgb16_to_packed_color16(color) \
  ((((color.dark) & 0xF) << 12) | (((color.r) & 0xF) << 8) | (((color.g) & 0xF) << 4) | ((color.b) & 0xF))
 
#define nc_set_palette_by_packed_color16(palette_number, palette_index, color) \
  do { \
    int address = 0x400000 | ((palette_number) << 5) | ((palette_index) << 1); \
    volMEMWORD(address) = (color); \
  } while (0)
 
#define nc_set_palette_by_rgb16(palette_number, palette_index, color) \
  do { \
    WORD packed_color = nc_rgb16_to_packed_color16(color); \
    nc_set_palette_by_packed_color16(palette_number, palette_index, packed_color); \
  } while (0)
 
#define nc_get_palette_packed_color16(palette_number, palette_index) \
  ({ \
    int address = 0x400000 | ((palette_number) << 5) | ((palette_index) << 1); \
    volMEMWORD(address); \
  })
 
#define nc_set_palette_backdrop_by_packed_color16(packed_color) \
  do { \
    int address = 0x401FFE; \
    volMEMWORD(address) = (packed_color); \
  } while (0)
 
#define nc_set_palette_backdrop_by_rgb16(color) \
  do { \
    WORD packed_color = nc_rgb16_to_packed_color16(color); \
    nc_set_palette_backdrop_by_packed_color16(packed_color); \
  } while (0)
 
  /*--------------*/
 /* GPU shrunk   */
/*--------------*/
 
WORD nc_get_shrunk_proportional_table(WORD index);
int nc_shrunk_centroid_get_translated_x(short centerPosX, WORD tileWidth, BYTE shrunkX);
int nc_shrunk_centroid_get_translated_y(short centerPosY, WORD tileHeight, BYTE shrunkY);
void nc_shrunk(WORD base_sprite, WORD max_width, WORD value);
WORD nc_shrunk_forge(BYTE xc, BYTE yc);
void nc_shrunk_addr(WORD addr, WORD shrunk_value);
WORD nc_shrunk_range(WORD addr_start, WORD addr_end, WORD shrunk_value);
 
  //--------------------------------------------------------------------------//
 //                                MATH                                      //
//--------------------------------------------------------------------------//
 
#define nc_bitwise_division_2(value) (value >> 1)
 
#define nc_bitwise_division_4(value) (value >> 2)
 
#define nc_bitwise_division_8(value) (value >> 3)
#define nc_bitwise_division_16(value) (value >> 4)
#define nc_bitwise_division_32(value) (value >> 5)
#define nc_bitwise_division_64(value) (value >> 6)
#define nc_bitwise_division_128(value) (value >> 7)
#define nc_bitwise_division_256(value) (value >> 8)
 
#define nc_bitwise_multiplication_2(value) (value << 1)
#define nc_bitwise_multiplication_4(value) (value << 2)
#define nc_bitwise_multiplication_8(value) (value << 3)
#define nc_bitwise_multiplication_16(value) (value << 4)
#define nc_bitwise_multiplication_32(value) (value << 5)
#define nc_bitwise_multiplication_64(value) (value << 6)
#define nc_bitwise_multiplication_128(value) (value << 7)
#define nc_bitwise_multiplication_256(value) (value << 8)
 
#define nc_random(range) rand() % range
 
#define nc_min(a,b) ((a) < (b) ? (a) : (b))
 
#define nc_max(a,b) ((a) > (b) ? (a) : (b))
 
#define nc_abs(num) ((num) < 0 ? ~(num) + 1 : (num))
#define nc_negative(num) -num
 
#define nc_fix(num) num * 65536
#define nc_fix_to_int(num) fixtoi(num)
#define nc_int_to_fix(num) itofix(num)
#define nc_fix_add(num1, num2) fadd(num1, num2)
#define nc_fix_sub(num1, num2) fsub(num1, num2)
#define nc_fix_mul(num1, num2) fmul(num1, num2)
#define nc_cos(num) fcos(num)
#define nc_tan(num) ftan(num)
 
void nc_byte_to_hex(BYTE value, char *hexchar);
void nc_word_to_hex(WORD value, char *hexchar);
char nc_sin(WORD index);
 
  //--------------------------------------------------------------------------//
 //                                PHYSIC                                    //
//--------------------------------------------------------------------------//
 
#define nc_copy_box(box_src, box_dest) memcpy(box_dest, box_src, sizeof(Box))
 
BYTE nc_collide_boxes(Box *box, Box *boxes[], BYTE box_max);
 
BOOL nc_collide_box(Box *box1, Box *box2);
 
void nc_init_box(Box *box, short width, short height, short widthOffset, short heightOffset);
 
void nc_update_box(Box *box, short x, short y);
 
void nc_shrunk_box(Box *box, Box *bOrigin, WORD shrunkValue);
void nc_resize_box(Box *Box, short edge); // todo (minor) - deprecated ?
 
  //--------------------------------------------------------------------------//
 //                                SOUND                                     //
//--------------------------------------------------------------------------//
 
  //---------
 //    CDDA
//-----------
 
void nc_play_cdda(BYTE track);
void nc_pause_cdda();
void nc_resume_cdda();
#define nc_stop_cdda() nc_pause_cdda()
 
  //--------
 //  ADPCM
//----------
 
void nc_stop_adpcm();
 
  //----------------------------------------------------------------------------//
 //                                  JOYPAD                                    //
//----------------------------------------------------------------------------//
 
void nc_set_joypad_edge_mode(BOOL actived);
void nc_update_joypad(BYTE id);
void nc_joypad_update(BYTE id);
 
BOOL nc_joypad_is_up(BYTE id);
BOOL nc_joypad_is_down(BYTE id);
BOOL nc_joypad_is_left(BYTE id);
BOOL nc_joypad_is_right(BYTE id);
BOOL nc_joypad_is_start(BYTE id);
BOOL nc_joypad_is_a(BYTE id);
BOOL nc_joypad_is_b(BYTE id);
BOOL nc_joypad_is_c(BYTE id);
BOOL nc_joypad_is_d(BYTE id);
 
void nc_debug_joypad(BYTE id);
 
  //----------------------------------------------------------------------------//
 //                                  UTIL                                      //
//----------------------------------------------------------------------------//
 
DWORD nc_frame_to_second(DWORD frame);
DWORD nc_second_to_frame(DWORD second);
void nc_init_system();
void nc_reset();
void nc_get_relative_position(Position *position, Box box, Position world_coord); // TODO
void nc_pause(BOOL (*exitFunc)());
void nc_sleep(DWORD frame);
BOOL nc_each_frame(DWORD frame);
void nc_print(int x, int y, char *label);
WORD nc_free_ram_info();
#define nc_get_frame_counter() DAT_frameCounter
 
  /*---------------*/
 /* UTIL LOGGER   */
/*---------------*/
 
void nc_init_log();
 
WORD nc_get_position_x_log();
 
WORD nc_get_position_y_log();
 
void nc_set_position_log(WORD _x, WORD _y);
 
void nc_log_next_line();
 
void nc_fix_set_bank(WORD bank);
 
void nc_fix_set_palette_id(WORD palette);
 
WORD nc_palette_set_info(const paletteInfo *paletteInfo, WORD palette_index);
 
WORD nc_fix_load_palette_info(const paletteInfo *palette_info);
 
BOOL nc_fix_unload_palette_info(const paletteInfo *palette_info);
 
BOOL nc_fix_unload_palette_id(WORD palette_id);
 
WORD nc_log_info(char *txt, ...);
 
WORD nc_log_info_line(char *txt, ...);
 
void nc_log_word(WORD value);
void nc_log_int(int value);
void nc_log_dword(DWORD value);
void nc_log_short(short value);
void nc_log_byte(BYTE value);
void nc_log_bool(BOOL value);
void nc_log_spriteInfo(spriteInfo *si);
void nc_log_box(Box *b);
void nc_log_pictureInfo(pictureInfo *pi);
void nc_log_palette_info(paletteInfo *paletteInfo);
void nc_log_packed_color16(WORD packed_color);
void nc_log_rgb16(RGB16 *color);
 
  /*---------------*/
 /* SOUND         */
/*---------------*/
 
void nc_init_adpcm();
void nc_update_adpcm_player();
void nc_push_remaining_frame_adpcm_player(DWORD frame);
Adpcm_player *nc_get_adpcm_player();
 
  /*---------------*/
 /* UTIL VECTOR   */
/*---------------*/
 
BOOL nc_vectors_collide(Box *box, Position vec[], BYTE vector_max);
BOOL nc_vector_is_left(short x, short y, short v1x, short v1y, short v2x, short v2y);
 
#endif