From 97f8eca559ee318131a11436b12f06b61b8629ad Mon Sep 17 00:00:00 2001 From: John Tsiombikas Date: Fri, 28 Oct 2022 22:02:56 +0300 Subject: [PATCH 1/1] added logo splash screen --- Makefile | 7 +- src/data.h | 4 + src/data.s | 9 + src/game.c | 4 + src/gba/main.c | 7 +- src/logoscr.c | 179 +++++ src/meshdata.h | 590 ++++++++++++++++ src/polyfill.c | 5 +- src/polyfill.h | 2 +- src/util.h | 3 + src/xgl.c | 14 +- tools/meshdump/Makefile | 13 + tools/meshdump/cmesh.c | 1638 +++++++++++++++++++++++++++++++++++++++++++++ tools/meshdump/cmesh.h | 138 ++++ tools/meshdump/dynarr.c | 141 ++++ tools/meshdump/dynarr.h | 80 +++ tools/meshdump/main.c | 71 ++ tools/meshdump/meshload.c | 398 +++++++++++ tools/meshdump/rbtree.c | 503 ++++++++++++++ tools/meshdump/rbtree.h | 78 +++ 20 files changed, 3874 insertions(+), 10 deletions(-) create mode 100644 src/logoscr.c create mode 100644 src/meshdata.h create mode 100644 tools/meshdump/Makefile create mode 100644 tools/meshdump/cmesh.c create mode 100644 tools/meshdump/cmesh.h create mode 100644 tools/meshdump/dynarr.c create mode 100644 tools/meshdump/dynarr.h create mode 100644 tools/meshdump/main.c create mode 100644 tools/meshdump/meshload.c create mode 100644 tools/meshdump/rbtree.c create mode 100644 tools/meshdump/rbtree.h diff --git a/Makefile b/Makefile index 3a2a7e6..e73d3dc 100644 --- a/Makefile +++ b/Makefile @@ -6,8 +6,8 @@ name = voxelburg elf = $(name).elf bin = $(name).gba -data = data/color.raw data/color.pal data/height.raw \ - data/spr_game.raw data/spr_game.pal data/menuscr.555 +data = data/color.raw data/color.pal data/height.raw data/menuscr.555 \ + data/spr_game.raw data/spr_game.pal data/spr_logo.raw data/spr_logo.pal libs = libs/maxmod/libmm.a @@ -55,6 +55,9 @@ src/data.arm.o: src/data.s $(data) tools/pngdump/pngdump: $(MAKE) -C tools/pngdump +tools/meshdump/meshdump: + $(MAKE) -C tools/meshdump + tools/lutgen: tools/lutgen.c cc -o $@ $< -lm diff --git a/src/data.h b/src/data.h index 78fc613..7b9684c 100644 --- a/src/data.h +++ b/src/data.h @@ -41,4 +41,8 @@ extern unsigned char spr_game_cmap[]; /* menu screen assets */ extern unsigned char menuscr_pixels[]; +/* logo splash assets */ +extern unsigned char spr_logo_pixels[]; +extern unsigned char spr_logo_cmap[]; + #endif /* DATA_H_ */ diff --git a/src/data.s b/src/data.s index fd9a5f7..b061441 100644 --- a/src/data.s +++ b/src/data.s @@ -6,6 +6,8 @@ .globl spr_game_pixels .globl spr_game_cmap .globl menuscr_pixels + .globl spr_logo_pixels + .globl spr_logo_cmap .align 1 color_pixels: @@ -27,3 +29,10 @@ spr_game_cmap: .align 1 menuscr_pixels: .incbin "data/menuscr.555" + + .align 1 +spr_logo_pixels: + .incbin "data/spr_logo.raw" + .align 1 +spr_logo_cmap: + .incbin "data/spr_logo.pal" diff --git a/src/game.c b/src/game.c index c203e5b..3c00d3b 100644 --- a/src/game.c +++ b/src/game.c @@ -2,6 +2,7 @@ #include "gba.h" #include "game.h" +struct screen *init_logo_screen(void); struct screen *init_menu_screen(void); struct screen *init_game_screen(void); @@ -13,6 +14,9 @@ static int num_scr; int init_screens(void) { + if(!(scrlist[num_scr++] = init_logo_screen())) { + return -1; + } if(!(scrlist[num_scr++] = init_menu_screen())) { return -1; } diff --git a/src/gba/main.c b/src/gba/main.c index 16c9ec9..982463f 100644 --- a/src/gba/main.c +++ b/src/gba/main.c @@ -5,6 +5,7 @@ #include "game.h" #include "maxmod.h" #include "input.h" +#include "xgl.h" static void vblank(void); @@ -33,12 +34,14 @@ int main(void) REG_DISPSTAT |= DISPSTAT_IEN_VBLANK; unmask(INTR_VBLANK); + xgl_init(); + if(init_screens() == -1) { panic(get_pc(), "failed to initialize screens"); } - if(change_screen(find_screen("menu")) == -1) { - panic(get_pc(), "failed to find game screen"); + if(change_screen(find_screen("logo")) == -1) { + panic(get_pc(), "failed to find starting screen"); } intr_enable(); diff --git a/src/logoscr.c b/src/logoscr.c new file mode 100644 index 0000000..3b822e0 --- /dev/null +++ b/src/logoscr.c @@ -0,0 +1,179 @@ +#include "gbaregs.h" +#include "game.h" +#include "gba.h" +#include "dma.h" +#include "sprite.h" +#include "util.h" +#include "xgl.h" +#include "polyfill.h" +#include "timer.h" +#include "data.h" +#include "meshdata.h" +#include "debug.h" + +static int logoscr_start(void); +static void logoscr_stop(void); +static void logoscr_frame(void); +static void logoscr_vblank(void); + +static struct screen logoscr = { + "logo", + logoscr_start, + logoscr_stop, + logoscr_frame, + logoscr_vblank +}; + +static uint16_t *framebuf; +static int nframes, backbuf; +static uint16_t *vram[] = { gba_vram_lfb0, gba_vram_lfb1 }; + +static int nfaces; +static struct { int32_t x, y; } *pos; + +#define MAX_SPR 4 +static uint16_t oam[4 * MAX_SPR]; + +static int16_t sprmat[4]; + + +struct screen *init_logo_screen(void) +{ + return &logoscr; +} + + +static int logoscr_start(void) +{ + int i; + unsigned int sprflags; + + gba_setmode(4, DISPCNT_BG2 | DISPCNT_OBJ); + + gba_bgpal[0] = 0; + gba_bgpal[0xff] = 0xffff; + + xgl_viewport(0, 0, 240, 160); + + nfaces = sizeof logomesh / sizeof *logomesh / 3; + pos = malloc_nf(nfaces * sizeof *pos); + + for(i=0; i 0x20000) { + tout = (tm - 0x20000) * 5 / 3; + + if(tout > X_HPI + 0x1800) { + tout = X_HPI + 0x1800; + change_screen(find_screen("menu")); + return; + } + } + + backbuf = ++nframes & 1; + framebuf = vram[backbuf]; + + polyfill_framebuffer(framebuf, 240, 160); + fillblock_16byte(framebuf, 0, 240 * 160 / 16); + + xgl_load_identity(); + xgl_scale(0x10000, 0xcccc, 0x10000); + xgl_translate(0, 0, (14 << 16) - (tout << 2)); + xgl_rotate_x(-X_HPI); + xgl_rotate_y(tout); + xgl_rotate_z(tout); + + xgl_index(0xff); + vptr = logomesh; + for(i=0; i> 8)) >> 8; + y = (pos[i].y * (tgoat >> 8)) >> 8; + + xgl_push_matrix(); + xgl_translate(x, 0, y); + xgl_draw(XGL_TRIANGLES, vptr, 3); + xgl_pop_matrix(); + + vptr += 3; + } + + wait_vblank(); + present(backbuf); + + if(!(nframes & 15)) { + emuprint("vbl: %d", vblperf_count); + } +#ifdef VBLBAR + vblperf_begin(); +#else + vblperf_count = 0; +#endif +} + +ARM_IWRAM +static void logoscr_vblank(void) +{ + tm = timer_msec << 5; + + tname = 0x10000 - (tm - 0x10000); + if(tname < 0) tname = 0; + if(tname > 0x10000) tname = 0x10000; + + REG_BLDY = tname >> 12; + + if(tm > 0x20000) { + if(sprmat[0] > 0) { + sprmat[0] -= 2; + } + spr_transform(oam, 0, sprmat); + REG_BLDY = (0x100 - sprmat[0]) >> 4; + REG_BLDCNT = BLDCNT_DARKEN | BLDCNT_A_OBJ | BLDCNT_A_BG2; + } + + dma_copy32(3, (void*)OAM_ADDR, oam, MAX_SPR * 2, 0); +} diff --git a/src/meshdata.h b/src/meshdata.h new file mode 100644 index 0000000..59fa4a7 --- /dev/null +++ b/src/meshdata.h @@ -0,0 +1,590 @@ +#include "xgl.h" + +static struct xvertex logomesh[] __attribute__((section(".rodata"))) = { + { -12855, 0, 140018, 0, 65536, 0, 0, 0, 0xff}, + { 22472, 0, 140018, 0, 65536, 0, 0, 0, 0xff}, + { 7640, 0, 295502, 0, 65536, 0, 0, 0, 0xff}, + { 22472, 0, 140018, 0, 65536, 0, 0, 0, 0xff}, + { -12855, 0, 140018, 0, 65536, 0, 0, 0, 0xff}, + { -1163, 0, 136278, 0, 65536, 0, 0, 0, 0xff}, + { -16725, 0, 111723, 0, 65536, 0, 0, 0, 0xff}, + { -7235, 0, 111668, 0, 65536, 0, 0, 0, 0xff}, + { -2749, 0, 115054, 0, 65536, 0, 65536, 65536, 0xff}, + { -7235, 0, 111668, 0, 65536, 0, 0, 0, 0xff}, + { 2101, 0, 114512, 0, 65536, 0, 65536, 65536, 0xff}, + { -2749, 0, 115054, 0, 65536, 0, 65536, 65536, 0xff}, + { 2101, 0, 114512, 0, 65536, 0, 65536, 65536, 0xff}, + { 17594, 0, 118898, 0, 65536, 0, 0, 0, 0xff}, + { -2749, 0, 115054, 0, 65536, 0, 65536, 65536, 0xff}, + { 24905, 0, 115026, 0, 65536, 0, 65536, 65536, 0xff}, + { 17594, 0, 118898, 0, 65536, 0, 0, 0, 0xff}, + { 17098, 0, 116680, 0, 65536, 0, 0, 0, 0xff}, + { 27274, 0, 97629, 0, 65536, 0, 65536, 65536, 0xff}, + { 24905, 0, 115026, 0, 65536, 0, 65536, 65536, 0xff}, + { 17098, 0, 116680, 0, 65536, 0, 0, 0, 0xff}, + { 24905, 0, 115026, 0, 65536, 0, 65536, 65536, 0xff}, + { 45765, 0, 112509, 0, 65536, 0, 65536, 65536, 0xff}, + { 17594, 0, 118898, 0, 65536, 0, 0, 0, 0xff}, + { 40560, 0, 111407, 0, 65536, 0, 0, 0, 0xff}, + { 46839, 0, 108075, 0, 65536, 0, 65536, 65536, 0xff}, + { 45765, 0, 112509, 0, 65536, 0, 65536, 65536, 0xff}, + { 46839, 0, 108075, 0, 65536, 0, 65536, 65536, 0xff}, + { 40560, 0, 111407, 0, 65536, 0, 0, 0, 0xff}, + { 38605, 0, 92930, 0, 65536, 0, 65536, 65536, 0xff}, + { 46839, 0, 108075, 0, 65536, 0, 65536, 65536, 0xff}, + { 66294, 0, 97688, 0, 65536, 0, 0, 0, 0xff}, + { 45765, 0, 112509, 0, 65536, 0, 65536, 65536, 0xff}, + { 60386, 0, 96920, 0, 65536, 0, 65536, 65536, 0xff}, + { 66995, 0, 92614, 0, 65536, 0, 0, 0, 0xff}, + { 66294, 0, 97688, 0, 65536, 0, 0, 0, 0xff}, + { -94976, 0, 93183, 0, 65536, 0, 0, 0, 0xff}, + { -82974, 0, 105751, 0, 65536, 0, 0, 0, 0xff}, + {-141620, 0, 151139, 0, 65536, 0, 0, 0, 0xff}, + { 22472, 0, 140018, 0, 65536, 0, 0, 0, 0xff}, + { -1163, 0, 136278, 0, 65536, 0, 0, 0, 0xff}, + { 11140, 0, 136134, 0, 65536, 0, 0, 0, 0xff}, + { 11140, 0, 136134, 0, 65536, 0, 0, 0, 0xff}, + { -1163, 0, 136278, 0, 65536, 0, 0, 0, 0xff}, + { 4518, 0, 122326, 0, 65536, 0, 0, 0, 0xff}, + { 99775, 0, 104686, 0, 65536, 0, 0, 0, 0xff}, + { 112016, 0, 92963, 0, 65536, 0, 0, 0, 0xff}, + { 157659, 0, 150807, 0, 65536, 0, 0, 0, 0xff}, + { 2101, 0, 114512, 0, 65536, 0, 65536, 65536, 0xff}, + { 17098, 0, 116680, 0, 65536, 0, 0, 0, 0xff}, + { 17594, 0, 118898, 0, 65536, 0, 0, 0, 0xff}, + { -47878, 0, 65534, 0, 65536, 0, 65536, 65536, 0xff}, + { -46507, 0, 85129, 0, 65536, 0, 65536, 65536, 0xff}, + { -60551, 0, 63728, 0, 65536, 0, 0, 0, 0xff}, + { -46507, 0, 85129, 0, 65536, 0, 65536, 65536, 0xff}, + { -39155, 0, 78919, 0, 65536, 0, 0, 0, 0xff}, + { -36657, 0, 84711, 0, 65536, 0, 65536, 65536, 0xff}, + { -36657, 0, 84711, 0, 65536, 0, 65536, 65536, 0xff}, + { -39155, 0, 78919, 0, 65536, 0, 0, 0, 0xff}, + { -9575, 0, 73994, 0, 65536, 0, 0, 0, 0xff}, + { -36657, 0, 84711, 0, 65536, 0, 65536, 65536, 0xff}, + { -36126, 0, 97608, 0, 65536, 0, 65536, 65536, 0xff}, + { -46507, 0, 85129, 0, 65536, 0, 65536, 65536, 0xff}, + { -36126, 0, 97608, 0, 65536, 0, 65536, 65536, 0xff}, + { -20669, 0, 102834, 0, 65536, 0, 0, 0, 0xff}, + { -16725, 0, 111723, 0, 65536, 0, 0, 0, 0xff}, + { -20669, 0, 102834, 0, 65536, 0, 0, 0, 0xff}, + { -27650, 0, 97046, 0, 65536, 0, 65536, 65536, 0xff}, + { 1635, 0, 86938, 0, 65536, 0, 65536, 65536, 0xff}, + { 2101, 0, 114512, 0, 65536, 0, 65536, 65536, 0xff}, + { -7235, 0, 111668, 0, 65536, 0, 0, 0, 0xff}, + { 14693, 0, 94786, 0, 65536, 0, 0, 0, 0xff}, + { 66995, 0, 92614, 0, 65536, 0, 0, 0, 0xff}, + { 60386, 0, 96920, 0, 65536, 0, 65536, 65536, 0xff}, + { 55746, 0, 84870, 0, 65536, 0, 65536, 65536, 0xff}, + { 66995, 0, 92614, 0, 65536, 0, 0, 0, 0xff}, + { 96165, 0, 80602, 0, 65536, 0, 65536, 65536, 0xff}, + { 66294, 0, 97688, 0, 65536, 0, 0, 0, 0xff}, + { 93891, 0, 72352, 0, 65536, 0, 0, 0, 0xff}, + { 118076, 0, 76260, 0, 65536, 0, 0, 0, 0xff}, + { 96165, 0, 80602, 0, 65536, 0, 65536, 65536, 0xff}, + { 50466, 0, 81395, 0, 65536, 0, 0, 0, 0xff}, + { 38151, 0, 83142, 0, 65536, 0, 0, 0, 0xff}, + { 48974, 0, 78095, 0, 65536, 0, 0, 0, 0xff}, + { 38550, 0, 86806, 0, 65536, 0, 0, 0, 0xff}, + { 26600, 0, 82102, 0, 65536, 0, 0, 0, 0xff}, + { 38151, 0, 83142, 0, 65536, 0, 0, 0, 0xff}, + { 26600, 0, 82102, 0, 65536, 0, 0, 0, 0xff}, + { 10079, 0, 79954, 0, 65536, 0, 0, 0, 0xff}, + { 11164, 0, 67190, 0, 65536, 0, 0, 0, 0xff}, + { 11164, 0, 67190, 0, 65536, 0, 0, 0, 0xff}, + { 10079, 0, 79954, 0, 65536, 0, 0, 0, 0xff}, + { 1636, 0, 70954, 0, 65536, 0, 0, 0, 0xff}, + { -36657, 0, 84711, 0, 65536, 0, 65536, 65536, 0xff}, + { -27650, 0, 97046, 0, 65536, 0, 65536, 65536, 0xff}, + { -36126, 0, 97608, 0, 65536, 0, 65536, 65536, 0xff}, + { -36126, 0, 97608, 0, 65536, 0, 65536, 65536, 0xff}, + { -27650, 0, 97046, 0, 65536, 0, 65536, 65536, 0xff}, + { -20669, 0, 102834, 0, 65536, 0, 0, 0, 0xff}, + { -16725, 0, 111723, 0, 65536, 0, 0, 0, 0xff}, + { -20669, 0, 102834, 0, 65536, 0, 0, 0, 0xff}, + { -7235, 0, 111668, 0, 65536, 0, 0, 0, 0xff}, + { 24905, 0, 115026, 0, 65536, 0, 65536, 65536, 0xff}, + { 40560, 0, 111407, 0, 65536, 0, 0, 0, 0xff}, + { 45765, 0, 112509, 0, 65536, 0, 65536, 65536, 0xff}, + { 46839, 0, 108075, 0, 65536, 0, 65536, 65536, 0xff}, + { 60386, 0, 96920, 0, 65536, 0, 65536, 65536, 0xff}, + { 66294, 0, 97688, 0, 65536, 0, 0, 0, 0xff}, + { 66995, 0, 92614, 0, 65536, 0, 0, 0, 0xff}, + { 93891, 0, 72352, 0, 65536, 0, 0, 0, 0xff}, + { 96165, 0, 80602, 0, 65536, 0, 65536, 65536, 0xff}, + { -71273, 0, 32850, 0, 65536, 0, 0, 0, 0xff}, + { -65731, 0, 48439, 0, 65536, 0, 0, 0, 0xff}, + { -75383, 0, 52933, 0, 65536, 0, 0, 0, 0xff}, + { -65731, 0, 48439, 0, 65536, 0, 0, 0, 0xff}, + { -47878, 0, 65534, 0, 65536, 0, 65536, 65536, 0xff}, + { -75383, 0, 52933, 0, 65536, 0, 0, 0, 0xff}, + { -47878, 0, 65534, 0, 65536, 0, 65536, 65536, 0xff}, + { -39155, 0, 78919, 0, 65536, 0, 0, 0, 0xff}, + { -46507, 0, 85129, 0, 65536, 0, 65536, 65536, 0xff}, + { 54916, 0, 25594, 0, 65536, 0, 0, 0, 0xff}, + { 79436, 0, 43991, 0, 65536, 0, 0, 0, 0xff}, + { 58231, 0, 48093, 0, 65536, 0, 0, 0, 0xff}, + { 79436, 0, 43991, 0, 65536, 0, 0, 0, 0xff}, + { 69556, 0, 59745, 0, 65536, 0, 0, 0, 0xff}, + { 58231, 0, 48093, 0, 65536, 0, 0, 0, 0xff}, + { 58231, 0, 48093, 0, 65536, 0, 0, 0, 0xff}, + { 59052, 0, 66201, 0, 65536, 0, 0, 0, 0xff}, + { 56207, 0, 65763, 0, 65536, 0, 0, 0, 0xff}, + { 59052, 0, 66201, 0, 65536, 0, 0, 0, 0xff}, + { 48974, 0, 78095, 0, 65536, 0, 0, 0, 0xff}, + { 56207, 0, 65763, 0, 65536, 0, 0, 0, 0xff}, + { -65731, 0, 48439, 0, 65536, 0, 0, 0, 0xff}, + { -38854, 0, 63972, 0, 65536, 0, 0, 0, 0xff}, + { -47878, 0, 65534, 0, 65536, 0, 65536, 65536, 0xff}, + { -47878, 0, 65534, 0, 65536, 0, 65536, 65536, 0xff}, + { -38854, 0, 63972, 0, 65536, 0, 0, 0, 0xff}, + { -39155, 0, 78919, 0, 65536, 0, 0, 0, 0xff}, + { 93891, 0, 72352, 0, 65536, 0, 0, 0, 0xff}, + { 100539, 0, 61349, 0, 65536, 0, 65536, 65536, 0xff}, + { 118076, 0, 76260, 0, 65536, 0, 0, 0, 0xff}, + { 26600, 0, 82102, 0, 65536, 0, 0, 0, 0xff}, + { 24657, 0, 86338, 0, 65536, 0, 0, 0, 0xff}, + { 10079, 0, 79954, 0, 65536, 0, 0, 0, 0xff}, + { 100539, 0, 61349, 0, 65536, 0, 65536, 65536, 0xff}, + { 93891, 0, 72352, 0, 65536, 0, 0, 0, 0xff}, + { 78751, 0, 30740, 0, 65536, 0, 0, 0, 0xff}, + { 79436, 0, 43991, 0, 65536, 0, 0, 0, 0xff}, + { 81351, 0, 69321, 0, 65536, 0, 0, 0, 0xff}, + { 69556, 0, 59745, 0, 65536, 0, 0, 0, 0xff}, + { 58231, 0, 48093, 0, 65536, 0, 0, 0, 0xff}, + { 69556, 0, 59745, 0, 65536, 0, 0, 0, 0xff}, + { 59052, 0, 66201, 0, 65536, 0, 0, 0, 0xff}, + { 59052, 0, 66201, 0, 65536, 0, 0, 0, 0xff}, + { 50466, 0, 81395, 0, 65536, 0, 0, 0, 0xff}, + { 48974, 0, 78095, 0, 65536, 0, 0, 0, 0xff}, + { 50466, 0, 81395, 0, 65536, 0, 0, 0, 0xff}, + { 38550, 0, 86806, 0, 65536, 0, 0, 0, 0xff}, + { 38151, 0, 83142, 0, 65536, 0, 0, 0, 0xff}, + { 38550, 0, 86806, 0, 65536, 0, 0, 0, 0xff}, + { 24657, 0, 86338, 0, 65536, 0, 0, 0, 0xff}, + { 26600, 0, 82102, 0, 65536, 0, 0, 0, 0xff}, + {-193321, 0, -5240, 0, 65536, 0, 0, 0, 0xff}, + {-174061, 0, 17832, 0, 65536, 0, 0, 0, 0xff}, + {-186686, 0, 16206, 0, 65536, 0, 0, 0, 0xff}, + { -34243, 0, 30391, 0, 65536, 0, 0, 0, 0xff}, + { -50418, 0, 30729, 0, 65536, 0, 0, 0, 0xff}, + { -49220, 0, 28597, 0, 65536, 0, 0, 0, 0xff}, + { -34243, 0, 30391, 0, 65536, 0, 0, 0, 0xff}, + { -49220, 0, 28597, 0, 65536, 0, 0, 0, 0xff}, + { -45233, 0, 24903, 0, 65536, 0, 0, 0, 0xff}, + {-193321, 0, -5240, 0, 65536, 0, 0, 0, 0xff}, + {-186686, 0, 16206, 0, 65536, 0, 0, 0, 0xff}, + {-284594, 0, 6990, 0, 65536, 0, 65536, 65536, 0xff}, + {-174061, 0, 17832, 0, 65536, 0, 0, 0, 0xff}, + {-131053, 0, -1063, 0, 65536, 0, 0, 0, 0xff}, + {-133580, 0, 25998, 0, 65536, 0, 65536, 65536, 0xff}, + {-133580, 0, 25998, 0, 65536, 0, 65536, 65536, 0xff}, + {-131053, 0, -1063, 0, 65536, 0, 0, 0, 0xff}, + {-127422, 0, 11747, 0, 65536, 0, 0, 0, 0xff}, + {-118515, 0, 18160, 0, 65536, 0, 65536, 65536, 0xff}, + {-102848, 0, 27602, 0, 65536, 0, 0, 0, 0xff}, + {-133580, 0, 25998, 0, 65536, 0, 65536, 65536, 0xff}, + {-127422, 0, 11747, 0, 65536, 0, 0, 0, 0xff}, + {-118515, 0, 18160, 0, 65536, 0, 65536, 65536, 0xff}, + {-133580, 0, 25998, 0, 65536, 0, 65536, 65536, 0xff}, + {-102848, 0, 27602, 0, 65536, 0, 0, 0, 0xff}, + {-118515, 0, 18160, 0, 65536, 0, 65536, 65536, 0xff}, + {-101768, 0, 13617, 0, 65536, 0, 65536, 65536, 0xff}, + {-133580, 0, 25998, 0, 65536, 0, 65536, 65536, 0xff}, + {-102848, 0, 27602, 0, 65536, 0, 0, 0, 0xff}, + { -94742, 0, 45684, 0, 65536, 0, 0, 0, 0xff}, + { -82948, 0, 6812, 0, 65536, 0, 0, 0, 0xff}, + { -68746, 0, 25425, 0, 65536, 0, 65536, 65536, 0xff}, + { -71273, 0, 32850, 0, 65536, 0, 0, 0, 0xff}, + { -71273, 0, 32850, 0, 65536, 0, 0, 0, 0xff}, + { -65549, 0, 26166, 0, 65536, 0, 65536, 65536, 0xff}, + { -65731, 0, 48439, 0, 65536, 0, 0, 0, 0xff}, + { -65549, 0, 26166, 0, 65536, 0, 65536, 65536, 0xff}, + { -68746, 0, 25425, 0, 65536, 0, 65536, 65536, 0xff}, + { -65039, 0, 17271, 0, 65536, 0, 65536, 65536, 0xff}, + { 100539, 0, 61349, 0, 65536, 0, 65536, 65536, 0xff}, + { 78751, 0, 30740, 0, 65536, 0, 0, 0, 0xff}, + { 80512, 0, 27939, 0, 65536, 0, 0, 0, 0xff}, + { -47461, 0, 23437, 0, -65536, 0, 0, 0, 0xff}, + { -59425, 0, 16751, 0, -65536, 0, 0, 0, 0xff}, + { -49220, 0, 28597, 0, -65536, 0, 0, 0, 0xff}, + { -49220, 0, 28597, 0, 65536, 0, 0, 0, 0xff}, + { -50418, 0, 30729, 0, 65536, 0, 0, 0, 0xff}, + { -59425, 0, 16751, 0, 65536, 0, 0, 0, 0xff}, + { -71273, 0, 32850, 0, 65536, 0, 0, 0, 0xff}, + { -68746, 0, 25425, 0, 65536, 0, 65536, 65536, 0xff}, + { -65549, 0, 26166, 0, 65536, 0, 65536, 65536, 0xff}, + { 80512, 0, 27939, 0, 65536, 0, 0, 0, 0xff}, + { 78751, 0, 30740, 0, 65536, 0, 0, 0, 0xff}, + { 59604, 0, 7933, 0, 65536, 0, 0, 0, 0xff}, + { 54916, 0, 25594, 0, 65536, 0, 0, 0, 0xff}, + { 59166, 0, 12091, 0, 65536, 0, 0, 0, 0xff}, + { 79436, 0, 43991, 0, 65536, 0, 0, 0, 0xff}, + { -34243, 0, 30391, 0, 65536, 0, 0, 0, 0xff}, + { -40235, 0, 43741, 0, 65536, 0, 0, 0, 0xff}, + { -50418, 0, 30729, 0, 65536, 0, 0, 0, 0xff}, + { 22364, 0, 47913, 0, 65536, 0, 0, 0, 0xff}, + { 41000, 0, 43862, 0, 65536, 0, 0, 0, 0xff}, + { 31381, 0, 58089, 0, 65536, 0, 0, 0, 0xff}, + { 302210, 0, 1827, 0, 65536, 0, 65536, 65536, 0xff}, + { 149161, 0, 6082, 0, 65536, 0, 65536, 65536, 0xff}, + { 139861, 0, -13458, 0, 65536, 0, 0, 0, 0xff}, + { 139861, 0, -13458, 0, 65536, 0, 0, 0, 0xff}, + { 149161, 0, 6082, 0, 65536, 0, 65536, 65536, 0xff}, + { 128423, 0, 1827, 0, 65536, 0, 0, 0, 0xff}, + { 128423, 0, 1827, 0, 65536, 0, 0, 0, 0xff}, + { 118162, 0, -5441, 0, 65536, 0, 65536, 65536, 0xff}, + { 139861, 0, -13458, 0, 65536, 0, 0, 0, 0xff}, + { 118162, 0, -5441, 0, 65536, 0, 65536, 65536, 0xff}, + { 128423, 0, 1827, 0, 65536, 0, 0, 0, 0xff}, + { 103731, 0, 11554, 0, 65536, 0, 65536, 65536, 0xff}, + { 80512, 0, 27939, 0, 65536, 0, 0, 0, 0xff}, + { 59604, 0, 7933, 0, 65536, 0, 0, 0, 0xff}, + { 61256, 0, 5307, 0, 65536, 0, 0, 0, 0xff}, + { 69290, 0, -27593, 0, 65536, 0, 32768, 32768, 0xff}, + { 65269, 0, -1924, 0, 65536, 0, 65536, 65536, 0xff}, + { 41280, 0, -10932, 0, 65536, 0, 65536, 65536, 0xff}, + { 90570, 0, -6556, 0, 65536, 0, 0, 0, 0xff}, + { 84756, 0, 8081, 0, 65536, 0, 0, 0, 0xff}, + { 75331, 0, 11760, 0, 65536, 0, 65536, 65536, 0xff}, + { 75331, 0, 11760, 0, 65536, 0, 65536, 65536, 0xff}, + { 84756, 0, 8081, 0, 65536, 0, 0, 0, 0xff}, + { 87834, 0, 33016, 0, 65536, 0, 0, 0, 0xff}, + { 302210, 0, 1827, 0, 65536, 0, 65536, 65536, 0xff}, + { 146254, 0, 22544, 0, 65536, 0, 0, 0, 0xff}, + { 149161, 0, 6082, 0, 65536, 0, 65536, 65536, 0xff}, + { -9299, 0, 2876, 0, 65536, 0, 65536, 65536, 0xff}, + { -7819, 0, 25377, 0, 65536, 0, 0, 0, 0xff}, + { -25238, 0, 3593, 0, 65536, 0, 65536, 65536, 0xff}, + { -9299, 0, 2876, 0, 65536, 0, 65536, 65536, 0xff}, + { 7840, 0, -6237, 0, 65536, 0, 0, 0, 0xff}, + { -7819, 0, 25377, 0, 65536, 0, 0, 0, 0xff}, + { 130483, 0, -24934, 0, 65536, 0, 0, 0, 0xff}, + { 90570, 0, -6556, 0, 65536, 0, 0, 0, 0xff}, + { 134427, 0, -30955, 0, 65536, 0, 0, 0, 0xff}, + { 61256, 0, 5307, 0, 65536, 0, 0, 0, 0xff}, + { 38473, 0, -2851, 0, 65536, 0, 0, 0, 0xff}, + { 38906, 0, -5057, 0, 65536, 0, 0, 0, 0xff}, + { 13597, 0, -11012, 0, 65536, 0, 0, 0, 0xff}, + { 40195, 0, -46919, 0, 65536, 0, 0, 0, 0xff}, + { 41280, 0, -10932, 0, 65536, 0, 65536, 65536, 0xff}, + { 38906, 0, -5057, 0, 65536, 0, 0, 0, 0xff}, + { 17044, 0, -3185, 0, 65536, 0, 0, 0, 0xff}, + { 13927, 0, -4638, 0, 65536, 0, 0, 0, 0xff}, + { 17044, 0, -3185, 0, 65536, 0, 0, 0, 0xff}, + { 8709, 0, -1626, 0, 65536, 0, 0, 0, 0xff}, + { 13927, 0, -4638, 0, 65536, 0, 0, 0, 0xff}, + { 19734, 0, 1117, 0, 65536, 0, 0, 0, 0xff}, + { 37056, 0, -388, 0, 65536, 0, 0, 0, 0xff}, + { 35765, 0, 6712, 0, 65536, 0, 0, 0, 0xff}, + { 35765, 0, 6712, 0, 65536, 0, 0, 0, 0xff}, + { 59166, 0, 12091, 0, 65536, 0, 0, 0, 0xff}, + { 54916, 0, 25594, 0, 65536, 0, 0, 0, 0xff}, + { 25971, 0, 8795, 0, 65536, 0, 0, 0, 0xff}, + { 378, 0, 23867, 0, 65536, 0, 0, 0, 0xff}, + { 9496, 0, 3685, 0, 65536, 0, 0, 0, 0xff}, + { 7435, 0, 35289, 0, 65536, 0, 0, 0, 0xff}, + { 32383, 0, 25226, 0, 65536, 0, 0, 0, 0xff}, + { 21863, 0, 39697, 0, 65536, 0, 0, 0, 0xff}, + { 21863, 0, 39697, 0, 65536, 0, 0, 0, 0xff}, + { 41000, 0, 43862, 0, 65536, 0, 0, 0, 0xff}, + { 22364, 0, 47913, 0, 65536, 0, 0, 0, 0xff}, + { 22364, 0, 47913, 0, 65536, 0, 0, 0, 0xff}, + { 31381, 0, 58089, 0, 65536, 0, 0, 0, 0xff}, + { 16252, 0, 59191, 0, 65536, 0, 0, 0, 0xff}, + { 32383, 0, 25226, 0, 65536, 0, 0, 0, 0xff}, + { 25971, 0, 8795, 0, 65536, 0, 0, 0, 0xff}, + { 35890, 0, 19615, 0, 65536, 0, 0, 0, 0xff}, + {-193321, 0, -5240, 0, 65536, 0, 0, 0, 0xff}, + {-118749, 0, -15190, 0, 65536, 0, 0, 0, 0xff}, + {-174061, 0, 17832, 0, 65536, 0, 0, 0, 0xff}, + {-174061, 0, 17832, 0, 65536, 0, 0, 0, 0xff}, + {-118749, 0, -15190, 0, 65536, 0, 0, 0, 0xff}, + {-131053, 0, -1063, 0, 65536, 0, 0, 0, 0xff}, + { 61256, 0, 5307, 0, 65536, 0, 0, 0, 0xff}, + { 59604, 0, 7933, 0, 65536, 0, 0, 0, 0xff}, + { 38473, 0, -2851, 0, 65536, 0, 0, 0, 0xff}, + { 25971, 0, 8795, 0, 65536, 0, 0, 0, 0xff}, + { 7435, 0, 35289, 0, 65536, 0, 0, 0, 0xff}, + { 378, 0, 23867, 0, 65536, 0, 0, 0, 0xff}, + { 7435, 0, 35289, 0, 65536, 0, 0, 0, 0xff}, + { 25971, 0, 8795, 0, 65536, 0, 0, 0, 0xff}, + { 32383, 0, 25226, 0, 65536, 0, 0, 0, 0xff}, + { 21863, 0, 39697, 0, 65536, 0, 0, 0, 0xff}, + { 32383, 0, 25226, 0, 65536, 0, 0, 0, 0xff}, + { 41000, 0, 43862, 0, 65536, 0, 0, 0, 0xff}, + { 55268, 0, -61576, 0, 65536, 0, 65536, 65536, 0xff}, + { 69290, 0, -27593, 0, 65536, 0, 32768, 32768, 0xff}, + { 40195, 0, -46919, 0, 65536, 0, 0, 0, 0xff}, + { 40195, 0, -46919, 0, 65536, 0, 0, 0, 0xff}, + { 69290, 0, -27593, 0, 65536, 0, 32768, 32768, 0xff}, + { 41280, 0, -10932, 0, 65536, 0, 65536, 65536, 0xff}, + { 7840, 0, -6237, 0, 65536, 0, 0, 0, 0xff}, + { -5203, 0, -13590, 0, 65536, 0, 65536, 65536, 0xff}, + { 1377, 0, -19416, 0, 65536, 0, 0, 0, 0xff}, + { 1377, 0, -19416, 0, 65536, 0, 0, 0, 0xff}, + { -32343, 0, -26406, 0, 65536, 0, 65536, 65536, 0xff}, + { -33417, 0, -31096, 0, 65536, 0, 0, 0, 0xff}, + { -62009, 0, -27601, 0, 65536, 0, 65536, 65536, 0xff}, + { -71813, 0, -20879, 0, 65536, 0, 0, 0, 0xff}, + { -71762, 0, -25340, 0, 65536, 0, 65536, 65536, 0xff}, + { -71813, 0, -20879, 0, 65536, 0, 0, 0, 0xff}, + { -81271, 0, -29053, 0, 65536, 0, 65536, 65536, 0xff}, + { -71762, 0, -25340, 0, 65536, 0, 65536, 65536, 0xff}, + { 13597, 0, -11012, 0, 65536, 0, 0, 0, 0xff}, + { 3470, 0, -27505, 0, 65536, 0, 0, 0, 0xff}, + { 21951, 0, -43725, 0, 65536, 0, 65536, 65536, 0xff}, + { 130483, 0, -24934, 0, 65536, 0, 0, 0, 0xff}, + { 93529, 0, -3771, 0, 65536, 0, 0, 0, 0xff}, + { 90570, 0, -6556, 0, 65536, 0, 0, 0, 0xff}, + { 90570, 0, -6556, 0, 65536, 0, 0, 0, 0xff}, + { 93529, 0, -3771, 0, 65536, 0, 0, 0, 0xff}, + { 84756, 0, 8081, 0, 65536, 0, 0, 0, 0xff}, + { 7840, 0, -6237, 0, 65536, 0, 0, 0, 0xff}, + { -9299, 0, 2876, 0, 65536, 0, 65536, 65536, 0xff}, + { -5203, 0, -13590, 0, 65536, 0, 65536, 65536, 0xff}, + { -62009, 0, -27601, 0, 65536, 0, 65536, 65536, 0xff}, + { -62266, 0, -16307, 0, 65536, 0, 0, 0, 0xff}, + { -71813, 0, -20879, 0, 65536, 0, 0, 0, 0xff}, + { 38906, 0, -5057, 0, 65536, 0, 0, 0, 0xff}, + { 38473, 0, -2851, 0, 65536, 0, 0, 0, 0xff}, + { 17044, 0, -3185, 0, 65536, 0, 0, 0, 0xff}, + { 17044, 0, -3185, 0, 65536, 0, 0, 0, 0xff}, + { 19734, 0, 1117, 0, 65536, 0, 0, 0, 0xff}, + { 8709, 0, -1626, 0, 65536, 0, 0, 0, 0xff}, + { 19734, 0, 1117, 0, 65536, 0, 0, 0, 0xff}, + { 17044, 0, -3185, 0, 65536, 0, 0, 0, 0xff}, + { 37056, 0, -388, 0, 65536, 0, 0, 0, 0xff}, + { 35765, 0, 6712, 0, 65536, 0, 0, 0, 0xff}, + { 37056, 0, -388, 0, 65536, 0, 0, 0, 0xff}, + { 59166, 0, 12091, 0, 65536, 0, 0, 0, 0xff}, + { -71813, 0, -20879, 0, 65536, 0, 0, 0, 0xff}, + { -84497, 0, -27338, 0, 65536, 0, 0, 0, 0xff}, + { -81271, 0, -29053, 0, 65536, 0, 65536, 65536, 0xff}, + { -92000, 0, -8972, 0, 65536, 0, 0, 0, 0xff}, + { -78350, 0, -4012, 0, 65536, 0, 65536, 65536, 0xff}, + { -86714, 0, -1478, 0, 65536, 0, 0, 0, 0xff}, + { -86714, 0, -1478, 0, 65536, 0, 0, 0, 0xff}, + { -78350, 0, -4012, 0, 65536, 0, 65536, 65536, 0xff}, + { -79726, 0, 5364, 0, 65536, 0, 65536, 65536, 0xff}, + { -82948, 0, 6812, 0, 65536, 0, 0, 0, 0xff}, + { -79726, 0, 5364, 0, 65536, 0, 65536, 65536, 0xff}, + { -68746, 0, 25425, 0, 65536, 0, 65536, 65536, 0xff}, + {-100091, 0, -36876, 0, 65536, 0, 65536, 65536, 0xff}, + {-100351, 0, -29531, 0, 65536, 0, 65536, 65536, 0xff}, + {-104576, 0, -26632, 0, 65536, 0, 0, 0, 0xff}, + {-100124, 0, -23738, 0, 65536, 0, 0, 0, 0xff}, + { -99642, 0, -16874, 0, 65536, 0, 65536, 65536, 0xff}, + {-104576, 0, -17394, 0, 65536, 0, 0, 0, 0xff}, + { -97082, 0, -12423, 0, 65536, 0, 0, 0, 0xff}, + { -99642, 0, -16874, 0, 65536, 0, 65536, 65536, 0xff}, + { -86732, 0, -15020, 0, 65536, 0, 65536, 65536, 0xff}, + { 69290, 0, -27593, 0, 65536, 0, 32768, 32768, 0xff}, + { 92976, 0, -73102, 0, 65536, 0, 0, 0, 0xff}, + { 144399, 0, -60883, 0, 65536, 0, 0, 0, 0xff}, + { 13597, 0, -11012, 0, 65536, 0, 0, 0, 0xff}, + { 21951, 0, -43725, 0, 65536, 0, 65536, 65536, 0xff}, + { 40195, 0, -46919, 0, 65536, 0, 0, 0, 0xff}, + { -81271, 0, -29053, 0, 65536, 0, 65536, 65536, 0xff}, + { -92820, 0, -38435, 0, 65536, 0, 0, 0, 0xff}, + { -91443, 0, -44105, 0, 65536, 0, 65536, 65536, 0xff}, + { -92820, 0, -38435, 0, 65536, 0, 0, 0, 0xff}, + {-101423, 0, -41211, 0, 65536, 0, 0, 0, 0xff}, + { -91443, 0, -44105, 0, 65536, 0, 65536, 65536, 0xff}, + {-100091, 0, -36876, 0, 65536, 0, 65536, 65536, 0xff}, + {-104576, 0, -26632, 0, 65536, 0, 0, 0, 0xff}, + {-101423, 0, -41211, 0, 65536, 0, 0, 0, 0xff}, + {-104576, 0, -26632, 0, 65536, 0, 0, 0, 0xff}, + {-100351, 0, -29531, 0, 65536, 0, 65536, 65536, 0xff}, + {-100124, 0, -23738, 0, 65536, 0, 0, 0, 0xff}, + {-100351, 0, -29531, 0, 65536, 0, 65536, 65536, 0xff}, + { -95116, 0, -23478, 0, 65536, 0, 65536, 65536, 0xff}, + {-100124, 0, -23738, 0, 65536, 0, 0, 0, 0xff}, + { -95116, 0, -23478, 0, 65536, 0, 65536, 65536, 0xff}, + { -87033, 0, -22111, 0, 65536, 0, 0, 0, 0xff}, + { -95825, 0, -18364, 0, 65536, 0, 65536, 65536, 0xff}, + {-100351, 0, -29531, 0, 65536, 0, 65536, 65536, 0xff}, + { -87033, 0, -22111, 0, 65536, 0, 0, 0, 0xff}, + { -95116, 0, -23478, 0, 65536, 0, 65536, 65536, 0xff}, + {-100124, 0, -23738, 0, 65536, 0, 0, 0, 0xff}, + {-104576, 0, -17394, 0, 65536, 0, 0, 0, 0xff}, + {-104576, 0, -26632, 0, 65536, 0, 0, 0, 0xff}, + { -99642, 0, -16874, 0, 65536, 0, 65536, 65536, 0xff}, + { -97082, 0, -12423, 0, 65536, 0, 0, 0, 0xff}, + {-104576, 0, -17394, 0, 65536, 0, 0, 0, 0xff}, + { -97082, 0, -12423, 0, 65536, 0, 0, 0, 0xff}, + { -86732, 0, -15020, 0, 65536, 0, 65536, 65536, 0xff}, + { -92000, 0, -8972, 0, 65536, 0, 0, 0, 0xff}, + { -97082, 0, -12423, 0, 65536, 0, 0, 0, 0xff}, + { -92000, 0, -8972, 0, 65536, 0, 0, 0, 0xff}, + { -94969, 0, -6510, 0, 65536, 0, 65536, 65536, 0xff}, + { -92000, 0, -8972, 0, 65536, 0, 0, 0, 0xff}, + { -86714, 0, -1478, 0, 65536, 0, 0, 0, 0xff}, + { -94969, 0, -6510, 0, 65536, 0, 65536, 65536, 0xff}, + { -86714, 0, -1478, 0, 65536, 0, 0, 0, 0xff}, + { -79726, 0, 5364, 0, 65536, 0, 65536, 65536, 0xff}, + { -82948, 0, 6812, 0, 65536, 0, 0, 0, 0xff}, + { -79726, 0, 5364, 0, 65536, 0, 65536, 65536, 0xff}, + { -78350, 0, -4012, 0, 65536, 0, 65536, 65536, 0xff}, + { -68720, 0, -5352, 0, 65536, 0, 0, 0, 0xff}, + { 55268, 0, -61576, 0, 65536, 0, 65536, 65536, 0xff}, + { 82657, 0, -88557, 0, 65536, 0, 0, 0, 0xff}, + { 92976, 0, -73102, 0, 65536, 0, 0, 0, 0xff}, + { 161344, 0, -65769, 0, 65536, 0, 65536, 65536, 0xff}, + { 164192, 0, -46175, 0, 65536, 0, 65536, 65536, 0xff}, + { 155823, 0, -49580, 0, 65536, 0, 65536, 65536, 0xff}, + { 164192, 0, -46175, 0, 65536, 0, 65536, 65536, 0xff}, + { 134427, 0, -30955, 0, 65536, 0, 0, 0, 0xff}, + { 155823, 0, -49580, 0, 65536, 0, 65536, 65536, 0xff}, + { -33417, 0, -31096, 0, 65536, 0, 0, 0, 0xff}, + { -53175, 0, -36847, 0, 65536, 0, 0, 0, 0xff}, + { -49141, 0, -39471, 0, 65536, 0, 0, 0, 0xff}, + { -49141, 0, -39471, 0, 65536, 0, 0, 0, 0xff}, + { -53175, 0, -36847, 0, 65536, 0, 0, 0, 0xff}, + { -55504, 0, -43835, 0, 65536, 0, 0, 0, 0xff}, + { -55504, 0, -43835, 0, 65536, 0, 0, 0, 0xff}, + { -47708, 0, -48520, 0, 65536, 0, 0, 0, 0xff}, + { -49141, 0, -39471, 0, 65536, 0, 0, 0, 0xff}, + { -55504, 0, -43835, 0, 65536, 0, 0, 0, 0xff}, + { -61681, 0, -40847, 0, 65536, 0, 65536, 65536, 0xff}, + { -66087, 0, -44443, 0, 65536, 0, 0, 0, 0xff}, + { -66087, 0, -44443, 0, 65536, 0, 0, 0, 0xff}, + { -61681, 0, -40847, 0, 65536, 0, 65536, 65536, 0xff}, + { -61226, 0, -32443, 0, 65536, 0, 65536, 65536, 0xff}, + { -47708, 0, -48520, 0, 65536, 0, 0, 0, 0xff}, + { -41265, 0, -47607, 0, 65536, 0, 0, 0, 0xff}, + { -35470, 0, -35271, 0, 65536, 0, 65536, 65536, 0xff}, + { -41265, 0, -47607, 0, 65536, 0, 0, 0, 0xff}, + { -29829, 0, -55969, 0, 65536, 0, 0, 0, 0xff}, + { -35470, 0, -35271, 0, 65536, 0, 65536, 65536, 0xff}, + { -33217, 0, -74117, 0, 65536, 0, 65536, 65536, 0xff}, + { -52454, 0, -65041, 0, 65536, 0, 0, 0, 0xff}, + { -56312, 0, -67428, 0, 65536, 0, 65536, 65536, 0xff}, + { -56312, 0, -67428, 0, 65536, 0, 65536, 65536, 0xff}, + { -69535, 0, -50302, 0, 65536, 0, 0, 0, 0xff}, + { -73073, 0, -56733, 0, 65536, 0, 65536, 65536, 0xff}, + { -73073, 0, -56733, 0, 65536, 0, 65536, 65536, 0xff}, + { -77516, 0, -48653, 0, 65536, 0, 0, 0, 0xff}, + { -83130, 0, -53966, 0, 65536, 0, 65536, 65536, 0xff}, + { -77516, 0, -48653, 0, 65536, 0, 0, 0, 0xff}, + { -90526, 0, -47208, 0, 65536, 0, 0, 0, 0xff}, + { -83130, 0, -53966, 0, 65536, 0, 65536, 65536, 0xff}, + { -62009, 0, -27601, 0, 65536, 0, 65536, 65536, 0xff}, + { -71762, 0, -25340, 0, 65536, 0, 65536, 65536, 0xff}, + { -69869, 0, -33560, 0, 65536, 0, 0, 0, 0xff}, + { 55268, 0, -61576, 0, 65536, 0, 65536, 65536, 0xff}, + { 92976, 0, -73102, 0, 65536, 0, 0, 0, 0xff}, + { 69290, 0, -27593, 0, 65536, 0, 32768, 32768, 0xff}, + { 164192, 0, -46175, 0, 65536, 0, 65536, 65536, 0xff}, + { 130483, 0, -24934, 0, 65536, 0, 0, 0, 0xff}, + { 134427, 0, -30955, 0, 65536, 0, 0, 0, 0xff}, + { 1377, 0, -19416, 0, 65536, 0, 0, 0, 0xff}, + { -5203, 0, -13590, 0, 65536, 0, 65536, 65536, 0xff}, + { -32343, 0, -26406, 0, 65536, 0, 65536, 65536, 0xff}, + { -33417, 0, -31096, 0, 65536, 0, 0, 0, 0xff}, + { -32343, 0, -26406, 0, 65536, 0, 65536, 65536, 0xff}, + { -53175, 0, -36847, 0, 65536, 0, 0, 0, 0xff}, + { -55504, 0, -43835, 0, 65536, 0, 0, 0, 0xff}, + { -50576, 0, -58888, 0, 65536, 0, 0, 0, 0xff}, + { -47708, 0, -48520, 0, 65536, 0, 0, 0, 0xff}, + { -55504, 0, -43835, 0, 65536, 0, 0, 0, 0xff}, + { -53175, 0, -36847, 0, 65536, 0, 0, 0, 0xff}, + { -61681, 0, -40847, 0, 65536, 0, 65536, 65536, 0xff}, + { -47708, 0, -48520, 0, 65536, 0, 0, 0, 0xff}, + { -50576, 0, -58888, 0, 65536, 0, 0, 0, 0xff}, + { -41265, 0, -47607, 0, 65536, 0, 0, 0, 0xff}, + { -41265, 0, -47607, 0, 65536, 0, 0, 0, 0xff}, + { -33177, 0, -62453, 0, 65536, 0, 0, 0, 0xff}, + { -29829, 0, -55969, 0, 65536, 0, 0, 0, 0xff}, + { 53617, 0, -85352, 0, 65536, 0, 65536, 65536, 0xff}, + { 80862, 0, -109789, 0, 65536, 0, 65536, 65536, 0xff}, + { 82657, 0, -88557, 0, 65536, 0, 0, 0, 0xff}, + { 82657, 0, -88557, 0, 65536, 0, 0, 0, 0xff}, + { 80862, 0, -109789, 0, 65536, 0, 65536, 65536, 0xff}, + { 103492, 0, -97423, 0, 65536, 0, 65536, 65536, 0xff}, + { 154024, 0, -91896, 0, 65536, 0, 65536, 65536, 0xff}, + { 161344, 0, -65769, 0, 65536, 0, 65536, 65536, 0xff}, + { 147828, 0, -88518, 0, 65536, 0, 0, 0, 0xff}, + { -29829, 0, -55969, 0, 65536, 0, 0, 0, 0xff}, + { -18172, 0, -66284, 0, 65536, 0, 65536, 65536, 0xff}, + { -17059, 0, -61556, 0, 65536, 0, 0, 0, 0xff}, + { -17059, 0, -61556, 0, 65536, 0, 0, 0, 0xff}, + { -4178, 0, -65592, 0, 65536, 0, 65536, 65536, 0xff}, + { 15557, 0, -61822, 0, 65536, 0, 0, 0, 0xff}, + { -4178, 0, -65592, 0, 65536, 0, 65536, 65536, 0xff}, + { -19755, 0, -74383, 0, 65536, 0, 65536, 65536, 0xff}, + { 15557, 0, -61822, 0, 65536, 0, 0, 0, 0xff}, + { -24309, 0, -71282, 0, 65536, 0, 0, 0, 0xff}, + { -33217, 0, -74117, 0, 65536, 0, 65536, 65536, 0xff}, + { -19755, 0, -74383, 0, 65536, 0, 65536, 65536, 0xff}, + { 55268, 0, -61576, 0, 65536, 0, 65536, 65536, 0xff}, + { 53617, 0, -85352, 0, 65536, 0, 65536, 65536, 0xff}, + { 82657, 0, -88557, 0, 65536, 0, 0, 0, 0xff}, + { 154024, 0, -91896, 0, 65536, 0, 65536, 65536, 0xff}, + { 169292, 0, -66929, 0, 65536, 0, 0, 0, 0xff}, + { 161344, 0, -65769, 0, 65536, 0, 65536, 65536, 0xff}, + { 161344, 0, -65769, 0, 65536, 0, 65536, 65536, 0xff}, + { 169292, 0, -66929, 0, 65536, 0, 0, 0, 0xff}, + { 164192, 0, -46175, 0, 65536, 0, 65536, 65536, 0xff}, + { -29829, 0, -55969, 0, 65536, 0, 0, 0, 0xff}, + { -33177, 0, -62453, 0, 65536, 0, 0, 0, 0xff}, + { -18172, 0, -66284, 0, 65536, 0, 65536, 65536, 0xff}, + { -17059, 0, -61556, 0, 65536, 0, 0, 0, 0xff}, + { -18172, 0, -66284, 0, 65536, 0, 65536, 65536, 0xff}, + { -4178, 0, -65592, 0, 65536, 0, 65536, 65536, 0xff}, + { -4178, 0, -65592, 0, 65536, 0, 65536, 65536, 0xff}, + { -24309, 0, -71282, 0, 65536, 0, 0, 0, 0xff}, + { -19755, 0, -74383, 0, 65536, 0, 65536, 65536, 0xff}, + { -33217, 0, -74117, 0, 65536, 0, 65536, 65536, 0xff}, + { -24309, 0, -71282, 0, 65536, 0, 0, 0, 0xff}, + { -52454, 0, -65041, 0, 65536, 0, 0, 0, 0xff}, + { -56312, 0, -67428, 0, 65536, 0, 65536, 65536, 0xff}, + { -52454, 0, -65041, 0, 65536, 0, 0, 0, 0xff}, + { -69535, 0, -50302, 0, 65536, 0, 0, 0, 0xff}, + { -73073, 0, -56733, 0, 65536, 0, 65536, 65536, 0xff}, + { -69535, 0, -50302, 0, 65536, 0, 0, 0, 0xff}, + { -77516, 0, -48653, 0, 65536, 0, 0, 0, 0xff}, + { -77516, 0, -48653, 0, 65536, 0, 0, 0, 0xff}, + { -74749, 0, -41310, 0, 65536, 0, 0, 0, 0xff}, + { -90526, 0, -47208, 0, 65536, 0, 0, 0, 0xff}, + { -81271, 0, -29053, 0, 65536, 0, 65536, 65536, 0xff}, + { -84497, 0, -27338, 0, 65536, 0, 0, 0, 0xff}, + { -92820, 0, -38435, 0, 65536, 0, 0, 0, 0xff}, + { -92820, 0, -38435, 0, 65536, 0, 0, 0, 0xff}, + {-100091, 0, -36876, 0, 65536, 0, 65536, 65536, 0xff}, + {-101423, 0, -41211, 0, 65536, 0, 0, 0, 0xff}, + { -7383, 0, -132173, 0, 65536, 0, 0, 0, 0xff}, + { 10265, 0, -96792, 0, 65536, 0, 65536, 65536, 0xff}, + { -31322, 0, -116741, 0, 65536, 0, 65536, 65536, 0xff}, + { 53617, 0, -85352, 0, 65536, 0, 65536, 65536, 0xff}, + { 35685, 0, -110002, 0, 65536, 0, 0, 0, 0xff}, + { 80862, 0, -109789, 0, 65536, 0, 65536, 65536, 0xff}, + { -31322, 0, -116741, 0, 65536, 0, 65536, 65536, 0xff}, + { -74166, 0, -122573, 0, 65536, 0, 65536, 65536, 0xff}, + { -7383, 0, -132173, 0, 65536, 0, 0, 0, 0xff}, + { 16471, 0, -118431, 0, 65536, 0, 65536, 65536, 0xff}, + { 42456, 0, -130789, 0, 65536, 0, 0, 0, 0xff}, + { 42362, 0, -126587, 0, 65536, 0, 65536, 65536, 0xff}, + { 42456, 0, -130789, 0, 65536, 0, 0, 0, 0xff}, + { 94869, 0, -118540, 0, 65536, 0, 65536, 65536, 0xff}, + { 42362, 0, -126587, 0, 65536, 0, 65536, 65536, 0xff}, + { 97388, 0, -121904, 0, 65536, 0, 65536, 65536, 0xff}, + { 147828, 0, -88518, 0, 65536, 0, 0, 0, 0xff}, + { 94869, 0, -118540, 0, 65536, 0, 65536, 65536, 0xff}, + { -7383, 0, -132173, 0, 65536, 0, 0, 0, 0xff}, + { 16471, 0, -118431, 0, 65536, 0, 65536, 65536, 0xff}, + { 10265, 0, -96792, 0, 65536, 0, 65536, 65536, 0xff}, + { -31322, 0, -116741, 0, 65536, 0, 65536, 65536, 0xff}, + {-146514, 0, -100851, 0, 65536, 0, 0, 0, 0xff}, + { -74166, 0, -122573, 0, 65536, 0, 65536, 65536, 0xff}, + { 97388, 0, -121904, 0, 65536, 0, 65536, 65536, 0xff}, + { 154024, 0, -91896, 0, 65536, 0, 65536, 65536, 0xff}, + { 147828, 0, -88518, 0, 65536, 0, 0, 0, 0xff}, + { 16471, 0, -118431, 0, 65536, 0, 65536, 65536, 0xff}, + { -7383, 0, -132173, 0, 65536, 0, 0, 0, 0xff}, + { 42456, 0, -130789, 0, 65536, 0, 0, 0, 0xff}, + { 42456, 0, -130789, 0, 65536, 0, 0, 0, 0xff}, + { 97388, 0, -121904, 0, 65536, 0, 65536, 65536, 0xff}, + { 94869, 0, -118540, 0, 65536, 0, 65536, 65536, 0xff} + +}; diff --git a/src/polyfill.c b/src/polyfill.c index 8b01ea1..911b1d7 100644 --- a/src/polyfill.c +++ b/src/polyfill.c @@ -21,9 +21,9 @@ along with this program. If not, see . static unsigned char *fb; static int fbwidth, fbheight; -static short scantab[2][160] __attribute__((section(".iwram"))); +static short scantab[2][160]; -void polyfill_framebuffer(unsigned char *ptr, int w, int h) +void polyfill_framebuffer(void *ptr, int w, int h) { fb = ptr; fbwidth = w; @@ -34,6 +34,7 @@ void polyfill_framebuffer(unsigned char *ptr, int w, int h) #define VPREV(p) ((p) == varr ? vlast : (p) - 1) #define VSUCC(p, side) ((side) == 0 ? VNEXT(p) : VPREV(p)) +ARM_IWRAM void polyfill_flat(struct pvertex *varr, int vnum, unsigned char col) { int i, line, top, bot; diff --git a/src/polyfill.h b/src/polyfill.h index 1afce36..e60ff6b 100644 --- a/src/polyfill.h +++ b/src/polyfill.h @@ -24,7 +24,7 @@ struct pvertex { int32_t x, y; }; -void polyfill_framebuffer(unsigned char *fb, int width, int height); +void polyfill_framebuffer(void *fb, int width, int height); void polyfill_flat(struct pvertex *v, int vnum, unsigned char col); int clip_line(int *x0, int *y0, int *x1, int *y1, int xmin, int ymin, int xmax, int ymax); diff --git a/src/util.h b/src/util.h index 3e8ee67..6902d64 100644 --- a/src/util.h +++ b/src/util.h @@ -5,6 +5,9 @@ #include #include "gba.h" +#define RGB555(r, g, b) \ + (((r) >> 3) | (((g) << 2) & 0x3e0) | (((b) << 7) & 0x7c00)) + #ifdef BUILD_GBA #define wait_vblank() \ diff --git a/src/xgl.c b/src/xgl.c index 368c498..7d22b2b 100644 --- a/src/xgl.c +++ b/src/xgl.c @@ -20,6 +20,7 @@ along with this program. If not, see . #include "xgl.h" #include "polyfill.h" #include "debug.h" +#include "util.h" #define MAT_STACK_SIZE 4 @@ -118,9 +119,13 @@ void xgl_mult_matrix(const int32_t *m2) } } -/* XXX TODO XXX */ +#if 0 #define XSIN(x) (int32_t)(sin(x / 65536.0f) * 65536.0f) #define XCOS(x) (int32_t)(cos(x / 65536.0f) * 65536.0f) +#else +#define XSIN(x) SIN(((x) << 8) / (X_2PI >> 8)) +#define XCOS(x) COS(((x) << 8) / (X_2PI >> 8)) +#endif void xgl_translate(int32_t x, int32_t y, int32_t z) { @@ -182,14 +187,14 @@ void xgl_index(int cidx) cur_cidx = cidx; } -static void xform(struct xvertex *out, const struct xvertex *in, const int32_t *m) +static inline void xform(struct xvertex *out, const struct xvertex *in, const int32_t *m) { out->x = XMUL(m[0], in->x) + XMUL(m[4], in->y) + XMUL(m[8], in->z) + m[12]; out->y = XMUL(m[1], in->x) + XMUL(m[5], in->y) + XMUL(m[9], in->z) + m[13]; out->z = XMUL(m[2], in->x) + XMUL(m[6], in->y) + XMUL(m[10], in->z) + m[14]; } -static void xform_norm(struct xvertex *out, const struct xvertex *in, const int32_t *m) +static inline void xform_norm(struct xvertex *out, const struct xvertex *in, const int32_t *m) { out->nx = XMUL(m[0], in->nx) + XMUL(m[4], in->ny) + XMUL(m[8], in->nz); out->ny = XMUL(m[1], in->nx) + XMUL(m[5], in->ny) + XMUL(m[9], in->nz); @@ -201,6 +206,7 @@ static void xform_norm(struct xvertex *out, const struct xvertex *in, const int3 /* near Z = 0.5 */ #define NEAR_Z 0x18000 +ARM_IWRAM void xgl_draw(int prim, const struct xvertex *varr, int vcount) { int i, cidx, clipnum; @@ -312,6 +318,7 @@ void xgl_xyzzy(void) (res)->lit = (v0)->lit + (((v1)->lit - (v0)->lit) >> 8) * (t); \ } while(0) +ARM_IWRAM static int clip_edge_near(struct xvertex *poly, int *vnumptr, struct xvertex *v0, struct xvertex *v1) { int vnum = *vnumptr; @@ -357,6 +364,7 @@ static int clip_edge_near(struct xvertex *poly, int *vnumptr, struct xvertex *v0 } /* special case near-plane clipper */ +ARM_IWRAM int xgl_clip_near(struct xvertex *vout, int *voutnum, struct xvertex *vin, int vnum) { int i, nextidx, res; diff --git a/tools/meshdump/Makefile b/tools/meshdump/Makefile new file mode 100644 index 0000000..880ae96 --- /dev/null +++ b/tools/meshdump/Makefile @@ -0,0 +1,13 @@ +src = $(wildcard *.c) +obj = $(src:.c=.o) +bin = meshdump + +CFLAGS = -pedantic -Wall -g -DNO_OPENGL +LDFLAGS = -lm + +$(bin): $(obj) + $(CC) -o $@ $(obj) $(LDFLAGS) + +.PHONY: clean +clean: + rm -f $(obj) $(bin) diff --git a/tools/meshdump/cmesh.c b/tools/meshdump/cmesh.c new file mode 100644 index 0000000..483b1f9 --- /dev/null +++ b/tools/meshdump/cmesh.c @@ -0,0 +1,1638 @@ +#include +#include +#include +#include +#include +#include "cmesh.h" + +#ifndef NO_OPENGL +#include "opengl.h" +#endif + + +struct cmesh_vattrib { + int nelem; /* num elements per attribute [1, 4] */ + float *data; + unsigned int count; + unsigned int vbo; + int vbo_valid, data_valid; +}; + +/* istart,icount are valid only when the mesh is indexed, otherwise icount is 0. + * vstart,vcount are define the submesh for non-indexed meshes. + * For indexed meshes, vstart,vcount denote the range of vertices used by each + * submesh. + */ +struct submesh { + char *name; + int nfaces; /* derived from either icount or vcount */ + int istart, icount; + int vstart, vcount; + struct submesh *next; +}; + +struct cmesh { + char *name; + unsigned int nverts, nfaces; + + struct submesh *sublist; + int subcount; + + /* current value for each attribute for the immediate mode interface */ + cgm_vec4 cur_val[CMESH_NUM_ATTR]; + + unsigned int buffer_objects[CMESH_NUM_ATTR + 1]; + struct cmesh_vattrib vattr[CMESH_NUM_ATTR]; + + unsigned int *idata; + unsigned int icount; + unsigned int ibo; + int ibo_valid, idata_valid; + + /* index buffer for wireframe rendering (constructed on demand) */ + unsigned int wire_ibo; + int wire_ibo_valid; + + /* axis-aligned bounding box */ + cgm_vec3 aabb_min, aabb_max; + int aabb_valid; + /* bounding sphere */ + cgm_vec3 bsph_center; + float bsph_radius; + int bsph_valid; +}; + + +static int clone(struct cmesh *cmdest, struct cmesh *cmsrc, struct submesh *sub); +static int pre_draw(struct cmesh *cm); +static void post_draw(struct cmesh *cm, int cur_sdr); +static void update_buffers(struct cmesh *cm); +static void update_wire_ibo(struct cmesh *cm); +static void calc_aabb(struct cmesh *cm); +static void calc_bsph(struct cmesh *cm); + +static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2}; + +static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7}; +static int use_custom_sdr_attr; + + +/* global state */ +void cmesh_set_attrib_sdrloc(int attr, int loc) +{ + sdr_loc[attr] = loc; +} + +int cmesh_get_attrib_sdrloc(int attr) +{ + return sdr_loc[attr]; +} + +void cmesh_clear_attrib_sdrloc(void) +{ + int i; + for(i=0; icur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1); + +#ifndef NO_OPENGL + glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects); + + for(i=0; ivattr[i].vbo = cm->buffer_objects[i]; + } + + cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR]; +#endif + return 0; +} + +void cmesh_destroy(struct cmesh *cm) +{ + int i; + + free(cm->name); + + for(i=0; ivattr[i].data); + } + free(cm->idata); + + cmesh_clear_submeshes(cm); + +#ifndef NO_OPENGL + glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects); + if(cm->wire_ibo) { + glDeleteBuffers(1, &cm->wire_ibo); + } +#endif +} + +void cmesh_clear(struct cmesh *cm) +{ + int i; + + for(i=0; ivattr[i].nelem = 0; + cm->vattr[i].vbo_valid = 0; + cm->vattr[i].data_valid = 0; + free(cm->vattr[i].data); + cm->vattr[i].data = 0; + cm->vattr[i].count = 0; + } + cm->ibo_valid = cm->idata_valid = 0; + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + + cm->wire_ibo_valid = 0; + cm->nverts = cm->nfaces = 0; + + cm->bsph_valid = cm->aabb_valid = 0; + + cmesh_clear_submeshes(cm); +} + +int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc) +{ + return clone(cmdest, cmsrc, 0); +} + +static int clone(struct cmesh *cmdest, struct cmesh *cmsrc, struct submesh *sub) +{ + int i, nelem, vstart, vcount, istart, icount; + char *srcname, *name = 0; + float *varr[CMESH_NUM_ATTR] = {0}; + float *vptr; + unsigned int *iptr, *iarr = 0; + + /* try do anything that can fail first, before making any changes to cmdest + * so we have the option of recovering gracefuly + */ + + srcname = sub ? sub->name : cmsrc->name; + if(srcname) { + if(!(name = malloc(strlen(srcname) + 1))) { + return -1; + } + strcpy(name, srcname); + } + + if(sub) { + vstart = sub->vstart; + vcount = sub->vcount; + istart = sub->istart; + icount = sub->icount; + } else { + vstart = istart = 0; + vcount = cmsrc->nverts; + icount = cmsrc->icount; + } + + if(cmesh_indexed(cmsrc)) { + if(!(iarr = malloc(icount * sizeof *iarr))) { + free(name); + return -1; + } + } + + for(i=0; ivattr[i].nelem; + if(!(varr[i] = malloc(vcount * nelem * sizeof(float)))) { + while(--i >= 0) { + free(varr[i]); + } + free(iarr); + free(name); + return -1; + } + } + } + + /* from this point forward nothing can fail */ + cmesh_clear(cmdest); + + for(i=0; ivattr[i].data); + + if(cmesh_has_attrib(cmsrc, i)) { + cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */ + + nelem = cmsrc->vattr[i].nelem; + cmdest->vattr[i].nelem = nelem; + cmdest->vattr[i].data = varr[i]; + cmdest->vattr[i].count = vcount; + vptr = cmsrc->vattr[i].data + vstart * nelem; + memcpy(cmdest->vattr[i].data, vptr, vcount * nelem * sizeof(float)); + cmdest->vattr[i].data_valid = 1; + cmdest->vattr[i].vbo_valid = 0; + } else { + memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]); + } + } + + if(cmesh_indexed(cmsrc)) { + cmesh_index(cmsrc); /* force validation .... */ + + cmdest->idata = iarr; + cmdest->icount = icount; + if(sub) { + /* need to offset all vertex indices by -vstart */ + iptr = cmsrc->idata + istart; + for(i=0; iidata[i] = *iptr++ - vstart; + } + } else { + memcpy(cmdest->idata, cmsrc->idata + istart, icount * sizeof *cmdest->idata); + } + cmdest->idata_valid = 1; + } else { + cmdest->idata = 0; + cmdest->idata_valid = cmdest->ibo_valid = 0; + } + + free(cmdest->name); + cmdest->name = name; + + cmdest->nverts = cmsrc->nverts; + cmdest->nfaces = sub ? sub->nfaces : cmsrc->nfaces; + + memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val); + + cmdest->aabb_min = cmsrc->aabb_min; + cmdest->aabb_max = cmsrc->aabb_max; + cmdest->aabb_valid = cmsrc->aabb_valid; + cmdest->bsph_center = cmsrc->bsph_center; + cmdest->bsph_radius = cmsrc->bsph_radius; + cmdest->bsph_valid = cmsrc->bsph_valid; + + /* copy sublist only if we're not cloning a submesh */ + if(!sub) { + struct submesh *sm, *n, *head = 0, *tail = 0; + + sm = cmsrc->sublist; + while(sm) { + if(!(n = malloc(sizeof *n)) || !(name = malloc(strlen(sm->name) + 1))) { + free(n); + sm = sm->next; + continue; + } + strcpy(name, sm->name); + *n = *sm; + n->name = name; + n->next = 0; + + if(head) { + tail->next = n; + tail = n; + } else { + head = tail = n; + } + + sm = sm->next; + } + + cmdest->sublist = head; + cmdest->subcount = cmsrc->subcount; + } + + return 0; +} + +int cmesh_set_name(struct cmesh *cm, const char *name) +{ + int len = strlen(name); + char *tmp = malloc(len + 1); + if(!tmp) return -1; + free(cm->name); + cm->name = tmp; + memcpy(cm->name, name, len + 1); + return 0; +} + +const char *cmesh_name(struct cmesh *cm) +{ + return cm->name; +} + +int cmesh_has_attrib(struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid; +} + +int cmesh_indexed(struct cmesh *cm) +{ + return cm->ibo_valid | cm->idata_valid; +} + +/* vdata can be 0, in which case only memory is allocated + * returns pointer to the attribute array + */ +float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num, + const float *vdata) +{ + float *newarr; + + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + if(cm->nverts && num != cm->nverts) { + return 0; + } + + if(!(newarr = malloc(num * nelem * sizeof *newarr))) { + return 0; + } + if(vdata) { + memcpy(newarr, vdata, num * nelem * sizeof *newarr); + } + + cm->nverts = num; + + free(cm->vattr[attr].data); + cm->vattr[attr].data = newarr; + cm->vattr[attr].count = num * nelem; + cm->vattr[attr].nelem = nelem; + cm->vattr[attr].data_valid = 1; + cm->vattr[attr].vbo_valid = 0; + return newarr; +} + +float *cmesh_attrib(struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + cm->vattr[attr].vbo_valid = 0; + return (float*)cmesh_attrib_ro(cm, attr); +} + +const float *cmesh_attrib_ro(struct cmesh *cm, int attr) +{ + void *tmp; + int nelem; + + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + + if(!cm->vattr[attr].data_valid) { +#if defined(GL_ES_VERSION_2_0) || defined(NO_OPENGL) + return 0; +#else + if(!cm->vattr[attr].vbo_valid) { + return 0; + } + + /* local data copy unavailable, grab the data from the vbo */ + nelem = cm->vattr[attr].nelem; + if(!(cm->vattr[attr].data = malloc(cm->nverts * nelem * sizeof(float)))) { + return 0; + } + cm->vattr[attr].count = cm->nverts * nelem; + + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo); + tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); + memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float)); + glUnmapBuffer(GL_ARRAY_BUFFER); + + cm->vattr[attr].data_valid = 1; +#endif + } + return cm->vattr[attr].data; +} + +float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx) +{ + float *vptr = cmesh_attrib(cm, attr); + return vptr ? vptr + idx * cm->vattr[attr].nelem : 0; +} + +const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx) +{ + const float *vptr = cmesh_attrib_ro(cm, attr); + return vptr ? vptr + idx * cm->vattr[attr].nelem : 0; +} + +int cmesh_attrib_count(struct cmesh *cm, int attr) +{ + return cmesh_has_attrib(cm, attr) ? cm->nverts : 0; +} + +int cmesh_push_attrib(struct cmesh *cm, int attr, float *v) +{ + float *vptr; + int i, cursz, newsz; + + if(!cm->vattr[attr].nelem) { + cm->vattr[attr].nelem = def_nelem[attr]; + } + + cursz = cm->vattr[attr].count; + newsz = cursz + cm->vattr[attr].nelem; + if(!(vptr = realloc(cm->vattr[attr].data, newsz * sizeof(float)))) { + return -1; + } + cm->vattr[attr].data = vptr; + cm->vattr[attr].count = newsz; + vptr += cursz; + + for(i=0; ivattr[attr].nelem; i++) { + *vptr++ = *v++; + } + cm->vattr[attr].data_valid = 1; + cm->vattr[attr].vbo_valid = 0; + + if(attr == CMESH_ATTR_VERTEX) { + cm->nverts = newsz / cm->vattr[attr].nelem; + } + return 0; +} + +int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x) +{ + float v[4]; + v[0] = x; + v[1] = v[2] = 0.0f; + v[3] = 1.0f; + return cmesh_push_attrib(cm, attr, v); +} + +int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y) +{ + float v[4]; + v[0] = x; + v[1] = y; + v[2] = 0.0f; + v[3] = 1.0f; + return cmesh_push_attrib(cm, attr, v); +} + +int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z) +{ + float v[4]; + v[0] = x; + v[1] = y; + v[2] = z; + v[3] = 1.0f; + return cmesh_push_attrib(cm, attr, v); +} + +int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w) +{ + float v[4]; + v[0] = x; + v[1] = y; + v[2] = z; + v[3] = w; + return cmesh_push_attrib(cm, attr, v); +} + +/* indices can be 0, in which case only memory is allocated + * returns pointer to the index array + */ +unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices) +{ + unsigned int *tmp; + int nidx = cm->nfaces * 3; + + if(nidx && num != nidx) { + return 0; + } + + if(!(tmp = malloc(num * sizeof *tmp))) { + return 0; + } + if(indices) { + memcpy(tmp, indices, num * sizeof *tmp); + } + + free(cm->idata); + cm->idata = tmp; + cm->icount = num; + cm->idata_valid = 1; + cm->ibo_valid = 0; + return tmp; +} + +unsigned int *cmesh_index(struct cmesh *cm) +{ + cm->ibo_valid = 0; + return (unsigned int*)cmesh_index_ro(cm); +} + +const unsigned int *cmesh_index_ro(struct cmesh *cm) +{ + int nidx; + unsigned int *tmp; + + if(!cm->idata_valid) { +#if defined(GL_ES_VERSION_2_0) || defined(NO_OPENGL) + return 0; +#else + if(!cm->ibo_valid) { + return 0; + } + + /* local copy is unavailable, grab the data from the ibo */ + nidx = cm->nfaces * 3; + if(!(tmp = malloc(nidx * sizeof *cm->idata))) { + return 0; + } + free(cm->idata); + cm->idata = tmp; + cm->icount = nidx; + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo); + tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY); + memcpy(cm->idata, tmp, nidx * sizeof *cm->idata); + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + + cm->idata_valid = 1; +#endif + } + return cm->idata; +} + +int cmesh_index_count(struct cmesh *cm) +{ + return cm->nfaces * 3; +} + +int cmesh_push_index(struct cmesh *cm, unsigned int idx) +{ + unsigned int *iptr; + unsigned int cur_sz = cm->icount; + if(!(iptr = realloc(cm->idata, (cur_sz + 1) * sizeof *iptr))) { + return -1; + } + iptr[cur_sz] = idx; + cm->idata = iptr; + cm->icount = cur_sz + 1; + cm->idata_valid = 1; + cm->ibo_valid = 0; + + cm->nfaces = cm->icount / 3; + return 0; +} + +int cmesh_poly_count(struct cmesh *cm) +{ + if(cm->nfaces) { + return cm->nfaces; + } + if(cm->nverts) { + return cm->nverts / 3; + } + return 0; +} + +/* attr can be -1 to invalidate all attributes */ +void cmesh_invalidate_vbo(struct cmesh *cm, int attr) +{ + int i; + + if(attr >= CMESH_NUM_ATTR) { + return; + } + + if(attr < 0) { + for(i=0; ivattr[i].vbo_valid = 0; + } + } else { + cm->vattr[attr].vbo_valid = 0; + } +} + +void cmesh_invalidate_index(struct cmesh *cm) +{ + cm->ibo_valid = 0; +} + +int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc) +{ + int i, nelem, newsz, origsz, srcsz; + float *vptr; + unsigned int *iptr; + unsigned int idxoffs; + + if(!cmdest->nverts) { + return cmesh_clone(cmdest, cmsrc); + } + + for(i=0; ivattr[i].nelem == cmsrc->vattr[i].nelem); + nelem = cmdest->vattr[i].nelem; + origsz = cmdest->nverts * nelem; + newsz = cmdest->nverts + cmsrc->nverts * nelem; + + if(!(vptr = realloc(cmdest->vattr[i].data, newsz * sizeof *vptr))) { + return -1; + } + memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float)); + cmdest->vattr[i].data = vptr; + cmdest->vattr[i].count = newsz; + } + } + + if(cmesh_indexed(cmdest)) { + assert(cmesh_indexed(cmsrc)); + /* force validation ... */ + cmesh_index(cmdest); + cmesh_index_ro(cmsrc); + + idxoffs = cmdest->nverts; + origsz = cmdest->icount; + srcsz = cmsrc->icount; + newsz = origsz + srcsz; + + if(!(iptr = realloc(cmdest->idata, newsz * sizeof *iptr))) { + return -1; + } + cmdest->idata = iptr; + cmdest->icount = newsz; + + /* copy and fixup all the new indices */ + iptr += origsz; + for(i=0; iidata[i] + idxoffs; + } + } + + cmdest->wire_ibo_valid = 0; + cmdest->aabb_valid = 0; + cmdest->bsph_valid = 0; + return 0; +} + +void cmesh_clear_submeshes(struct cmesh *cm) +{ + struct submesh *sm; + + while(cm->sublist) { + sm = cm->sublist; + cm->sublist = cm->sublist->next; + free(sm->name); + free(sm); + } + cm->subcount = 0; +} + +int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount) +{ + int i; + unsigned int minv = UINT_MAX, maxv = 0; + unsigned int *iptr; + struct submesh *sm; + + if(fstart < 0 || fcount < 1 || fstart + fcount > cm->nfaces) { + return -1; + } + + if(!(sm = malloc(sizeof *sm)) || !(sm->name = malloc(strlen(name) + 1))) { + free(sm); + return -1; + } + strcpy(sm->name, name); + sm->nfaces = fcount; + + if(cmesh_indexed(cm)) { + sm->istart = fstart * 3; + sm->icount = fcount * 3; + + /* find out which vertices are used by this submesh */ + iptr = cm->idata + sm->istart; + for(i=0; iicount; i++) { + unsigned int vidx = *iptr++; + if(vidx < minv) minv = vidx; + if(vidx > maxv) maxv = vidx; + } + sm->vstart = minv; + sm->vcount = maxv - minv + 1; + } else { + sm->istart = sm->icount = 0; + sm->vstart = fstart * 3; + sm->vcount = fcount * 3; + } + + sm->next = cm->sublist; + cm->sublist = sm; + cm->subcount++; + return 0; +} + +int cmesh_remove_submesh(struct cmesh *cm, int idx) +{ + struct submesh dummy; + struct submesh *prev, *sm; + + if(idx >= cm->subcount) { + return -1; + } + + dummy.next = cm->sublist; + prev = &dummy; + + while(prev->next && idx-- > 0) { + prev = prev->next; + } + + if(!(sm = prev->next)) return -1; + + prev->next = sm->next; + free(sm->name); + free(sm); + + cm->subcount--; + assert(cm->subcount >= 0); + + cm->sublist = dummy.next; + return 0; +} + +int cmesh_find_submesh(struct cmesh *cm, const char *name) +{ + int idx = 0; + struct submesh *sm = cm->sublist; + while(sm) { + if(strcmp(sm->name, name) == 0) { + assert(idx <= cm->subcount); + return idx; + } + idx++; + sm = sm->next; + } + return -1; +} + +int cmesh_submesh_count(struct cmesh *cm) +{ + return cm->subcount; +} + +static struct submesh *get_submesh(struct cmesh *m, int idx) +{ + struct submesh *sm = m->sublist; + while(sm && --idx >= 0) { + sm = sm->next; + } + return sm; +} + +int cmesh_clone_submesh(struct cmesh *cmdest, struct cmesh *cm, int subidx) +{ + struct submesh *sub; + + if(!(sub = get_submesh(cm, subidx))) { + return -1; + } + return clone(cmdest, cm, sub); +} + + +/* assemble a complete vertex by adding all the useful attributes */ +int cmesh_vertex(struct cmesh *cm, float x, float y, float z) +{ + int i, j; + + cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f); + cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1; + cm->vattr[CMESH_ATTR_VERTEX].nelem = 3; + + for(i=0; ivattr[i].data_valid) { + int newsz = cm->vattr[i].count + cm->vattr[i].nelem; + float *tmp = realloc(cm->vattr[i].data, newsz * sizeof *tmp); + if(!tmp) return -1; + tmp += cm->vattr[i].count; + + cm->vattr[i].data = tmp; + cm->vattr[i].count = newsz; + + for(j=0; jvattr[i].nelem; j++) { + *tmp++ = *(&cm->cur_val[i].x + j); + } + } + cm->vattr[i].vbo_valid = 0; + cm->vattr[i].data_valid = 1; + } + + if(cm->idata_valid) { + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + } + cm->ibo_valid = cm->idata_valid = 0; + return 0; +} + +void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f); + cm->vattr[CMESH_ATTR_NORMAL].nelem = 3; +} + +void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f); + cm->vattr[CMESH_ATTR_TANGENT].nelem = 3; +} + +void cmesh_texcoord(struct cmesh *cm, float u, float v, float w) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f); + cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3; +} + +void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4); + cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4; +} + +void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4); + cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4; +} + +static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res) +{ + int i; + float *sptr, *dptr; + cgm_wcons(res, 0, 0, 0, 1); + if(!(sptr = cmesh_attrib_at(cm, attr, idx))) { + return 0; + } + dptr = &res->x; + + for(i=0; ivattr[attr].nelem; i++) { + *dptr++ = sptr[i]; + } + return sptr; +} + +static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res) +{ + int i; + float *sptr, *dptr; + cgm_vcons(res, 0, 0, 0); + if(!(sptr = cmesh_attrib_at(cm, attr, idx))) { + return 0; + } + dptr = &res->x; + + for(i=0; ivattr[attr].nelem; i++) { + *dptr++ = sptr[i]; + } + return sptr; +} + +/* dir_xform can be null, in which case it's calculated from xform */ +void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform) +{ + unsigned int i; + int j; + cgm_vec4 v; + cgm_vec3 n, t; + float *vptr; + + for(i=0; inverts; i++) { + if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) { + return; + } + cgm_wmul_m4v4(&v, xform); + for(j=0; jvattr[CMESH_ATTR_VERTEX].nelem; j++) { + *vptr++ = (&v.x)[j]; + } + + if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) { + if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) { + cgm_vmul_m3v3(&n, dir_xform); + for(j=0; jvattr[CMESH_ATTR_NORMAL].nelem; j++) { + *vptr++ = (&n.x)[j]; + } + } + } + if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) { + if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) { + cgm_vmul_m3v3(&t, dir_xform); + for(j=0; jvattr[CMESH_ATTR_TANGENT].nelem; j++) { + *vptr++ = (&t.x)[j]; + } + } + } + } +} + +void cmesh_flip(struct cmesh *cm) +{ + cmesh_flip_faces(cm); + cmesh_flip_normals(cm); +} + +void cmesh_flip_faces(struct cmesh *cm) +{ + int i, j, idxnum, vnum, nelem; + unsigned int *indices; + float *verts, *vptr; + + if(cmesh_indexed(cm)) { + if(!(indices = cmesh_index(cm))) { + return; + } + idxnum = cmesh_index_count(cm); + for(i=0; ivattr[CMESH_ATTR_VERTEX].nelem; + for(i=0; inverts * cm->vattr[CMESH_ATTR_NORMAL].nelem; + for(i=0; ivattr[i].nelem * sizeof(float)))) { + return -1; + } + dstptr = tmpbuf; + + for(j=0; jvattr[i].nelem; + + for(k=0; kvattr[i].nelem; k++) { + *dstptr++ = *srcptr++; + } + } + + free(cm->vattr[i].data); + cm->vattr[i].data = tmpbuf; + cm->vattr[i].count = nnverts * cm->vattr[i].nelem; + cm->vattr[i].data_valid = 1; + } + + cm->ibo_valid = 0; + cm->idata_valid = 0; + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + + cm->nverts = nnverts; + cm->nfaces = idxnum / 3; + return 0; +} + +void cmesh_calc_face_normals(struct cmesh *cm) +{ + /* TODO */ +} + +#ifndef NO_OPENGL +static int pre_draw(struct cmesh *cm) +{ + int i, loc, cur_sdr; + + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); + + update_buffers(cm); + + if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) { + return -1; + } + + if(cur_sdr && use_custom_sdr_attr) { + if(sdr_loc[CMESH_ATTR_VERTEX] == -1) { + return -1; + } + + for(i=0; i= 0 && cm->vattr[i].vbo_valid) { + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo); + glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0); + glEnableVertexAttribArray(loc); + } + } + } else { +#ifndef GL_ES_VERSION_2_0 + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo); + glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0); + glEnableClientState(GL_VERTEX_ARRAY); + + if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) { + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo); + glNormalPointer(GL_FLOAT, 0, 0); + glEnableClientState(GL_NORMAL_ARRAY); + } + if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) { + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo); + glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + } + if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) { + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo); + glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0); + glEnableClientState(GL_COLOR_ARRAY); + } + if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) { + glClientActiveTexture(GL_TEXTURE1); + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo); + glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glClientActiveTexture(GL_TEXTURE0); + } +#endif /* GL_ES_VERSION_2_0 */ + } + glBindBuffer(GL_ARRAY_BUFFER, 0); + return cur_sdr; +} + +void cmesh_draw(struct cmesh *cm) +{ + int cur_sdr; + + if((cur_sdr = pre_draw(cm)) == -1) { + return; + } + + if(cm->ibo_valid) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo); + glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } else { + glDrawArrays(GL_TRIANGLES, 0, cm->nverts); + } + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_range(struct cmesh *cm, int start, int count) +{ + int cur_sdr; + + if((cur_sdr = pre_draw(cm)) == -1) { + return; + } + + if(cm->ibo_valid) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo); + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, (void*)(start * 4)); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } else { + glDrawArrays(GL_TRIANGLES, start, count); + } + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_submesh(struct cmesh *cm, int subidx) +{ + struct submesh *sm = cm->sublist; + + while(sm && subidx-- > 0) { + sm = sm->next; + } + if(!sm) return; + + if(sm->icount) { + cmesh_draw_range(cm, sm->istart, sm->icount); + } else { + cmesh_draw_range(cm, sm->vstart, sm->vcount); + } +} + +static void post_draw(struct cmesh *cm, int cur_sdr) +{ + int i; + + if(cur_sdr && use_custom_sdr_attr) { + for(i=0; i= 0 && cm->vattr[i].vbo_valid) { + glDisableVertexAttribArray(loc); + } + } + } else { +#ifndef GL_ES_VERSION_2_0 + glDisableClientState(GL_VERTEX_ARRAY); + if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) { + glDisableClientState(GL_NORMAL_ARRAY); + } + if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) { + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + } + if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) { + glDisableClientState(GL_COLOR_ARRAY); + } + if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) { + glClientActiveTexture(GL_TEXTURE1); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glClientActiveTexture(GL_TEXTURE0); + } +#endif /* GL_ES_VERSION_2_0 */ + } +} + +void cmesh_draw_wire(struct cmesh *cm, float linesz) +{ + int cur_sdr, nfaces; + + if((cur_sdr = pre_draw(cm)) == -1) { + return; + } + update_wire_ibo(cm); + + nfaces = cmesh_poly_count(cm); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo); + glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_vertices(struct cmesh *cm, float ptsz) +{ + int cur_sdr; + if((cur_sdr = pre_draw(cm)) == -1) { + return; + } + + glPushAttrib(GL_POINT_BIT); + glPointSize(ptsz); + glDrawArrays(GL_POINTS, 0, cm->nverts); + glPopAttrib(); + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_normals(struct cmesh *cm, float len) +{ +#ifndef GL_ES_VERSION_2_0 + int i, cur_sdr, vert_nelem, norm_nelem; + int loc = -1; + const float *varr, *norm; + + varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX); + norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL); + if(!varr || !norm) return; + + vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem; + norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem; + + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); + if(cur_sdr && use_custom_sdr_attr) { + if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) { + return; + } + } + + glBegin(GL_LINES); + for(i=0; inverts; i++) { + float x, y, z, endx, endy, endz; + + x = varr[i * vert_nelem]; + y = varr[i * vert_nelem + 1]; + z = varr[i * vert_nelem + 2]; + endx = x + norm[i * norm_nelem] * len; + endy = y + norm[i * norm_nelem + 1] * len; + endz = z + norm[i * norm_nelem + 2] * len; + + if(loc == -1) { + glVertex3f(x, y, z); + glVertex3f(endx, endy, endz); + } else { + glVertexAttrib3f(loc, x, y, z); + glVertexAttrib3f(loc, endx, endy, endz); + } + } + glEnd(); +#endif /* GL_ES_VERSION_2_0 */ +} + +void cmesh_draw_tangents(struct cmesh *cm, float len) +{ +#ifndef GL_ES_VERSION_2_0 + int i, cur_sdr, vert_nelem, tang_nelem; + int loc = -1; + const float *varr, *tang; + + varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX); + tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT); + if(!varr || !tang) return; + + vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem; + tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem; + + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); + if(cur_sdr && use_custom_sdr_attr) { + if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) { + return; + } + } + + glBegin(GL_LINES); + for(i=0; inverts; i++) { + float x, y, z, endx, endy, endz; + + x = varr[i * vert_nelem]; + y = varr[i * vert_nelem + 1]; + z = varr[i * vert_nelem + 2]; + endx = x + tang[i * tang_nelem] * len; + endy = y + tang[i * tang_nelem + 1] * len; + endz = z + tang[i * tang_nelem + 2] * len; + + if(loc == -1) { + glVertex3f(x, y, z); + glVertex3f(endx, endy, endz); + } else { + glVertexAttrib3f(loc, x, y, z); + glVertexAttrib3f(loc, endx, endy, endz); + } + } + glEnd(); +#endif /* GL_ES_VERSION_2_0 */ +} + +static void update_buffers(struct cmesh *cm) +{ + int i; + + for(i=0; ivattr[i].vbo_valid) { + glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo); + glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float), + cm->vattr[i].data, GL_STATIC_DRAW); + cm->vattr[i].vbo_valid = 1; + } + } + glBindBuffer(GL_ARRAY_BUFFER, 0); + + if(cm->idata_valid && !cm->ibo_valid) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int), + cm->idata, GL_STATIC_DRAW); + cm->ibo_valid = 1; + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } +} + +static void update_wire_ibo(struct cmesh *cm) +{ + int i, num_faces; + unsigned int *wire_idxarr, *dest; + + update_buffers(cm); + + if(cm->wire_ibo_valid) return; + + if(!cm->wire_ibo) { + glGenBuffers(1, &cm->wire_ibo); + } + num_faces = cmesh_poly_count(cm); + + if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) { + return; + } + dest = wire_idxarr; + + if(cm->ibo_valid) { + /* we're dealing with an indexed mesh */ + const unsigned int *idxarr = cmesh_index_ro(cm); + + for(i=0; iwire_ibo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int), + wire_idxarr, GL_STATIC_DRAW); + free(wire_idxarr); + cm->wire_ibo_valid = 1; + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +} +#endif /* !def NO_OPENGL */ + +static void calc_aabb(struct cmesh *cm) +{ + int i, j; + + if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) { + return; + } + + cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX); + cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX); + + for(i=0; inverts; i++) { + const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i); + for(j=0; j<3; j++) { + if(v[j] < (&cm->aabb_min.x)[j]) { + (&cm->aabb_min.x)[j] = v[j]; + } + if(v[j] > (&cm->aabb_max.x)[j]) { + (&cm->aabb_max.x)[j] = v[j]; + } + } + } + cm->aabb_valid = 1; +} + +void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax) +{ + if(!cm->aabb_valid) { + calc_aabb(cm); + } + *vmin = cm->aabb_min; + *vmax = cm->aabb_max; +} + +static void calc_bsph(struct cmesh *cm) +{ + int i; + float s, dist_sq; + + if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) { + return; + } + + cgm_vcons(&cm->bsph_center, 0, 0, 0); + + /* first find the center */ + for(i=0; inverts; i++) { + const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i); + cm->bsph_center.x += v[0]; + cm->bsph_center.y += v[1]; + cm->bsph_center.z += v[2]; + } + s = 1.0f / (float)cm->nverts; + cm->bsph_center.x *= s; + cm->bsph_center.y *= s; + cm->bsph_center.z *= s; + + cm->bsph_radius = 0.0f; + for(i=0; inverts; i++) { + const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i); + if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) { + cm->bsph_radius = dist_sq; + } + } + cm->bsph_radius = sqrt(cm->bsph_radius); + cm->bsph_valid = 1; +} + +float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad) +{ + if(!cm->bsph_valid) { + calc_bsph(cm); + } + *center = cm->bsph_center; + *rad = cm->bsph_radius; + return cm->bsph_radius; +} + +/* TODO */ +void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform); +void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang); +void cmesh_texcoord_gen_box(struct cmesh *cm); +void cmesh_texcoord_gen_cylinder(struct cmesh *cm); + +int cmesh_dump(struct cmesh *cm, const char *fname) +{ + FILE *fp = fopen(fname, "wb"); + if(fp) { + int res = cmesh_dump_file(cm, fp); + fclose(fp); + return res; + } + return -1; +} + +int cmesh_dump_file(struct cmesh *cm, FILE *fp) +{ + static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" }; + static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 }; + int i, j; + + if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) { + return -1; + } + + fprintf(fp, "VERTEX ATTRIBUTES\n"); + + for(i=0; inverts; i++) { + fprintf(fp, "%5u:", i); + for(j=0; jvattr[j].nelem; + fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f, + nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f); + } + } + fputc('\n', fp); + } + + if(cmesh_indexed(cm)) { + const unsigned int *idx = cmesh_index_ro(cm); + int numidx = cmesh_index_count(cm); + int numtri = numidx / 3; + assert(numidx % 3 == 0); + + fprintf(fp, "FACES\n"); + + for(i=0; ivattr[CMESH_ATTR_VERTEX].nelem; + if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) { + fprintf(stderr, "vertex array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; i++) { + const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i); + fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f); + } + + if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) { + aflags |= HAS_VN; + nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem; + if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) { + fprintf(stderr, "normal array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; i++) { + const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i); + fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f); + } + } + + if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) { + aflags |= HAS_VT; + nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem; + if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) { + fprintf(stderr, "texcoord array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; i++) { + const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i); + fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f); + } + } + + if(cmesh_indexed(cm)) { + const unsigned int *idxptr = cmesh_index_ro(cm); + int numidx = cmesh_index_count(cm); + int numtri = numidx / 3; + assert(numidx % 3 == 0); + + for(i=0; inverts / 3; + unsigned int idx = 1 + voffs; + for(i=0; i +#include "cgmath/cgmath.h" + +enum { + CMESH_ATTR_VERTEX, + CMESH_ATTR_NORMAL, + CMESH_ATTR_TANGENT, + CMESH_ATTR_TEXCOORD, + CMESH_ATTR_COLOR, + CMESH_ATTR_BONEWEIGHTS, + CMESH_ATTR_BONEIDX, + CMESH_ATTR_TEXCOORD2, + + CMESH_NUM_ATTR +}; + +struct cmesh; + +/* global state */ +void cmesh_set_attrib_sdrloc(int attr, int loc); +int cmesh_get_attrib_sdrloc(int attr); +void cmesh_clear_attrib_sdrloc(void); + +/* mesh functions */ +struct cmesh *cmesh_alloc(void); +void cmesh_free(struct cmesh *cm); + +int cmesh_init(struct cmesh *cm); +void cmesh_destroy(struct cmesh *cm); + +void cmesh_clear(struct cmesh *cm); +int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc); + +int cmesh_set_name(struct cmesh *cm, const char *name); +const char *cmesh_name(struct cmesh *cm); + +int cmesh_has_attrib(struct cmesh *cm, int attr); +int cmesh_indexed(struct cmesh *cm); + +/* vdata can be 0, in which case only memory is allocated + * returns pointer to the attribute array + */ +float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num, + const float *vdata); +float *cmesh_attrib(struct cmesh *cm, int attr); /* invalidates VBO */ +const float *cmesh_attrib_ro(struct cmesh *cm, int attr); /* doesn't invalidate */ +float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx); +const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx); +int cmesh_attrib_count(struct cmesh *cm, int attr); +int cmesh_push_attrib(struct cmesh *cm, int attr, float *v); +int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x); +int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y); +int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z); +int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w); + +/* indices can be 0, in which case only memory is allocated + * returns pointer to the index array + */ +unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices); +unsigned int *cmesh_index(struct cmesh *cm); /* invalidates IBO */ +const unsigned int *cmesh_index_ro(struct cmesh *cm); /* doesn't invalidate */ +int cmesh_index_count(struct cmesh *cm); +int cmesh_push_index(struct cmesh *cm, unsigned int idx); + +int cmesh_poly_count(struct cmesh *cm); + +/* attr can be -1 to invalidate all attributes */ +void cmesh_invalidate_vbo(struct cmesh *cm, int attr); +void cmesh_invalidate_ibo(struct cmesh *cm); + +int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc); + +/* submeshes */ +void cmesh_clear_submeshes(struct cmesh *cm); +/* a submesh is defined as a consecutive range of faces */ +int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount); +int cmesh_remove_submesh(struct cmesh *cm, int idx); +int cmesh_find_submesh(struct cmesh *cm, const char *name); +int cmesh_submesh_count(struct cmesh *cm); +int cmesh_clone_submesh(struct cmesh *cmdest, struct cmesh *cm, int subidx); + +/* immediate-mode style mesh construction interface */ +int cmesh_vertex(struct cmesh *cm, float x, float y, float z); +void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz); +void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz); +void cmesh_texcoord(struct cmesh *cm, float u, float v, float w); +void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4); +void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4); + +/* dir_xform can be null, in which case it's calculated from xform */ +void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform); + +void cmesh_flip(struct cmesh *cm); /* flip faces (winding) and normals */ +void cmesh_flip_faces(struct cmesh *cm); +void cmesh_flip_normals(struct cmesh *cm); + +int cmesh_explode(struct cmesh *cm); /* undo all vertex sharing */ + +/* this is only guaranteed to work on an exploded mesh */ +void cmesh_calc_face_normals(struct cmesh *cm); + +void cmesh_draw(struct cmesh *cm); +void cmesh_draw_range(struct cmesh *cm, int start, int count); +void cmesh_draw_submesh(struct cmesh *cm, int subidx); /* XXX only for indexed meshes currently */ +void cmesh_draw_wire(struct cmesh *cm, float linesz); +void cmesh_draw_vertices(struct cmesh *cm, float ptsz); +void cmesh_draw_normals(struct cmesh *cm, float len); +void cmesh_draw_tangents(struct cmesh *cm, float len); + +/* get the bounding box in local space. The result will be cached and subsequent + * calls will return the same box. The cache gets invalidated by any functions that + * can affect the vertex data + */ +void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax); + +/* get the bounding sphere in local space. The result will be cached ... see above */ +float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad); + +/* texture coordinate manipulation */ +void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform); +void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang); +void cmesh_texcoord_gen_box(struct cmesh *cm); +void cmesh_texcoord_gen_cylinder(struct cmesh *cm); + +/* FILE I/O */ +int cmesh_load(struct cmesh *cm, const char *fname); + +int cmesh_dump(struct cmesh *cm, const char *fname); +int cmesh_dump_file(struct cmesh *cm, FILE *fp); +int cmesh_dump_obj(struct cmesh *cm, const char *fname); +int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs); + + + +#endif /* CMESH_H_ */ diff --git a/tools/meshdump/dynarr.c b/tools/meshdump/dynarr.c new file mode 100644 index 0000000..59bbf8c --- /dev/null +++ b/tools/meshdump/dynarr.c @@ -0,0 +1,141 @@ +/* dynarr - dynamic resizable C array data structure + * author: John Tsiombikas + * license: public domain + */ +#include +#include +#include +#include "dynarr.h" + +/* The array descriptor keeps auxilliary information needed to manipulate + * the dynamic array. It's allocated adjacent to the array buffer. + */ +struct arrdesc { + int nelem, szelem; + int max_elem; + int bufsz; /* not including the descriptor */ +}; + +#define DESC(x) ((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc))) + +void *dynarr_alloc(int elem, int szelem) +{ + struct arrdesc *desc; + + if(!(desc = malloc(elem * szelem + sizeof *desc))) { + return 0; + } + desc->nelem = desc->max_elem = elem; + desc->szelem = szelem; + desc->bufsz = elem * szelem; + return (char*)desc + sizeof *desc; +} + +void dynarr_free(void *da) +{ + if(da) { + free(DESC(da)); + } +} + +void *dynarr_resize(void *da, int elem) +{ + int newsz; + void *tmp; + struct arrdesc *desc; + + if(!da) return 0; + desc = DESC(da); + + newsz = desc->szelem * elem; + + if(!(tmp = realloc(desc, newsz + sizeof *desc))) { + return 0; + } + desc = tmp; + + desc->nelem = desc->max_elem = elem; + desc->bufsz = newsz; + return (char*)desc + sizeof *desc; +} + +int dynarr_empty(void *da) +{ + return DESC(da)->nelem ? 0 : 1; +} + +int dynarr_size(void *da) +{ + return DESC(da)->nelem; +} + + +void *dynarr_clear(void *da) +{ + return dynarr_resize(da, 0); +} + +/* stack semantics */ +void *dynarr_push(void *da, void *item) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(nelem >= desc->max_elem) { + /* need to resize */ + struct arrdesc *tmp; + int newsz = desc->max_elem ? desc->max_elem * 2 : 1; + + if(!(tmp = dynarr_resize(da, newsz))) { + fprintf(stderr, "failed to resize\n"); + return da; + } + da = tmp; + desc = DESC(da); + desc->nelem = nelem; + } + + if(item) { + memcpy((char*)da + desc->nelem * desc->szelem, item, desc->szelem); + } + desc->nelem++; + return da; +} + +void *dynarr_pop(void *da) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(!nelem) return da; + + if(nelem <= desc->max_elem / 3) { + /* reclaim space */ + struct arrdesc *tmp; + int newsz = desc->max_elem / 2; + + if(!(tmp = dynarr_resize(da, newsz))) { + fprintf(stderr, "failed to resize\n"); + return da; + } + da = tmp; + desc = DESC(da); + desc->nelem = nelem; + } + desc->nelem--; + + return da; +} + +void *dynarr_finalize(void *da) +{ + struct arrdesc *desc = DESC(da); + memmove(desc, da, desc->bufsz); + return desc; +} diff --git a/tools/meshdump/dynarr.h b/tools/meshdump/dynarr.h new file mode 100644 index 0000000..8690b5a --- /dev/null +++ b/tools/meshdump/dynarr.h @@ -0,0 +1,80 @@ +/* dynarr - dynamic resizable C array data structure + * author: John Tsiombikas + * license: public domain + */ +#ifndef DYNARR_H_ +#define DYNARR_H_ + +/* usage example: + * ------------- + * int *arr = dynarr_alloc(0, sizeof *arr); + * + * int x = 10; + * arr = dynarr_push(arr, &x); + * x = 5; + * arr = dynarr_push(arr, &x); + * x = 42; + * arr = dynarr_push(arr, &x); + * + * for(i=0; i +#include +#include +#include "cmesh.h" + +int dump(struct cmesh *cm); + +int main(int argc, char **argv) +{ + int i; + struct cmesh *cm; + + for(i=1; i +#include +#include +#include +#include "cmesh.h" + +#ifdef USE_ASSIMP +#include +#include +#include +#include +#include +#else +#include "dynarr.h" +#include "rbtree.h" +#endif + + +#ifdef USE_ASSIMP + +static int add_mesh(struct cmesh *mesh, struct aiMesh *aimesh); + +#define AIPPFLAGS \ + (aiProcess_JoinIdenticalVertices | aiProcess_PreTransformVertices | \ + aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_FlipUVs) + +int cmesh_load(struct cmesh *mesh, const char *fname) +{ + int i; + const struct aiScene *aiscn; + + if(!(aiscn = aiImportFile(fname, AIPPFLAGS))) { + fprintf(stderr, "failed to open mesh file: %s\n", fname); + return -1; + } + + for(i=0; i<(int)aiscn->mNumMeshes; i++) { + add_mesh(mesh, aiscn->mMeshes[i]); + } + + aiReleaseImport(aiscn); + return 0; +} + +static int add_mesh(struct cmesh *mesh, struct aiMesh *aim) +{ + int i, j, voffs, foffs; + + voffs = cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX); + foffs = cmesh_poly_count(mesh); + + for(i=0; imNumVertices; i++) { + struct aiVector3D *v = aim->mVertices + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_VERTEX, v->x, v->y, v->z); + + if(aim->mNormals) { + v = aim->mNormals + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_NORMAL, v->x, v->y, v->z); + } + if(aim->mTangents) { + v = aim->mTangents + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_TANGENT, v->x, v->y, v->z); + } + if(aim->mColors[0]) { + struct aiColor4D *col = aim->mColors[0] + i; + cmesh_push_attrib4f(mesh, CMESH_ATTR_COLOR, col->r, col->g, col->b, col->a); + } + if(aim->mTextureCoords[0]) { + v = aim->mTextureCoords[0] + i; + cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD, v->x, v->y); + } + if(aim->mTextureCoords[1]) { + v = aim->mTextureCoords[1] + i; + cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD2, v->x, v->y); + } + } + + if(aim->mFaces) { + for(i=0; imNumFaces; i++) { + assert(aim->mFaces[i].mNumIndices == 3); + for(j=0; j<3; j++) { + cmesh_push_index(mesh, aim->mFaces[i].mIndices[j] + voffs); + } + } + cmesh_submesh(mesh, aim->mName.data, foffs, aim->mNumFaces); + } + return 0; +} + +#else + +struct vertex_pos { + float x, y, z; +}; + +struct facevertex { + int vidx, tidx, nidx; +}; + +static char *clean_line(char *s); +static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn); +static int cmp_facevert(const void *ap, const void *bp); +static void free_rbnode_key(struct rbnode *n, void *cls); + +/* merge of different indices per attribute happens during face processing. + * + * A triplet of (vertex index/texcoord index/normal index) is used as the key + * to search in a balanced binary search tree for vertex buffer index assigned + * to the same triplet if it has been encountered before. That index is + * appended to the index buffer. + * + * If a particular triplet has not been encountered before, a new vertex is + * appended to the vertex buffer. The index of this new vertex is appended to + * the index buffer, and also inserted into the tree for future searches. + */ +int cmesh_load(struct cmesh *mesh, const char *fname) +{ + int i, line_num = 0, result = -1; + int found_quad = 0; + FILE *fp = 0; + char buf[256]; + struct vertex_pos *varr = 0; + cgm_vec3 *narr = 0; + cgm_vec2 *tarr = 0; + struct rbtree *rbtree = 0; + char *subname = 0; + int substart = 0, subcount = 0; + + if(!(fp = fopen(fname, "rb"))) { + fprintf(stderr, "load_mesh: failed to open file: %s\n", fname); + goto err; + } + + if(!(rbtree = rb_create(cmp_facevert))) { + fprintf(stderr, "load_mesh: failed to create facevertex binary search tree\n"); + goto err; + } + rb_set_delete_func(rbtree, free_rbnode_key, 0); + + if(!(varr = dynarr_alloc(0, sizeof *varr)) || + !(narr = dynarr_alloc(0, sizeof *narr)) || + !(tarr = dynarr_alloc(0, sizeof *tarr))) { + fprintf(stderr, "load_mesh: failed to allocate resizable vertex array\n"); + goto err; + } + + while(fgets(buf, sizeof buf, fp)) { + char *line = clean_line(buf); + ++line_num; + + if(!*line) continue; + + switch(line[0]) { + case 'v': + if(isspace(line[1])) { + /* vertex */ + struct vertex_pos v; + int num; + + num = sscanf(line + 2, "%f %f %f", &v.x, &v.y, &v.z); + if(num < 3) { + fprintf(stderr, "%s:%d: invalid vertex definition: \"%s\"\n", fname, line_num, line); + goto err; + } + if(!(varr = dynarr_push(varr, &v))) { + fprintf(stderr, "load_mesh: failed to resize vertex buffer\n"); + goto err; + } + + } else if(line[1] == 't' && isspace(line[2])) { + /* texcoord */ + cgm_vec2 tc; + if(sscanf(line + 3, "%f %f", &tc.x, &tc.y) != 2) { + fprintf(stderr, "%s:%d: invalid texcoord definition: \"%s\"\n", fname, line_num, line); + goto err; + } + tc.y = 1.0f - tc.y; + if(!(tarr = dynarr_push(tarr, &tc))) { + fprintf(stderr, "load_mesh: failed to resize texcoord buffer\n"); + goto err; + } + + } else if(line[1] == 'n' && isspace(line[2])) { + /* normal */ + cgm_vec3 norm; + if(sscanf(line + 3, "%f %f %f", &norm.x, &norm.y, &norm.z) != 3) { + fprintf(stderr, "%s:%d: invalid normal definition: \"%s\"\n", fname, line_num, line); + goto err; + } + if(!(narr = dynarr_push(narr, &norm))) { + fprintf(stderr, "load_mesh: failed to resize normal buffer\n"); + goto err; + } + } + break; + + case 'f': + if(isspace(line[1])) { + /* face */ + char *ptr = line + 2; + struct facevertex fv; + struct rbnode *node; + int vsz = dynarr_size(varr); + int tsz = dynarr_size(tarr); + int nsz = dynarr_size(narr); + + for(i=0; i<4; i++) { + if(!(ptr = parse_face_vert(ptr, &fv, vsz, tsz, nsz))) { + if(i < 3 || found_quad) { + fprintf(stderr, "%s:%d: invalid face definition: \"%s\"\n", fname, line_num, line); + goto err; + } else { + break; + } + } + + if((node = rb_find(rbtree, &fv))) { + unsigned int idx = (unsigned int)node->data; + assert(idx < cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX)); + if(cmesh_push_index(mesh, idx) == -1) { + fprintf(stderr, "load_mesh: failed to resize index array\n"); + goto err; + } + subcount++; /* inc number of submesh indices, in case we have submeshes */ + } else { + unsigned int newidx = cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX); + struct facevertex *newfv; + struct vertex_pos *vptr = varr + fv.vidx; + + if(cmesh_push_attrib3f(mesh, CMESH_ATTR_VERTEX, vptr->x, vptr->y, vptr->z) == -1) { + fprintf(stderr, "load_mesh: failed to resize vertex array\n"); + goto err; + } + if(fv.nidx >= 0) { + float nx = narr[fv.nidx].x; + float ny = narr[fv.nidx].y; + float nz = narr[fv.nidx].z; + if(cmesh_push_attrib3f(mesh, CMESH_ATTR_NORMAL, nx, ny, nz) == -1) { + fprintf(stderr, "load_mesh: failed to resize normal array\n"); + goto err; + } + } + if(fv.tidx >= 0) { + float tu = tarr[fv.tidx].x; + float tv = tarr[fv.tidx].y; + if(cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD, tu, tv) == -1) { + fprintf(stderr, "load_mesh: failed to resize texcoord array\n"); + goto err; + } + } + + if(cmesh_push_index(mesh, newidx) == -1) { + fprintf(stderr, "load_mesh: failed to resize index array\n"); + goto err; + } + subcount++; /* inc number of submesh indices, in case we have submeshes */ + + if((newfv = malloc(sizeof *newfv))) { + *newfv = fv; + } + if(!newfv || rb_insert(rbtree, newfv, (void*)newidx) == -1) { + fprintf(stderr, "load_mesh: failed to insert facevertex to the binary search tree\n"); + goto err; + } + } + } + if(i > 3) found_quad = 1; + } + break; + + case 'o': + if(subcount > 0) { + printf("adding submesh: %s\n", subname); + cmesh_submesh(mesh, subname, substart / 3, subcount / 3); + } + free(subname); + if((subname = malloc(strlen(line)))) { + strcpy(subname, clean_line(line + 2)); + } + substart += subcount; + subcount = 0; + break; + + default: + break; + } + } + + if(subcount > 0) { + /* don't add the final submesh if we never found another. an obj file with a + * single 'o' for the whole list of faces, is a single mesh without submeshes + */ + if(cmesh_submesh_count(mesh) > 0) { + printf("adding submesh: %s\n", subname); + cmesh_submesh(mesh, subname, substart / 3, subcount / 3); + } else { + /* ... but use the 'o' name as the name of the mesh instead of the filename */ + if(subname && *subname) { + cmesh_set_name(mesh, subname); + } + } + } + + result = 0; /* success */ + + printf("loaded %s mesh: %s (%d submeshes): %d vertices, %d faces\n", + found_quad ? "quad" : "triangle", fname, cmesh_submesh_count(mesh), + cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX), cmesh_poly_count(mesh)); + +err: + if(fp) fclose(fp); + dynarr_free(varr); + dynarr_free(narr); + dynarr_free(tarr); + rb_free(rbtree); + free(subname); + return result; +} + + +static char *clean_line(char *s) +{ + char *end; + + while(*s && isspace(*s)) ++s; + if(!*s) return 0; + + end = s; + while(*end && *end != '#') ++end; + *end-- = 0; + + while(end > s && isspace(*end)) { + *end-- = 0; + } + + return s; +} + +static char *parse_idx(char *ptr, int *idx, int arrsz) +{ + char *endp; + int val = strtol(ptr, &endp, 10); + if(endp == ptr) return 0; + + if(val < 0) { /* convert negative indices */ + *idx = arrsz + val; + } else { + *idx = val - 1; /* indices in obj are 1-based */ + } + return endp; +} + +/* possible face-vertex definitions: + * 1. vertex + * 2. vertex/texcoord + * 3. vertex//normal + * 4. vertex/texcoord/normal + */ +static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn) +{ + if(!(ptr = parse_idx(ptr, &fv->vidx, numv))) + return 0; + if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0; + + if(*++ptr == '/') { /* no texcoord */ + fv->tidx = -1; + ++ptr; + } else { + if(!(ptr = parse_idx(ptr, &fv->tidx, numt))) + return 0; + if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0; + ++ptr; + } + + if(!(ptr = parse_idx(ptr, &fv->nidx, numn))) + return 0; + return (!*ptr || isspace(*ptr)) ? ptr : 0; +} + +static int cmp_facevert(const void *ap, const void *bp) +{ + const struct facevertex *a = ap; + const struct facevertex *b = bp; + + if(a->vidx == b->vidx) { + if(a->tidx == b->tidx) { + return a->nidx - b->nidx; + } + return a->tidx - b->tidx; + } + return a->vidx - b->vidx; +} + +static void free_rbnode_key(struct rbnode *n, void *cls) +{ + free(n->key); +} +#endif diff --git a/tools/meshdump/rbtree.c b/tools/meshdump/rbtree.c new file mode 100644 index 0000000..e595885 --- /dev/null +++ b/tools/meshdump/rbtree.c @@ -0,0 +1,503 @@ +/* +rbtree - simple balanced binary search tree (red-black tree) library. +Copyright (C) 2011-2014 John Tsiombikas + +rbtree is free software, feel free to use, modify, and redistribute it, under +the terms of the 3-clause BSD license. See COPYING for details. + */ +#include +#include +#include +#include +#include "rbtree.h" + +#define INT2PTR(x) ((void*)(intptr_t)(x)) +#define PTR2INT(x) ((int)(intptr_t)(x)) + +struct rbtree { + struct rbnode *root; + + rb_alloc_func_t alloc; + rb_free_func_t free; + + rb_cmp_func_t cmp; + rb_del_func_t del; + void *del_cls; + + struct rbnode *rstack, *iter; +}; + +static int cmpaddr(const void *ap, const void *bp); +static int cmpint(const void *ap, const void *bp); + +static int count_nodes(struct rbnode *node); +static void del_tree(struct rbnode *node, void (*delfunc)(struct rbnode*, void*), void *cls); +static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data); +static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key); +/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key);*/ +static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls); + +struct rbtree *rb_create(rb_cmp_func_t cmp_func) +{ + struct rbtree *rb; + + if(!(rb = malloc(sizeof *rb))) { + return 0; + } + if(rb_init(rb, cmp_func) == -1) { + free(rb); + return 0; + } + return rb; +} + +void rb_free(struct rbtree *rb) +{ + rb_destroy(rb); + free(rb); +} + + +int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func) +{ + memset(rb, 0, sizeof *rb); + + if(!cmp_func) { + rb->cmp = cmpaddr; + } else if(cmp_func == RB_KEY_INT) { + rb->cmp = cmpint; + } else if(cmp_func == RB_KEY_STRING) { + rb->cmp = (rb_cmp_func_t)strcmp; + } else { + rb->cmp = cmp_func; + } + + rb->alloc = malloc; + rb->free = free; + return 0; +} + +void rb_destroy(struct rbtree *rb) +{ + del_tree(rb->root, rb->del, rb->del_cls); +} + +void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free) +{ + rb->alloc = alloc; + rb->free = free; +} + + +void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func) +{ + rb->cmp = func; +} + +void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls) +{ + rb->del = func; + rb->del_cls = cls; +} + + +void rb_clear(struct rbtree *rb) +{ + del_tree(rb->root, rb->del, rb->del_cls); + rb->root = 0; +} + +int rb_copy(struct rbtree *dest, struct rbtree *src) +{ + struct rbnode *node; + + rb_clear(dest); + rb_begin(src); + while((node = rb_next(src))) { + if(rb_insert(dest, node->key, node->data) == -1) { + return -1; + } + } + return 0; +} + +int rb_size(struct rbtree *rb) +{ + return count_nodes(rb->root); +} + +int rb_insert(struct rbtree *rb, void *key, void *data) +{ + rb->root = insert(rb, rb->root, key, data); + rb->root->red = 0; + return 0; +} + +int rb_inserti(struct rbtree *rb, int key, void *data) +{ + rb->root = insert(rb, rb->root, INT2PTR(key), data); + rb->root->red = 0; + return 0; +} + + +int rb_delete(struct rbtree *rb, void *key) +{ + if((rb->root = delete(rb, rb->root, key))) { + rb->root->red = 0; + } + return 0; +} + +int rb_deletei(struct rbtree *rb, int key) +{ + if((rb->root = delete(rb, rb->root, INT2PTR(key)))) { + rb->root->red = 0; + } + return 0; +} + + +struct rbnode *rb_find(struct rbtree *rb, void *key) +{ + struct rbnode *node = rb->root; + + while(node) { + int cmp = rb->cmp(key, node->key); + if(cmp == 0) { + return node; + } + node = cmp < 0 ? node->left : node->right; + } + return 0; +} + +struct rbnode *rb_findi(struct rbtree *rb, int key) +{ + return rb_find(rb, INT2PTR(key)); +} + + +void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls) +{ + traverse(rb->root, func, cls); +} + + +struct rbnode *rb_root(struct rbtree *rb) +{ + return rb->root; +} + +void rb_begin(struct rbtree *rb) +{ + rb->rstack = 0; + rb->iter = rb->root; +} + +#define push(sp, x) ((x)->next = (sp), (sp) = (x)) +#define pop(sp) ((sp) = (sp)->next) +#define top(sp) (sp) + +struct rbnode *rb_next(struct rbtree *rb) +{ + struct rbnode *res = 0; + + while(rb->rstack || rb->iter) { + if(rb->iter) { + push(rb->rstack, rb->iter); + rb->iter = rb->iter->left; + } else { + rb->iter = top(rb->rstack); + pop(rb->rstack); + res = rb->iter; + rb->iter = rb->iter->right; + break; + } + } + return res; +} + +void *rb_node_key(struct rbnode *node) +{ + return node ? node->key : 0; +} + +int rb_node_keyi(struct rbnode *node) +{ + return node ? PTR2INT(node->key) : 0; +} + +void *rb_node_data(struct rbnode *node) +{ + return node ? node->data : 0; +} + +static int cmpaddr(const void *ap, const void *bp) +{ + return ap < bp ? -1 : (ap > bp ? 1 : 0); +} + +static int cmpint(const void *ap, const void *bp) +{ + return PTR2INT(ap) - PTR2INT(bp); +} + + +/* ---- left-leaning 2-3 red-black implementation ---- */ + +/* helper prototypes */ +static int is_red(struct rbnode *tree); +static void color_flip(struct rbnode *tree); +static struct rbnode *rot_left(struct rbnode *a); +static struct rbnode *rot_right(struct rbnode *a); +static struct rbnode *find_min(struct rbnode *tree); +static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree); +/*static struct rbnode *move_red_right(struct rbnode *tree);*/ +static struct rbnode *move_red_left(struct rbnode *tree); +static struct rbnode *fix_up(struct rbnode *tree); + +static int count_nodes(struct rbnode *node) +{ + if(!node) + return 0; + + return 1 + count_nodes(node->left) + count_nodes(node->right); +} + +static void del_tree(struct rbnode *node, rb_del_func_t delfunc, void *cls) +{ + if(!node) + return; + + del_tree(node->left, delfunc, cls); + del_tree(node->right, delfunc, cls); + + if(delfunc) { + delfunc(node, cls); + } + free(node); +} + +static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data) +{ + int cmp; + + if(!tree) { + struct rbnode *node = rb->alloc(sizeof *node); + node->red = 1; + node->key = key; + node->data = data; + node->left = node->right = 0; + return node; + } + + cmp = rb->cmp(key, tree->key); + + if(cmp < 0) { + tree->left = insert(rb, tree->left, key, data); + } else if(cmp > 0) { + tree->right = insert(rb, tree->right, key, data); + } else { + tree->data = data; + } + + /* fix right-leaning reds */ + if(is_red(tree->right)) { + tree = rot_left(tree); + } + /* fix two reds in a row */ + if(is_red(tree->left) && is_red(tree->left->left)) { + tree = rot_right(tree); + } + + /* if 4-node, split it by color inversion */ + if(is_red(tree->left) && is_red(tree->right)) { + color_flip(tree); + } + + return tree; +} + +static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key) +{ + int cmp; + + if(!tree) { + return 0; + } + + cmp = rb->cmp(key, tree->key); + + if(cmp < 0) { + if(!is_red(tree->left) && !is_red(tree->left->left)) { + tree = move_red_left(tree); + } + tree->left = delete(rb, tree->left, key); + } else { + /* need reds on the right */ + if(is_red(tree->left)) { + tree = rot_right(tree); + } + + /* found it at the bottom (XXX what certifies left is null?) */ + if(cmp == 0 && !tree->right) { + if(rb->del) { + rb->del(tree, rb->del_cls); + } + rb->free(tree); + return 0; + } + + if(!is_red(tree->right) && !is_red(tree->right->left)) { + tree = move_red_left(tree); + } + + if(key == tree->key) { + struct rbnode *rmin = find_min(tree->right); + tree->key = rmin->key; + tree->data = rmin->data; + tree->right = del_min(rb, tree->right); + } else { + tree->right = delete(rb, tree->right, key); + } + } + + return fix_up(tree); +} + +/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key) +{ + int cmp; + + if(!node) + return 0; + + if((cmp = rb->cmp(key, node->key)) == 0) { + return node; + } + return find(rb, cmp < 0 ? node->left : node->right, key); +}*/ + +static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls) +{ + if(!node) + return; + + traverse(node->left, func, cls); + func(node, cls); + traverse(node->right, func, cls); +} + +/* helpers */ + +static int is_red(struct rbnode *tree) +{ + return tree && tree->red; +} + +static void color_flip(struct rbnode *tree) +{ + tree->red = !tree->red; + tree->left->red = !tree->left->red; + tree->right->red = !tree->right->red; +} + +static struct rbnode *rot_left(struct rbnode *a) +{ + struct rbnode *b = a->right; + a->right = b->left; + b->left = a; + b->red = a->red; + a->red = 1; + return b; +} + +static struct rbnode *rot_right(struct rbnode *a) +{ + struct rbnode *b = a->left; + a->left = b->right; + b->right = a; + b->red = a->red; + a->red = 1; + return b; +} + +static struct rbnode *find_min(struct rbnode *tree) +{ + if(!tree) + return 0; + + while(tree->left) { + tree = tree->left; + } + return tree; +} + +static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree) +{ + if(!tree->left) { + if(rb->del) { + rb->del(tree->left, rb->del_cls); + } + rb->free(tree->left); + return 0; + } + + /* make sure we've got red (3/4-nodes) at the left side so we can delete at the bottom */ + if(!is_red(tree->left) && !is_red(tree->left->left)) { + tree = move_red_left(tree); + } + tree->left = del_min(rb, tree->left); + + /* fix right-reds, red-reds, and split 4-nodes on the way up */ + return fix_up(tree); +} + +#if 0 +/* push a red link on this node to the right */ +static struct rbnode *move_red_right(struct rbnode *tree) +{ + /* flipping it makes both children go red, so we have a red to the right */ + color_flip(tree); + + /* if after the flip we've got a red-red situation to the left, fix it */ + if(is_red(tree->left->left)) { + tree = rot_right(tree); + color_flip(tree); + } + return tree; +} +#endif + +/* push a red link on this node to the left */ +static struct rbnode *move_red_left(struct rbnode *tree) +{ + /* flipping it makes both children go red, so we have a red to the left */ + color_flip(tree); + + /* if after the flip we've got a red-red on the right-left, fix it */ + if(is_red(tree->right->left)) { + tree->right = rot_right(tree->right); + tree = rot_left(tree); + color_flip(tree); + } + return tree; +} + +static struct rbnode *fix_up(struct rbnode *tree) +{ + /* fix right-leaning */ + if(is_red(tree->right)) { + tree = rot_left(tree); + } + /* change invalid red-red pairs into a proper 4-node */ + if(is_red(tree->left) && is_red(tree->left->left)) { + tree = rot_right(tree); + } + /* split 4-nodes */ + if(is_red(tree->left) && is_red(tree->right)) { + color_flip(tree); + } + return tree; +} diff --git a/tools/meshdump/rbtree.h b/tools/meshdump/rbtree.h new file mode 100644 index 0000000..8688c7f --- /dev/null +++ b/tools/meshdump/rbtree.h @@ -0,0 +1,78 @@ +/* +rbtree - simple balanced binary search tree (red-black tree) library. +Copyright (C) 2011-2014 John Tsiombikas + +rbtree is free software, feel free to use, modify, and redistribute it, under +the terms of the 3-clause BSD license. See COPYING for details. + */ +#ifndef RBTREE_H_ +#define RBTREE_H_ + +struct rbtree; + + +struct rbnode { + void *key, *data; + int red; + struct rbnode *left, *right; + struct rbnode *next; /* for iterator stack */ +}; + + +typedef void *(*rb_alloc_func_t)(size_t); +typedef void (*rb_free_func_t)(void*); + +typedef int (*rb_cmp_func_t)(const void*, const void*); +typedef void (*rb_del_func_t)(struct rbnode*, void*); + +#define RB_KEY_ADDR (rb_cmp_func_t)(0) +#define RB_KEY_INT (rb_cmp_func_t)(1) +#define RB_KEY_STRING (rb_cmp_func_t)(3) + + +#ifdef __cplusplus +extern "C" { +#endif + +struct rbtree *rb_create(rb_cmp_func_t cmp_func); +void rb_free(struct rbtree *rb); + +int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func); +void rb_destroy(struct rbtree *rb); + +void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free); +void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func); +void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls); +/* TODO add user deep copy function */ + +void rb_clear(struct rbtree *rb); +int rb_copy(struct rbtree *dest, struct rbtree *src); + +int rb_size(struct rbtree *rb); + +int rb_insert(struct rbtree *rb, void *key, void *data); +int rb_inserti(struct rbtree *rb, int key, void *data); + +int rb_delete(struct rbtree *rb, void *key); +int rb_deletei(struct rbtree *rb, int key); + +struct rbnode *rb_find(struct rbtree *rb, void *key); +struct rbnode *rb_findi(struct rbtree *rb, int key); + +void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls); + +struct rbnode *rb_root(struct rbtree *rb); + +void rb_begin(struct rbtree *rb); +struct rbnode *rb_next(struct rbtree *rb); + +void *rb_node_key(struct rbnode *node); +int rb_node_keyi(struct rbnode *node); +void *rb_node_data(struct rbnode *node); + +#ifdef __cplusplus +} +#endif + + +#endif /* RBTREE_H_ */ -- 1.7.10.4