From 151e4342f35e1e276ec05a700ac7d27436116094 Mon Sep 17 00:00:00 2001 From: Zack Buhman Date: Tue, 29 Jul 2025 17:14:21 -0500 Subject: [PATCH] demo/lizard: in-person game jam event version --- .gitignore | 4 +- build_textures.sh | 15 ++ demo.mk | 28 ++- font/ter_u12n.data | Bin 4096 -> 0 bytes src/demo/bridge.cpp | 2 +- src/demo/bridge.hpp | 2 +- src/demo/lizard/levels.hpp | 28 +++ src/demo/lizard/main.cpp | 228 ++++++++++++++++++++ src/demo/lizard/main.hpp | 40 ++++ src/demo/lizard/maps/level1.png | Bin 0 -> 631 bytes src/demo/lizard/world.cpp | 109 ++++++++++ src/demo/lizard/world.hpp | 29 +++ src/demo/scene.hpp | 6 +- src/platform/font.cpp | 4 +- src/platform/graphics.cpp | 38 +++- src/platform/graphics_primitive.cpp | 288 +++++++++++++++++++++++++- src/platform/graphics_primitive.hpp | 24 +-- src/platform/ta_parameter_presets.hpp | 187 +++++++++++++++++ src/platform/texture.cpp | 60 ++++++ src/platform/texture.hpp | 24 +++ texture/igh25_box_bottom_32.data.h | 15 ++ texture/igh25_box_bottom_32.png | Bin 0 -> 9659 bytes texture/igh25_box_side_32.data.h | 15 ++ texture/igh25_box_side_32.png | Bin 0 -> 10022 bytes texture/igh25_box_top_32.data.h | 15 ++ texture/igh25_box_top_32.png | Bin 0 -> 9810 bytes texture/walking/frame0000.png | Bin 0 -> 2496 bytes texture/walking/frame0000_128.data.h | 15 ++ texture/walking/frame0001.png | Bin 0 -> 2497 bytes texture/walking/frame0001_128.data.h | 15 ++ texture/walking/frame0002.png | Bin 0 -> 2564 bytes texture/walking/frame0002_128.data.h | 15 ++ texture/walking/frame0003.png | Bin 0 -> 2545 bytes texture/walking/frame0003_128.data.h | 15 ++ texture/walking/frame0004.png | Bin 0 -> 2511 bytes texture/walking/frame0004_128.data.h | 15 ++ texture/walking/frame0005.png | Bin 0 -> 2520 bytes texture/walking/frame0005_128.data.h | 15 ++ texture/walking/frame0006.png | Bin 0 -> 2524 bytes texture/walking/frame0006_128.data.h | 15 ++ tools/canvas_size.py | 17 ++ tools/generate.py | 42 ++++ tools/parse_map.py | 151 ++++++++++++++ 43 files changed, 1446 insertions(+), 30 deletions(-) create mode 100644 build_textures.sh delete mode 100644 font/ter_u12n.data create mode 100644 src/demo/lizard/levels.hpp create mode 100644 src/demo/lizard/main.cpp create mode 100644 src/demo/lizard/main.hpp create mode 100644 src/demo/lizard/maps/level1.png create mode 100644 src/demo/lizard/world.cpp create mode 100644 src/demo/lizard/world.hpp create mode 100644 texture/igh25_box_bottom_32.data.h create mode 100644 texture/igh25_box_bottom_32.png create mode 100644 texture/igh25_box_side_32.data.h create mode 100644 texture/igh25_box_side_32.png create mode 100644 texture/igh25_box_top_32.data.h create mode 100644 texture/igh25_box_top_32.png create mode 100755 texture/walking/frame0000.png create mode 100644 texture/walking/frame0000_128.data.h create mode 100755 texture/walking/frame0001.png create mode 100644 texture/walking/frame0001_128.data.h create mode 100755 texture/walking/frame0002.png create mode 100644 texture/walking/frame0002_128.data.h create mode 100755 texture/walking/frame0003.png create mode 100644 texture/walking/frame0003_128.data.h create mode 100755 texture/walking/frame0004.png create mode 100644 texture/walking/frame0004_128.data.h create mode 100755 texture/walking/frame0005.png create mode 100644 texture/walking/frame0005_128.data.h create mode 100755 texture/walking/frame0006.png create mode 100644 texture/walking/frame0006_128.data.h create mode 100644 tools/canvas_size.py create mode 100644 tools/generate.py create mode 100644 tools/parse_map.py diff --git a/.gitignore b/.gitignore index 206b71c..6e25a20 100644 --- a/.gitignore +++ b/.gitignore @@ -12,4 +12,6 @@ __pycache__ *.gch *.blend1 *.scramble -*.FCStd1 \ No newline at end of file +*.FCStd1 +*.data +*_128.png \ No newline at end of file diff --git a/build_textures.sh b/build_textures.sh new file mode 100644 index 0000000..b667ed8 --- /dev/null +++ b/build_textures.sh @@ -0,0 +1,15 @@ +set -eux + +for i in texture/*.png; do + j=$(echo $i | cut -d. -f1).data + python ~/model_generator/color_convert.py $i rgb565 twiddled non_mipmapped $j + make ${j}.h +done + +rm -f texture/walking/*128.png +for i in texture/walking/*.png; do + j=$(echo $i | cut -d. -f1) + python ~/physics_engine/tools/canvas_size.py $i 128 32 ${j}_128.png + python ~/model_generator/color_convert.py ${j}_128.png argb4444 twiddled non_mipmapped ${j}_128.data + make ${j}_128.data.h +done diff --git a/demo.mk b/demo.mk index f5552c5..615abe3 100644 --- a/demo.mk +++ b/demo.mk @@ -1,6 +1,18 @@ FONT_OBJ = \ font/ter_u12n.data.o +TEXTURE_OBJ = \ + texture/igh25_box_top_32.data.o \ + texture/igh25_box_bottom_32.data.o \ + texture/igh25_box_side_32.data.o \ + texture/walking/frame0000_128.data.o \ + texture/walking/frame0001_128.data.o \ + texture/walking/frame0002_128.data.o \ + texture/walking/frame0003_128.data.o \ + texture/walking/frame0004_128.data.o \ + texture/walking/frame0005_128.data.o \ + texture/walking/frame0006_128.data.o + DEMO_OBJ = \ $(LIB)/holly/core.o \ $(LIB)/holly/region_array.o \ @@ -23,6 +35,8 @@ DEMO_OBJ = \ src/demo/bridge.o \ src/demo/sailboat.o \ src/demo/collision.o \ + src/demo/lizard/main.o \ + src/demo/lizard/world.o \ src/physics/particle.o \ src/physics/particle_link.o \ src/physics/particle_contact.o \ @@ -31,4 +45,16 @@ DEMO_OBJ = \ src/physics/collide.o demo.elf: LDSCRIPT = $(LIB)/main.lds -demo.elf: $(START_OBJ) $(DEMO_OBJ) $(FONT_OBJ) $(LIBGCC) +demo.elf: $(START_OBJ) $(DEMO_OBJ) $(FONT_OBJ) $(TEXTURE_OBJ) $(LIBGCC) + +%_128.png: %.png + python tools/canvas_size.py $< 128 32 $@ + +texture/igh25_box_%.data: texture/igh25_box_%.png + python ../model_generator/color_convert.py $< rgb565 twiddled non_mipmapped $@ + +texture/walking/%.data: texture/walking/%.png + python ../model_generator/color_convert.py $< argb4444 twiddled non_mipmapped $@ + +font/ter_u12n.data: + $(LIB)/tools/ttf_bitmap2 20 7f 128 64 /usr/share/fonts/terminus/ter-u12n.otb $@ > /dev/null diff --git a/font/ter_u12n.data b/font/ter_u12n.data deleted file mode 100644 index 1d01af88d40ae8cb9d24618c92d08200838cd781..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4096 zcmc(hfpXj+3`Ea=aQ^?F?Y>en zrMDD3)s}GhvIy37-EX1jxoQOOeg_R*+9eoGv?NQZf-1WUU*^V$F@Pphv1M`TuffW< zFv`VBkzri&^09_axR&vPzcJO>Q6#Am?X5+JbzZmW&|N8@F~SFj%V8OzuJM_V@IiI@ z4jPGGP{t)3zGZ{5S_t1_XJ|acFTScXe%shS@sN1vvtI?e7iA*|KdkkBB7fN~)rLk~ z9Nm%y9A{g(EW5@vM8;;n(>}tXa?}o;k$e=xtNyhy}I|Jn!w;N8-ztp&Fv%+{Ch4oh-CZ+9{3j zZQJBF=VQgoD|cIJzWGWozu4}BmfwB*z= z`6dDy=HR3r=siL4C;}Q=OOGAi&gpS~XMJ)$L3Dm1Ct3e;ck4SIZl&zCV$4)=38lF2 z`Zb8rckdVH;2??HFY1n4A-tDUXC8Kr1#3GW?$5fvP!ShS9(^L5^(&4QjNDWGWZSWP zR1}C@rib-W3`VJYTY6l6%!;k(9BRJ{bg&Mj1LZNn5VmP#sd-N|g3j++w`A6{uSc8L zJ%*PY$g zx3u$(*E65CV{Yi!+x4s`Jf#UVA-qZK={8zJ_V_4?QWM?|>eGYTayni-9 zLf3WcY=UPy-kxiZbH8{kamLikgzx{Hee9waB0A79bH!Y>;%9A^M6!KssxG|e_a(kZ zi?3}7K_uSt-LgZu2jP+X5k}Fs?efyEFkktsM%VRgOO4cO#OW21==V`-(7p@ZzHMI+ zZ6vitB17?``HN`O;53?b$JMJN@c8|6c72`!?7jO4ITWd8_86Zh-Z1?yqEj6u;e5_U fZOJo#bsDF^53&vgUrYYN%h^e=u^~So{N3eWUQ;QM diff --git a/src/demo/bridge.cpp b/src/demo/bridge.cpp index 6a3f50d..4d40380 100644 --- a/src/demo/bridge.cpp +++ b/src/demo/bridge.cpp @@ -102,7 +102,7 @@ namespace demo { printf("en cables %d\n", en_cables); } - void bridge::analog(float dx) { + void bridge::analog(float dl, float dr, float dx, float dy) { interpolator.interp_add(dx * 0.5f); } diff --git a/src/demo/bridge.hpp b/src/demo/bridge.hpp index ecd03a5..294ddd1 100644 --- a/src/demo/bridge.hpp +++ b/src/demo/bridge.hpp @@ -25,7 +25,7 @@ namespace demo { void draw_weight(ta_parameter_writer& writer, const mat4x4& trans); void draw(ta_parameter_writer& writer, const mat4x4& trans) override; void a() override; - void analog(float dx) override; + void analog(float dl, float dr, float dx, float dy) override; static const inline int particles_length = 12; physics::particle particles[particles_length]; diff --git a/src/demo/lizard/levels.hpp b/src/demo/lizard/levels.hpp new file mode 100644 index 0000000..b94a1b9 --- /dev/null +++ b/src/demo/lizard/levels.hpp @@ -0,0 +1,28 @@ +#include "demo/lizard/world.hpp" + +namespace demo { + + world::platform level1_platforms[] = { + { + .position = vec3( 7.500, 0.000, 7.500), + .scale = vec3( 3.000, 1.000, 3.000), + }, + { + .position = vec3( 12.500, 0.000, 7.500), + .scale = vec3( 3.000, 1.000, 3.000), + }, + { + .position = vec3( 17.500, 0.000, 7.500), + .scale = vec3( 3.000, 1.000, 3.000), + }, + { + .position = vec3( 12.500, 0.000, 12.500), + .scale = vec3( 3.000, 1.000, 3.000), + }, + }; + world::level level1_level = { + .platforms = level1_platforms, + .platforms_length = (sizeof (level1_platforms)) / (sizeof (world::platform)), + }; + +} diff --git a/src/demo/lizard/main.cpp b/src/demo/lizard/main.cpp new file mode 100644 index 0000000..37f74e2 --- /dev/null +++ b/src/demo/lizard/main.cpp @@ -0,0 +1,228 @@ +#include "math/float_types.hpp" +#include "math/transform.hpp" + +#include "platform/graphics_primitive.hpp" +#include "platform/font.hpp" + +#include "demo/lizard/main.hpp" +#include "demo/lizard/levels.hpp" + +#include "texture/igh25_box_top_32.data.h" + +#include "assert.h" + +extern float alpha_mul; + +const int lizard_frames[] = { + texture::offset::walking_frame0000, + texture::offset::walking_frame0001, + texture::offset::walking_frame0002, + texture::offset::walking_frame0003, + texture::offset::walking_frame0004, + texture::offset::walking_frame0005, + texture::offset::walking_frame0006, +}; +const int lizard_frames_count = (sizeof (lizard_frames)) / (sizeof (lizard_frames[0])); +int last_drawn_frame; + +namespace demo { + static inline void print_mat4x4(const mat4x4& mat) + { + for (int i = 0; i < 4; i++) { + printf("%f %f %f %f\n", mat[i][0], mat[i][1], mat[i][2], mat[i][3]); + } + } + + mat4x4 lizard::init() + { + vx = 0; + vy = 0; + + current_level = &demo::level1_level; + + world::table_build(*current_level); + + lizard_position = {7.5, 1, 7.5}; + lizard_velocity = {0, 0, 0}; + + return view_trans; + } + + static float sign(float n) + { + if (n > 0) + return 1; + else + return -1; + } + + void lizard::update() + { + /* + if (!collided) + lizard_velocity.y -= 0.01; + */ + + if (abs(lizard_velocity.x) > 0.05) + lizard_velocity.x = 0.05 * sign(lizard_velocity.x); + if (abs(lizard_velocity.y) > 0.05) + lizard_velocity.y = 0.05 * sign(lizard_velocity.y); + if (abs(lizard_velocity.z) > 0.05) + lizard_velocity.z = 0.05 * sign(lizard_velocity.z); + + lizard_velocity.x *= 0.8; + lizard_velocity.y *= 0.8; + lizard_velocity.z *= 0.8; + + lizard_frame += magnitude(lizard_velocity) * 15; + + lizard_position.x += lizard_velocity.x; + lizard_position.y += lizard_velocity.y; + lizard_position.z += lizard_velocity.z; + + world::platform * p = lizard_collide(); + collided = p != nullptr; + + if (collided) { + lizard_position.y -= -lizard_velocity.y; + } + + view_trans + = translate(vec3(0, 0, 3)) + * rotate_x(vy) + * rotate_y(vx) + * translate(-lizard_position); + } + + void lizard::y() + { + lizard_velocity.y += 0.01; + } + + void lizard::a() + { + lizard_velocity.y -= 0.01; + } + + void lizard::x() + { + lizard_heading -= pi * (1.0f / 160); + } + + void lizard::b() + { + lizard_heading += pi * (1.0f / 160); + } + + void lizard::analog(float dl, float dr, float dx, float dy) + { + //float forward = (dr - dl) * -0.001f; + //alpha_mul += forward; + float forward = (dr - dl) * -0.04f; + + lizard_velocity.x += -cos(lizard_heading) * forward; + lizard_velocity.z += sin(lizard_heading) * forward; + + vy += dy * 0.03f; + vx += dx * 0.03f; + } + + world::platform * lizard::lizard_collide() + { + world::platform * p = world::table_lookup(lizard_position.x, lizard_position.z); + if (p == nullptr) + return nullptr; + + float ym = lizard_position.y - 0.5; + float yp = lizard_position.y + 0.5; + + float pm = p->position.y - p->scale.y * 0.5; + float pp = p->position.y + p->scale.y * 0.5; + + if (ym < pp && yp > pm) + return p; + else + return nullptr; + } + + void lizard::draw_hud(ta_parameter_writer& writer) + { + const int title_length = 8; + const int title_width_2 = (font::ter_u12n.hori_advance * title_length) >> 1; + const int framebuffer_width_2 = framebuffer::framebuffer.px_width >> 1; + const int x = framebuffer_width_2 - title_width_2; + vec3 center_p = vec3(x, 5, 10); + + font::ter_u12n.global(writer); + font::ter_u12n.draw_string(writer, center_p, "platform", 0xffffffff); + + vec3 status_p = vec3(10, 10, 10); + /* + if (collided) + font::ter_u12n.draw_string(writer, status_p, "collide", 0xffffffff); + else + font::ter_u12n.draw_string(writer, status_p, "air", 0xffffffff); + */ + + font::ter_u12n.draw_float(writer, status_p, (float)last_drawn_frame, 0xffffffff, 10); + } + + void lizard::draw_platform(ta_parameter_writer& writer, const mat4x4& trans, const world::platform& p) + { + mat4x4 t + = trans + * translate(p.position) + * scale(p.scale); + + draw_textured_cube(writer, + t, + p.scale, + texture::cube_type_1); + } + + void lizard::draw_lizard(ta_parameter_writer& writer, const mat4x4& trans) + { + mat4x4 t + = trans + * translate(lizard_position) + * rotate_y(lizard_heading); + + /* + draw_icosphere(writer, + t, + vec3(1, 0.5, 0)); + */ + int frame = ((int)lizard_frame) % lizard_frames_count; + if (frame < 0) + frame = lizard_frames_count + frame; + last_drawn_frame = frame; + + draw_textured_voxel(writer, + t, + lizard_frames[frame]); + } + + void lizard::draw(ta_parameter_writer& writer, const mat4x4& _) + { + // punch through + const mat4x4& trans = view_trans; + + draw_hud(writer); + + draw_lizard(writer, trans); + + writer.append() = + ta_global_parameter::end_of_list(para_control::para_type::end_of_list); + + // opaque + + //draw_axis(writer, trans * translate(lizard_position)); + + for (int i = 0; i < current_level->platforms_length; i++) { + draw_platform(writer, trans, current_level->platforms[i]); + } + + writer.append() = + ta_global_parameter::end_of_list(para_control::para_type::end_of_list); + } +} diff --git a/src/demo/lizard/main.hpp b/src/demo/lizard/main.hpp new file mode 100644 index 0000000..7f58461 --- /dev/null +++ b/src/demo/lizard/main.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include "demo/scene.hpp" +#include "demo/lizard/world.hpp" + +namespace demo { + + struct lizard : scene { + world::level * current_level; + vec3 lizard_position; + vec3 lizard_velocity; + float lizard_heading; + float lizard_frame; + + bool collided; + + mat4x4 view_trans; + + float vx; + float vy; + + mat4x4 init() override; + + void update() override; + + void y() override; + void x() override; + void b() override; + void a() override; + + void analog(float dl, float dr, float dx, float dy) override; + + world::platform * lizard_collide(); + + void draw_hud(ta_parameter_writer& writer); + void draw_platform(ta_parameter_writer& writer, const mat4x4& trans, const world::platform& p); + void draw_lizard(ta_parameter_writer& writer, const mat4x4& trans); + void draw(ta_parameter_writer& writer, const mat4x4& trans) override; + }; +} diff --git a/src/demo/lizard/maps/level1.png b/src/demo/lizard/maps/level1.png new file mode 100644 index 0000000000000000000000000000000000000000..c45f5634f834cb84e2ba668a20f356d98f9fc7a1 GIT binary patch literal 631 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1SEZ8zRh7^U~I{Bb`J1#c2+1T%1_J8No8Qr zm{>c}*5j~)%+dJZrAnfX)+;PhRy;}&7cE>9s^QccpuOc)Leb0i3riF|3kyYJxcTaI z!enFSl$I8VvK-_WC_m_V(belud{BnqG zZE=E!6n+UDnQ=xZIc!qU2if@V93Q^w9ozip{9nteD|?PMGn0_sp32MW(PNLTB5?OUKrvWE}}U5*T_}GyX)? znxcD;)=XW!rqci4p@O*hxJOoJ6IC`gxOxaIT+qckB~jUJwO?1O$y@cBKhEpom8Ltb z<25KcvzUo@(`)ws&G+v{wVveE*PO#(6)*EVnT6vmQ}3+DHS*Sek6AeEn8T}1$FF2I zp1SEovEz zu7ti~v#?-s>z=ar+2?obzTNw0d-=_K_KxjE>(wMaZ2(3KXMsm#F$061G6*wPEVVBK z3bL1Y`ns~eWS0_Rlu24VQ4lC3S>hT|;+&tGo0?a`;9QiNSdyBeP@Y+mq2TW68xY>e zCk|AU=;`7ZQgQ3;RYf5N1r8R6FHi06p0SAFVJj0B*jWHHMz;6!mQMxol_q-~7#f81 iGGk>GfZB)!4<_?2pTxplzGUB8kQPr@KbLh*2~7ah5$%Kk literal 0 HcmV?d00001 diff --git a/src/demo/lizard/world.cpp b/src/demo/lizard/world.cpp new file mode 100644 index 0000000..30ba1dc --- /dev/null +++ b/src/demo/lizard/world.cpp @@ -0,0 +1,109 @@ +#include + +#include "demo/lizard/world.hpp" +#include "assert.h" + +namespace demo::world { + + struct min_max { + int x_min; + int x_max; + int z_min; + int z_max; + }; + + static platform_lookup lookup; + + static inline void clear_table() + { + for (int i = 0; i < lookup_table_dim * lookup_table_dim; i++) { + lookup.table[i] = nullptr; + } + } + + static inline bool float_equal_int(float f) + { + int i = (int)f; + float fi = (float)i; + return fi == f; + } + + static inline min_max calculate_platforms_area(const level& level) + { + float x_min = std::numeric_limits::max(); + float x_max = std::numeric_limits::min(); + + float z_min = std::numeric_limits::max(); + float z_max = std::numeric_limits::min(); + + for (int i = 0; i < level.platforms_length; i++) { + const vec3& position = level.platforms[i].position; + float scale_x_2 = level.platforms[i].scale.x * 0.5; + float scale_z_2 = level.platforms[i].scale.z * 0.5; + + if (position.x - scale_x_2 < x_min) + x_min = position.x - scale_x_2; + if (position.x + scale_x_2 > x_max) + x_max = position.x + scale_x_2; + if (position.z - scale_z_2 < z_min) + z_min = position.z - scale_z_2; + if (position.z + scale_z_2 > z_max) + z_max = position.z + scale_z_2; + } + + assert(float_equal_int(x_min)); + assert(float_equal_int(x_max)); + assert(float_equal_int(z_min)); + assert(float_equal_int(z_max)); + + return { + (int)x_min, + (int)x_max, + (int)z_min, + (int)z_max, + }; + } + + void table_build(const level& level) + { + clear_table(); + min_max mm = calculate_platforms_area(level); + + lookup.xz_offset = vec2i(mm.x_min, mm.z_min); + lookup.size = vec2i(mm.x_max - mm.x_min, + mm.z_max - mm.z_min); + + for (int i = 0; i < level.platforms_length; i++) { + const vec3& position = level.platforms[i].position; + int scale_x = (int)level.platforms[i].scale.x; + int scale_z = (int)level.platforms[i].scale.z; + float scale_x_2 = level.platforms[i].scale.x * 0.5; + float scale_z_2 = level.platforms[i].scale.z * 0.5; + + for (int xo = 0; xo < scale_x; xo++) { + for (int zo = 0; zo < scale_z; zo++) { + int x = xo + (int)(position.x - scale_x_2) - mm.x_min; + int z = zo + (int)(position.z - scale_z_2) - mm.z_min; + assert(x >= 0); + assert(z >= 0); + assert(x < lookup.size.x); + assert(z < lookup.size.y); + + lookup.table[z * lookup.size.x + x] = &level.platforms[i]; + } + } + } + } + + platform * table_lookup(float x, float z) + { + int xi = ((int)x) - lookup.xz_offset.x; + int zi = ((int)z) - lookup.xz_offset.y; + + if (xi < 0 || zi < 0 || xi >= lookup.size.x || zi >= lookup.size.y) { + return nullptr; + } + + return lookup.table[zi * lookup.size.x + xi]; + } +} diff --git a/src/demo/lizard/world.hpp b/src/demo/lizard/world.hpp new file mode 100644 index 0000000..c661e7a --- /dev/null +++ b/src/demo/lizard/world.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include "math/float_types.hpp" + +namespace demo::world { + + using vec2i = vec<2, int>; + + struct platform { + vec3 position; + vec3 scale; + }; + + struct level { + platform * platforms; + int platforms_length; + }; + + constexpr int lookup_table_dim = 128; + + struct platform_lookup { + vec2i xz_offset; + vec2i size; + platform * table[lookup_table_dim * lookup_table_dim]; + }; + + void table_build(const level& level); + platform * table_lookup(float x, float z); +} diff --git a/src/demo/scene.hpp b/src/demo/scene.hpp index 968745a..1e1c53d 100644 --- a/src/demo/scene.hpp +++ b/src/demo/scene.hpp @@ -7,11 +7,15 @@ namespace demo { struct scene { virtual mat4x4 init() = 0; - virtual void analog(float dx) {} + virtual void analog(float dl, float dr, float dx, float dy) {} virtual void a() {} virtual void b() {} virtual void x() {} virtual void y() {} + virtual void ra() {} + virtual void la() {} + virtual void da() {} + virtual void ua() {} virtual void update() = 0; virtual void draw(ta_parameter_writer& writer, const mat4x4& trans) = 0; }; diff --git a/src/platform/font.cpp b/src/platform/font.cpp index 655c19e..c56c57d 100644 --- a/src/platform/font.cpp +++ b/src/platform/font.cpp @@ -83,10 +83,10 @@ namespace font { int32_t whole = num; offset += unparse_base10_unsigned(&s[offset], whole, 0, 0); s[offset++] = '.'; - int32_t fraction = (int32_t)((num - (float)whole) * 1000.0); + int32_t fraction = (int32_t)((num - (float)whole) * 1000000000.0); if (fraction < 0) fraction = -fraction; - offset += unparse_base10_unsigned(&s[offset], fraction, 3, '0'); + offset += unparse_base10_unsigned(&s[offset], fraction, 9, '0'); return offset; } diff --git a/src/platform/graphics.cpp b/src/platform/graphics.cpp index 757413f..92dd19e 100644 --- a/src/platform/graphics.cpp +++ b/src/platform/graphics.cpp @@ -27,6 +27,7 @@ #include "demo/bridge.hpp" #include "demo/sailboat.hpp" #include "demo/collision.hpp" +#include "demo/lizard/main.hpp" #include "maple/maple_bus_bits.hpp" @@ -94,14 +95,19 @@ namespace graphics { } } + /* demo::ballistics _ballistics; demo::bridge _bridge; demo::sailboat _sailboat; demo::collision _collision; - demo::scene * current_scene = &_collision; + */ + demo::lizard _lizard; + demo::scene * current_scene = &_lizard; void draw() { + holly.PT_ALPHA_REF = 15; + current_scene->draw(writer, view_trans * scale(0.05f)); } @@ -172,25 +178,39 @@ namespace graphics { auto& data = data_fields.data; - float dx = static_cast(data.analog_coordinate_axis[2] - 0x80) * 0.001; - float dy = static_cast(data.analog_coordinate_axis[3] - 0x80) * 0.001; + float dl = static_cast(data.analog_coordinate_axis[0]) * (1.f / 255.f); + float dr = static_cast(data.analog_coordinate_axis[1]) * (1.f / 255.f); + float dx = static_cast(data.analog_coordinate_axis[2] - 0x80) * (1.f / 128.f); + float dy = static_cast(data.analog_coordinate_axis[3] - 0x80) * (1.f / 128.f); bool a = ft0::data_transfer::digital_button::a(data.digital_button) == 0; bool b = ft0::data_transfer::digital_button::b(data.digital_button) == 0; bool x = ft0::data_transfer::digital_button::x(data.digital_button) == 0; bool y = ft0::data_transfer::digital_button::y(data.digital_button) == 0; - if (last[port_ix].a == 0 && a) current_scene->a(); - if (last[port_ix].b == 0 && b) current_scene->b(); - if (last[port_ix].x == 0 && x) current_scene->x(); - if (last[port_ix].y == 0 && y) current_scene->y(); + + bool ra = ft0::data_transfer::digital_button::ra(data.digital_button) == 0; + bool la = ft0::data_transfer::digital_button::la(data.digital_button) == 0; + bool da = ft0::data_transfer::digital_button::da(data.digital_button) == 0; + bool ua = ft0::data_transfer::digital_button::ua(data.digital_button) == 0; + + if (a) current_scene->a(); + if (b) current_scene->b(); + if (x) current_scene->x(); + if (y) current_scene->y(); + + if (ra) current_scene->ra(); + if (la) current_scene->la(); + if (da) current_scene->da(); + if (ua) current_scene->ua(); + last[port_ix].a = a; last[port_ix].b = b; last[port_ix].x = x; last[port_ix].y = y; - current_scene->analog(dx); + current_scene->analog(dl, dr, dx, dy); - view_trans = view_trans * rotate_y(dy);// * rotate_x(dx); + //view_trans = rotate_y(dy) * view_trans;// * rotate_x(dx); } } } diff --git a/src/platform/graphics_primitive.cpp b/src/platform/graphics_primitive.cpp index 9777da4..ed95d28 100644 --- a/src/platform/graphics_primitive.cpp +++ b/src/platform/graphics_primitive.cpp @@ -154,7 +154,7 @@ void draw_icosphere(ta_parameter_writer& writer, const vec3& ap = position_cache[tris[i].a]; const vec3& bp = position_cache[tris[i].b]; const vec3& cp = position_cache[tris[i].c]; - const float& intensity = _intensity(trans, normal[tris[i].n]); + const float intensity = _intensity(trans, normal[tris[i].n]); tri_type_2(writer, ap, @@ -261,3 +261,289 @@ void draw_halfspace(ta_parameter_writer& writer, dp, 1.0f); } + +void draw_textured_cube(ta_parameter_writer& writer, + const mat4x4& trans, + const vec3& scale, + const texture::cube_texture_offsets& offsets) +{ + static const vec3 position[] = { + {-0.5, -0.5, 0.5}, + {-0.5, 0.5, 0.5}, + {-0.5, -0.5, -0.5}, + {-0.5, 0.5, -0.5}, + { 0.5, -0.5, 0.5}, + { 0.5, 0.5, 0.5}, + { 0.5, -0.5, -0.5}, + { 0.5, 0.5, -0.5}, + }; + static const vec3 normal[] = { + {-1.0, -0.0, -0.0}, + {-0.0, -0.0, -1.0}, + { 1.0, -0.0, -0.0}, + {-0.0, -0.0, 1.0}, + {-0.0, -1.0, -0.0}, + {-0.0, 1.0, -0.0}, + }; + static const vec2 texture[] = { + {0.0, 0.0}, + {1.0, 0.0}, + {1.0, 1.0}, + {0.0, 1.0}, + }; + const int position_length = (sizeof (position)) / (sizeof (position[0])); + + struct quad { + int a, b, c, d; + }; + + static const quad quads[] = { + {0, 1, 3, 2}, // front (z, y) + {2, 3, 7, 6}, // left (x, y) + {6, 7, 5, 4}, // rear (z, y) + {4, 5, 1, 0}, // right (x, y) + {2, 6, 4, 0}, // bottom (x, z) + {7, 3, 1, 5} // top (x, z) + }; + + const vec2 uv_scale[] = { + {scale.z, scale.y}, + {scale.x, scale.y}, + {scale.z, scale.y}, + {scale.x, scale.y}, + {scale.z, scale.x}, + {scale.z, scale.x}, + }; + + const int quads_length = (sizeof (quads)) / (sizeof (quads[0])); + + vec3 position_cache[position_length]; + for (int i = 0; i < position_length; i++) { + position_cache[i] = trans * position[i]; + } + + int texture_uv_size + = tsp_instruction_word::texture_shading_instruction::decal + | tsp_instruction_word::src_alpha_instr::one + | tsp_instruction_word::dst_alpha_instr::zero + | tsp_instruction_word::texture_u_size::from_int(32) + | tsp_instruction_word::texture_v_size::from_int(32); + + int pixel_format + = texture_control_word::pixel_format::_565; + + const vec4 color = {0, 0, 0, 0}; + + global_polygon_textured_intensity(writer, + color, + para_control::list_type::opaque, + offsets.side, + texture_uv_size, + pixel_format); + + for (int i = 0; i < quads_length; i++) { + if (i == 4) + global_polygon_textured_intensity(writer, + color, + para_control::list_type::opaque, + offsets.bottom, + texture_uv_size, + pixel_format); + if (i == 5) + global_polygon_textured_intensity(writer, + color, + para_control::list_type::opaque, + offsets.top, + texture_uv_size, + pixel_format); + + const vec3& ap = position_cache[quads[i].a]; + const vec3& bp = position_cache[quads[i].b]; + const vec3& cp = position_cache[quads[i].c]; + const vec3& dp = position_cache[quads[i].d]; + + const vec2& at = texture[3] * uv_scale[i]; + const vec2& bt = texture[0] * uv_scale[i]; + const vec2& ct = texture[1] * uv_scale[i]; + const vec2& dt = texture[2] * uv_scale[i]; + + const float base_intensity = _intensity(trans, normal[i]); + + quad_type_7_maybe_clip(writer, + ap, at, + bp, bt, + cp, ct, + dp, dt, + base_intensity); + } +} + +constexpr inline float pow(float x, int n) +{ + for (int i = 0; i < n; i++) + x *= x; + + return x; +} + +float alpha_mul = 0.9; + +void draw_textured_voxel(ta_parameter_writer& writer, + const mat4x4& trans, + int texture_offset) +{ + static const vec3 position[] = { + {-0.5, 0.5, 0.0}, + { 0.5, 0.5, 0.0}, + { 0.5, -0.5, 0.0}, + {-0.5, -0.5, 0.0}, + }; + static const vec2 texture[] = { + {0.0, 0.0}, + {1.0, 0.0}, + {1.0, 1.0}, + {0.0, 1.0}, + }; + const int position_length = (sizeof (position)) / (sizeof (position[0])); + + const vec3 pos_scale = {96 / 32, 1.0f, 1.0f}; + const vec2 uv_scale = {96.0f / 128.0f, 1.0}; + + vec3 position_cache[position_length]; + for (int i = 0; i < position_length; i++) { + position_cache[i] = trans * (position[i] * pos_scale); + } + + int texture_uv_size + = tsp_instruction_word::texture_shading_instruction::modulate_alpha + | tsp_instruction_word::src_alpha_instr::src_alpha + | tsp_instruction_word::dst_alpha_instr::inverse_src_alpha + | tsp_instruction_word::texture_u_size::from_int(128) + | tsp_instruction_word::texture_v_size::from_int(32) + | tsp_instruction_word::use_alpha; + + int pixel_format + = texture_control_word::pixel_format::_4444; + + const float table[] = { + 0.063, + 0.063, + 0.063, + 0.074, + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.090, + 0.090, + 0.090, + 0.100, + 0.100, + 0.100, + 0.111, + 0.111, + 0.111, + 0.129, + 0.129, + 0.129, + 0.148, + 0.148, + 0.148, + 0.180, + 0.180, + 0.180, + 0.440, // green + 0.440, // green + 0.440, // green + 0.881, // yellow + 1.0, + 1.0, + 1.0, + 0.881, // yellow + 0.440, // green + 0.440, // green + 0.440, // green + 0.180, + 0.180, + 0.180, + 0.148, + 0.148, + 0.148, + 0.129, + 0.129, + 0.129, + 0.111, + 0.111, + 0.111, + 0.100, + 0.100, + 0.100, + 0.090, + 0.090, + 0.090, + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.084, // purple + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.077, // after purple + 0.074, + 0.063, + 0.063, + 0.063, + }; + const int table_length = (sizeof (table)) / (sizeof (table[0])); + + constexpr int num_quads = table_length; + constexpr int half_quads = (num_quads - 1) / 2; + constexpr float inverse_half_quads = 1.0f / (float)half_quads; + + + for (int i = 0; i < num_quads; i++) { + float z = (float)(i - half_quads) * inverse_half_quads; + float s = sin(z * pi * 0.5f + pi * 0.5f); + //printf("%f\n", s); + //float a = pow(s, 5); + float a = table[i]; + //float a = alpha_mul; + vec4 color = {1, 1, 1, a}; + + global_polygon_textured_intensity(writer, + color, + para_control::list_type::punch_through, + texture_offset, + texture_uv_size, + pixel_format); + + vec3 z_trans = {0, 0, z * 0.35f}; + const vec3& ap = trans * (position[0] * pos_scale + z_trans); + const vec3& bp = trans * (position[1] * pos_scale + z_trans); + const vec3& cp = trans * (position[2] * pos_scale + z_trans); + const vec3& dp = trans * (position[3] * pos_scale + z_trans); + + const vec2& at = texture[0] * uv_scale; + const vec2& bt = texture[1] * uv_scale; + const vec2& ct = texture[2] * uv_scale; + const vec2& dt = texture[3] * uv_scale; + + //const float base_intensity = _intensity(trans, normal[i]); + const float base_intensity = 1.0f; + + quad_type_7_maybe_clip(writer, + ap, at, + bp, bt, + cp, ct, + dp, dt, + base_intensity); + } +} diff --git a/src/platform/graphics_primitive.hpp b/src/platform/graphics_primitive.hpp index 7946d35..c315080 100644 --- a/src/platform/graphics_primitive.hpp +++ b/src/platform/graphics_primitive.hpp @@ -1,10 +1,9 @@ #include "math/math.hpp" -#include "holly/framebuffer.hpp" #include "platform/ta_parameter_presets.hpp" +#include "platform/texture.hpp" #define _fsrra(n) (1.0f / (sqrt(n))) - static inline void draw_line(ta_parameter_writer& writer, const vec3& p1, const vec3& p2) @@ -28,17 +27,7 @@ static inline void draw_line(ta_parameter_writer& writer, dp, intensity); } - -static inline vec3 screen_transform(const vec3& v) -{ - float tx = framebuffer::framebuffer.px_width / 2.f; - float ty = framebuffer::framebuffer.px_height / 2.f; - float s = framebuffer::framebuffer.px_height / 2.f; - - float z = _fsrra(v.z); - float z2 = z * z; - return {(v.x) * s * z2 + tx , (v.y) * s * z2 + ty , z2}; -} +#undef _fsrra static inline void draw_grid(ta_parameter_writer& writer, const mat4x4& trans) @@ -91,6 +80,11 @@ void draw_cube(ta_parameter_writer& writer, const mat4x4& trans, const vec3& color); +void draw_textured_cube(ta_parameter_writer& writer, + const mat4x4& trans, + const vec3& scale, + const texture::cube_texture_offsets& offsets); + void draw_icosphere(ta_parameter_writer& writer, const mat4x4& trans, const vec3& color); @@ -106,3 +100,7 @@ void draw_halfspace(ta_parameter_writer& writer, const vec3& n, const mat4x4& trans, const vec3& color); + +void draw_textured_voxel(ta_parameter_writer& writer, + const mat4x4& trans, + int texture_offset); diff --git a/src/platform/ta_parameter_presets.hpp b/src/platform/ta_parameter_presets.hpp index 6ce92c4..d42d3d6 100644 --- a/src/platform/ta_parameter_presets.hpp +++ b/src/platform/ta_parameter_presets.hpp @@ -5,7 +5,9 @@ #include "holly/ta_global_parameter.hpp" #include "holly/isp_tsp.hpp" #include "holly/texture_memory_alloc9.hpp" +#include "holly/framebuffer.hpp" +#include "math/geometry.hpp" #include "math/float_types.hpp" static inline void global_polygon_intensity(ta_parameter_writer& writer, @@ -35,6 +37,38 @@ static inline void global_polygon_intensity(ta_parameter_writer& writer, 1.0f, color.x, color.y, color.z); } +static inline void global_polygon_textured_intensity(ta_parameter_writer& writer, + const vec4& color, + int list_type, + int texture_offset, + int texture_uv_size, + int pixel_format) +{ + const uint32_t parameter_control_word = para_control::para_type::polygon_or_modifier_volume + | list_type + | obj_control::col_type::intensity_mode_1 + | obj_control::texture + ; + + const uint32_t isp_tsp_instruction_word = isp_tsp_instruction_word::depth_compare_mode::greater_or_equal + | isp_tsp_instruction_word::culling_mode::no_culling;//cull_if_positive; + + const uint32_t tsp_instruction_word = tsp_instruction_word::fog_control::no_fog + | texture_uv_size; + + const uint32_t texture_address = texture_memory_alloc.texture.start + texture_offset; + const uint32_t texture_control_word = pixel_format + | texture_control_word::scan_order::twiddled + | texture_control_word::texture_address(texture_address / 8); + + writer.append() = + ta_global_parameter::polygon_type_1(parameter_control_word, + isp_tsp_instruction_word, + tsp_instruction_word, + texture_control_word, + color.w, color.x, color.y, color.z); +} + static inline void global_polygon_textured(ta_parameter_writer& writer, uint32_t list_type, uint32_t texture_offset, @@ -151,3 +185,156 @@ static inline void quad_type_3(ta_parameter_writer& writer, ct.x, ct.y, base_color, 0); } + +static inline void quad_type_7(ta_parameter_writer& writer, + const vec3& ap, const vec2& at, + const vec3& bp, const vec2& bt, + const vec3& cp, const vec2& ct, + const vec3& dp, const vec2& dt, + float base_intensity) +{ + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(false), + ap.x, ap.y, ap.z, + at.x, at.y, + base_intensity, 0); + + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(false), + bp.x, bp.y, bp.z, + bt.x, bt.y, + base_intensity, 0); + + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(false), + dp.x, dp.y, dp.z, + dt.x, dt.y, + base_intensity, 0); + + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(true), + cp.x, cp.y, cp.z, + ct.x, ct.y, + base_intensity, 0); +} + +static inline void tri_type_7(ta_parameter_writer& writer, + const vec3& ap, const vec2& at, + const vec3& bp, const vec2& bt, + const vec3& cp, const vec2& ct, + float base_intensity) +{ + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(false), + ap.x, ap.y, ap.z, + at.x, at.y, + base_intensity, 0); + + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(false), + bp.x, bp.y, bp.z, + bt.x, bt.y, + base_intensity, 0); + + writer.append() = + ta_vertex_parameter::polygon_type_7(polygon_vertex_parameter_control_word(true), + cp.x, cp.y, cp.z, + ct.x, ct.y, + base_intensity, 0); +} + +#define _fsrra(n) (1.0f / (sqrt(n))) +static inline vec3 screen_transform(const vec3& v) +{ + float tx = framebuffer::framebuffer.px_width / 2.f; + float ty = framebuffer::framebuffer.px_height / 2.f; + float s = framebuffer::framebuffer.px_height / 2.f; + + float z = _fsrra(v.z); + float z2 = z * z; + return {(-v.x) * s * z2 + tx , (-v.y) * s * z2 + ty , z2}; +} +#undef _fsrra + +static inline void tri_type_7_clip(ta_parameter_writer& writer, + const vec3& ap, const vec2& at, + const vec3& bp, const vec2& bt, + const vec3& cp, const vec2& ct, + float base_intensity) +{ + const vec3 plane_point = {0.f, 0.f, 0.5f}; + const vec3 plane_normal = {0.f, 0.f, 1.f}; + + vec3 preclip_position[] = {ap, bp, cp}; + vec2 preclip_texture[] = {at, bt, ct}; + + vec3 clip_position[4]; + vec2 clip_texture[4]; + + int output_length = geometry::clip_polygon_2<3>(clip_position, + clip_texture , + plane_point, + plane_normal, + preclip_position, + preclip_texture); + + { + vec3 ap = screen_transform(clip_position[0]); + vec3 bp = screen_transform(clip_position[1]); + vec3 cp = screen_transform(clip_position[2]); + + const vec2& at = clip_texture[0]; + const vec2& bt = clip_texture[1]; + const vec2& ct = clip_texture[2]; + + if (output_length >= 4) { + vec3 dp = screen_transform(clip_position[3]); + const vec2& dt = clip_texture[3]; + quad_type_7(writer, + ap, at, + bp, bt, + cp, ct, + dp, dt, + base_intensity); + } else { + tri_type_7(writer, + ap, at, + bp, bt, + cp, ct, + base_intensity); + } + } +} + +static inline void quad_type_7_maybe_clip(ta_parameter_writer& writer, + const vec3& ap, const vec2& at, + const vec3& bp, const vec2& bt, + const vec3& cp, const vec2& ct, + const vec3& dp, const vec2& dt, + float base_intensity) +{ + if (ap.z < 0 && bp.z < 0 && cp.z < 0 && dp.z < 0) { + return; + } + + if (ap.z < 0 || bp.z < 0 || cp.z < 0 || dp.z < 0) { + tri_type_7_clip(writer, + ap, at, + bp, bt, + cp, ct, + base_intensity); + + tri_type_7_clip(writer, + ap, at, + cp, ct, + dp, dt, + base_intensity); + } else { + quad_type_7(writer, + screen_transform(ap), at, + screen_transform(bp), bt, + screen_transform(cp), ct, + screen_transform(dp), dt, + base_intensity); + } +} diff --git a/src/platform/texture.cpp b/src/platform/texture.cpp index 200f7af..0dd91d8 100644 --- a/src/platform/texture.cpp +++ b/src/platform/texture.cpp @@ -8,6 +8,16 @@ #include "holly/ta_fifo_texture_memory_transfer.hpp" #include "font/ter_u12n.data.h" +#include "texture/igh25_box_top_32.data.h" +#include "texture/igh25_box_bottom_32.data.h" +#include "texture/igh25_box_side_32.data.h" +#include "texture/walking/frame0000_128.data.h" +#include "texture/walking/frame0001_128.data.h" +#include "texture/walking/frame0002_128.data.h" +#include "texture/walking/frame0003_128.data.h" +#include "texture/walking/frame0004_128.data.h" +#include "texture/walking/frame0005_128.data.h" +#include "texture/walking/frame0006_128.data.h" namespace texture { struct entry { @@ -22,6 +32,56 @@ namespace texture { .size = reinterpret_cast(&_binary_font_ter_u12n_data_size), .offset = offset::ter_u12n, }, + { + .start = reinterpret_cast(&_binary_texture_igh25_box_top_32_data_start), + .size = reinterpret_cast(&_binary_texture_igh25_box_top_32_data_size), + .offset = offset::igh25_box_top_32, + }, + { + .start = reinterpret_cast(&_binary_texture_igh25_box_bottom_32_data_start), + .size = reinterpret_cast(&_binary_texture_igh25_box_bottom_32_data_size), + .offset = offset::igh25_box_bottom_32, + }, + { + .start = reinterpret_cast(&_binary_texture_igh25_box_side_32_data_start), + .size = reinterpret_cast(&_binary_texture_igh25_box_side_32_data_size), + .offset = offset::igh25_box_side_32, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0000_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0000_128_data_size), + .offset = offset::walking_frame0000, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0001_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0001_128_data_size), + .offset = offset::walking_frame0001, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0002_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0002_128_data_size), + .offset = offset::walking_frame0002, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0003_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0003_128_data_size), + .offset = offset::walking_frame0003, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0004_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0004_128_data_size), + .offset = offset::walking_frame0004, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0005_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0005_128_data_size), + .offset = offset::walking_frame0005, + }, + { + .start = reinterpret_cast(&_binary_texture_walking_frame0006_128_data_start), + .size = reinterpret_cast(&_binary_texture_walking_frame0006_128_data_size), + .offset = offset::walking_frame0006, + }, }; const int textures_length = (sizeof (textures)) / (sizeof (textures[0])); diff --git a/src/platform/texture.hpp b/src/platform/texture.hpp index b250367..c6576c5 100644 --- a/src/platform/texture.hpp +++ b/src/platform/texture.hpp @@ -1,7 +1,31 @@ +#pragma once + namespace texture { namespace offset { constexpr int ter_u12n = 0; + constexpr int igh25_box_top_32 = ter_u12n + 4096; + constexpr int igh25_box_bottom_32 = igh25_box_top_32 + 2048; + constexpr int igh25_box_side_32 = igh25_box_bottom_32 + 2048; + constexpr int walking_frame0000 = igh25_box_side_32 + 2048; + constexpr int walking_frame0001 = walking_frame0000 + 8192; + constexpr int walking_frame0002 = walking_frame0001 + 8192; + constexpr int walking_frame0003 = walking_frame0002 + 8192; + constexpr int walking_frame0004 = walking_frame0003 + 8192; + constexpr int walking_frame0005 = walking_frame0004 + 8192; + constexpr int walking_frame0006 = walking_frame0005 + 8192; } + struct cube_texture_offsets { + const int top; + const int bottom; + const int side; + }; + + constexpr cube_texture_offsets cube_type_1 = { + offset::igh25_box_top_32, + offset::igh25_box_bottom_32, + offset::igh25_box_side_32, + }; + void init(); } diff --git a/texture/igh25_box_bottom_32.data.h b/texture/igh25_box_bottom_32.data.h new file mode 100644 index 0000000..929d6af --- /dev/null +++ b/texture/igh25_box_bottom_32.data.h @@ -0,0 +1,15 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_igh25_box_bottom_32_data_start __asm("_binary_texture_igh25_box_bottom_32_data_start"); +extern uint32_t _binary_texture_igh25_box_bottom_32_data_end __asm("_binary_texture_igh25_box_bottom_32_data_end"); +extern uint32_t _binary_texture_igh25_box_bottom_32_data_size __asm("_binary_texture_igh25_box_bottom_32_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/igh25_box_bottom_32.png b/texture/igh25_box_bottom_32.png new file mode 100644 index 0000000000000000000000000000000000000000..65739fc0b77157b4a2837d749baec6d56b13788f GIT binary patch literal 9659 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 xkdHbK1b&- + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_igh25_box_side_32_data_start __asm("_binary_texture_igh25_box_side_32_data_start"); +extern uint32_t _binary_texture_igh25_box_side_32_data_end __asm("_binary_texture_igh25_box_side_32_data_end"); +extern uint32_t _binary_texture_igh25_box_side_32_data_size __asm("_binary_texture_igh25_box_side_32_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/igh25_box_side_32.png b/texture/igh25_box_side_32.png new file mode 100644 index 0000000000000000000000000000000000000000..25ac1940262ae056c7ae8743d80460a8b26ead19 GIT binary patch literal 10022 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 literal 0 HcmV?d00001 diff --git a/texture/igh25_box_top_32.data.h b/texture/igh25_box_top_32.data.h new file mode 100644 index 0000000..3445e26 --- /dev/null +++ b/texture/igh25_box_top_32.data.h @@ -0,0 +1,15 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_igh25_box_top_32_data_start __asm("_binary_texture_igh25_box_top_32_data_start"); +extern uint32_t _binary_texture_igh25_box_top_32_data_end __asm("_binary_texture_igh25_box_top_32_data_end"); +extern uint32_t _binary_texture_igh25_box_top_32_data_size __asm("_binary_texture_igh25_box_top_32_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/igh25_box_top_32.png b/texture/igh25_box_top_32.png new file mode 100644 index 0000000000000000000000000000000000000000..d4767fbece05215eaf5cb780133192f43b89edc7 GIT binary patch literal 9810 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 literal 0 HcmV?d00001 diff --git a/texture/walking/frame0000.png b/texture/walking/frame0000.png new file mode 100755 index 0000000000000000000000000000000000000000..906109d284dd5081123cffec56f03a68a28dbd5f GIT binary patch literal 2496 zcmV;x2|xCUP)irP@#0RNDw`gMuW2_@iQ#g4Kc4%pBF) zqJkqQO~KE^4(zB!EQlXyr=p+(!Hyh=u{aQg;s-6QP%+{_ss$U{w24jIB-gce&c3dD z-ns9+n_oR}a__rmpL6zJ`+Lt#z4kwAFTMUu4_N9ZTW{_A@Xt=!!@P}3TV-yidn^WB zJzn(i$FDxO_sN6rFUDrA)(pUtq`Pm!O|>&;FYtZ>Kwj)%o+&J9ZRakvjH&$^`Vipn z;%{6F*0k7+y43^t7|3o>OcNWy>hn2NoV1iu7F(3c>lYN@vwt1=tw!Nux30W8CbU~e zLr%PY05qwDm^TMsl~9%cs`PWgBc8L&AAI%s+q-@oJGX+rU5F3{=Dd#zp#TTo1ZbB4+bE|g277W0#DF47|8!A z;N+2``{_9uO8wm&%X0w354*Q{#6k-_Wr-ZmpT_W>&JLh6}o9*{8M zR!*?01boyX2g8v!Dum<9(SJv04!MT#GfwcG z2wbc9o(7l#yb1y?UeR0=4|mHamL7_x;RRO!IDgN;+L*ry;v ztN>%4i+2cqL3l8@C#pC~!4Dv>3=1e922ObH<0+7hCZ&YPt0*`tyk(+j?zaZL0a^#< zN>CWreFFWv0R9;Xmpq`lDAkV}1wDa^s3QSq0H0GmQKx_(B?0N;7qMJWdGX=tq&_eF z=0IT3tX@jIEd&Rh?nwYB@LF~}vnxRfUAG`mq-FQ<6kV>Iu#YK&-7TM9gU;k`3LxN# zs{^zgwA`EP+S*6I|MoRrL*ixf_4lNPDCGvOi7>=)(?w8ulq0QR@px|Fvo+-aJ~Yeh zs|~`nhous-V*pV~({Zs@5V$w+L!--g1*?otUkL~qjG3GP5RE8=aJd`9nzSy4t~EmA ziBajyz-alQ%4-BKh|j<@y!jrq(09Xr`XaU)0DG0gc?>gkD5udsFzZbTB{aoJM40`g zHP;Vu_!MsWE?{{8on_f@**OaVmp9Wq<^yOCJG5Yeq9xhg-0$-ARBdIKZT(XaFjh=n zoh6jODLG&cE}q#rmILnh6|P>kb2c`tRU_th)0XxcfDTE{%k>`Wa z5QcpFb$&yuSDy0ND{iafEFlYTm0I8Po^d}|cRy%n-;@wu0x)h(WG=V5pT{qFn4m(a zc($f*6D`0aZ58_53tFt{G22Nz5AnBqfR(9eRCWg7DHrFNkpbNNn1N-cFBF5WJmd>8BDff0HcgRuNY-UWysGr{M*6uC@;-OkN5;pK%SNllZOWYA3Qa(Uh#Ed~TIV z#|8X}@SI9o3*h_a#6V(_g#~Eqqp}4(nZhIPX9wNRpfFnfI^5ret5zwDkF=!Rg`qIs zQvr;T6nF|JQ&XqM&s#FRw`V=`2FElR`&r9E$?EHPs39Lbmm#kNUco0V-v!uMwa`P@ z8w&|O7f-zhm>2Nd0IpWb1S|LNefF^yEq=x3Gk0NUUcuwDL+F+lCTFH=UG;kH0JXYW*gn9ioKo9YzNm>=C`0{-rE>m^fyvPB@Rg-6_p2*vD zmOTcglZM9zZdhK<=Jh%Wwmtr0X_V;DFp^{i4-mjcU@3lh=1SnfQsJw&F#Ty*-GOGz zq{|xPJnqJ=RSv>M9Y3zlWSQ5LH^K`D$QKc(W32=%DO0OrLLBTUxLzY$iwAhjSU~|1 zSbP`o#{0r)W)NIyNSgy6<(0$n#uOCT&&oXe$325y#G?Rf3j}byy?H7^;I;I5$@i95HsT$e2nLclJ&G&O64NuJG-xEJ@*Crv%s@Gy!{0$wU?rms#E_+(OH2)7oFq?KB}DuFz!0;+mI@_$1+ z(OjoA;T*nYMWa@RgTD!ev9jLjzE$a%d_w{z@Ja9$_^Rud(f + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0000_128_data_start __asm("_binary_texture_walking_frame0000_128_data_start"); +extern uint32_t _binary_texture_walking_frame0000_128_data_end __asm("_binary_texture_walking_frame0000_128_data_end"); +extern uint32_t _binary_texture_walking_frame0000_128_data_size __asm("_binary_texture_walking_frame0000_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0001.png b/texture/walking/frame0001.png new file mode 100755 index 0000000000000000000000000000000000000000..91205874a22815b37d42572dd11ac2d24fc86946 GIT binary patch literal 2497 zcmV;y2|o6TP)NlwDMy{W&CKchmis%dv;Te0 ze{n|Lu=&r~m$ldazO~j~XV27YH(7b*t>;%jrCzG_-tJHTZdX0bTjR%eGPm6|=3`tv z7P|lQH(uEF%)XE3W3eik0eBAS9aw#9?ZnB`e4YZ3XWE!&ghi$0-0Qu^)Oroy2=KS@ z9lr%@nr}sA^#DEwveyyQq(-p%d=80oB}K}7Z>3}T1p+kt_pv`}++6I|9ZScAR&spE ziRA}ClO)8t34BjNr}}p~z8gH^ISbTq`0Mw#{WLkggzwr!2m@WO<2R&dADexDWWDj4 zwB|e%#q+B4zndvMR=n`o5SnuZLgXkBdU32$;cmf=?1AF`nQS%HYu5?5_dG+wfC= z_w`TK*6a0EY|FCj*sE{v_y@8r*xdQ5`-*H~wCx9Dq;Y3HoXS`6>aw z95}d#o|7Tf-_E}L3}ERi=-wIX5PpZCJoCrOni$gp{~9-w*Da4c z+Ry6S+%t6=ZgsAJlqW#aEb25X=3GRbhHeJDD?KI3HF=Dk0f_%LUIe%UX+^i^fD03{ za)O-~x7iJBtg`Nn1NYcG>B+HedV$T;{1)pRLO+S1@r=U&ZEhkQFF-%RXJG^(*nH2y zMHuQqsL9|3C(&+R;0ott2>S=%1tWPH>Nn_OVIlpC1lg+(ISIF=rN_kpR}t|3-Gl4F zi|4gNLI?A8n39P8U?7DshQ0n3&H$?NAF4$V=uyW$7>-m(2>TbK{)x&n+bTJO}b@$EAoK_yXWD8}vF^Hu}suQlMds_4)Z6cjUzJSfss^SRYb@ zY<4X}B|zs(JZUrJet~}81{eX#f`E%Mn#<0^W%eHPZv^Fr4?g+0Us znDP|fCisQTL&2R<#!(7>0Qr_6!0Tb)gm(3(K(;X{5+bkS#+l(Qa71&x<){se6)+bA zVU+tc>h}Ts6E0lxg6fRReqk9OHe}fOAsiIWmSJ_Tux3{$H-un<q(tW)H`j z>xVde43GR4uyX*FY1wGmJqrPMU#5A?2ha*Tv|xhLl#&S$F~kkH=UlJEI1S4Ib7Slt zOMpl6+Idw*L&9c&$>XRe@l5b|9vBJyz{1`y1?;%LvmqqWh;$xIgfOIaSL%UQ@0H18 zuX9`9&lIxoRq6A4J~QqI>mJ0|D_=?oF98@?6P2UYt-E(w;mVk#dr;c}iem^?)88_x zCRdQDX^Po;*Ez&@d4Q#Hdp&ak+yQlEh49rmu(~#k z(BnzCo&5lQt2+P%KCNCBpF!qqAlAU=yx-29uHAQ)1ce@Mf@1_~N8tJm#rud!iLx$r z^DCBEoQ=lQ`t$Gu>%SB4Qz0s32qWub`R#z-M1WJe5QeDi5nN4#D}x_J4BEE_A%i3V z^Vd3|vWhsHQ7Tsd6(j^=9>Bb#5%?5E8AgJO-#%R}+jnJqi7c<@MknBi1Ai*ClcYWX zKhTu|iAi=C!9_kR6R5)!9`P_M#%&FR(dt*?`L19+@+QVdT2k)90GrPwfH9IAR%IJW z;2ie(!&rAMbG28=QK+E~yqBS_1m1(svHTWbVb($qVQtJM_!OS{4lpm^-v;n&sZ6kP z1#kOfElT`}%{IBPl=tAV?KM=B6Ra^mIMGBvlq&idpL>HBR`Hz7s>1kbtb0Dnt~~Iz zw}p*7Nt*CuckSLc=YOirS8`rpe-{WK9Vbx1;t3X0$~#z@GY6|6=&A%+;7>sgU03c) zkreE6d*MhAVWpf&R05%@kS5EGf4xW1N;!`*e3gFQE4lWQs7phYF;1^rzLGNYe4PU~ zJ@s;Fl&COa2nCd zFU@9I?ZFkRHvN2N;&6$!1hTXwz7<+-Ix&DDkfpy~tDBDV1$ex6fq)1sehaAZxp12q zHtxr8Y!19XS3u_ecwx*J8OnHk*y2@yl{o@9Uf$M%Y!Y9i5uosk78a6O7{wn?5{7s5CQRqU{MBorxwzU4xP>+0g=HN_^A@zbQXqO z7Xr!-Cu$Z9433 zG(p@S5{GmORN)nKeh8PjV4DOaU0BxQ@5`ZhfrJ}PK&RpBTF3tnDe+SRn?{PU00000 LNkvXXu0mjfT6V8O literal 0 HcmV?d00001 diff --git a/texture/walking/frame0001_128.data.h b/texture/walking/frame0001_128.data.h new file mode 100644 index 0000000..40cc7e5 --- /dev/null +++ b/texture/walking/frame0001_128.data.h @@ -0,0 +1,15 @@ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0001_128_data_start __asm("_binary_texture_walking_frame0001_128_data_start"); +extern uint32_t _binary_texture_walking_frame0001_128_data_end __asm("_binary_texture_walking_frame0001_128_data_end"); +extern uint32_t _binary_texture_walking_frame0001_128_data_size __asm("_binary_texture_walking_frame0001_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0002.png b/texture/walking/frame0002.png new file mode 100755 index 0000000000000000000000000000000000000000..55e7891f29e6059971644d4e84074c64c4c8cf67 GIT binary patch literal 2564 zcmV+f3j6hmP)cY}qyD zgRT-zdgzl^pWpq|fe+?mv1W5R;7QWex8|1Q^qC8Mp9GNOCB})sf>Jp4TJsoNuWB0s z{&s%jnbD^C-l%FlfDeJ}GJXvx)%~|h-wqz(m<8JK^%rk%|7q-8C%=^m=LXtd$1u&roiOq00>1xlX< z0?TYW26AYbI^VSxh*$u9KeZnMP~e4uq5xPRoCY7P!PRP|3AoYetTn#z{?OW(wui#7 zW5P9?0i3rNjIr5R9UDD|N=>Z+qb+$jVBF{En?a?bvt9uG)0SScAQyb;eg@$GM?iE{ zS&#{;ek}qQV=$u0gGE-Sb2XtGwtb<{>^|)JmM(CWDu5Z#6MPC`4D zEdrhWoy*8mlBk<37$ZPvQE+oymk7-6Eyh21`wHW!$rJ!<%I)wSd*ky8=K=Txo}jN0 zkpCCJiNitr406{1Y(&P!>SeWU=AC;QEQ%`-%3}~x9ks@aG1I6u>`j0-r6Xr^4HhFY0RCU-RRAU+EpImt z7&oC>POyD3%x+|3Gwt5gcc+ZgeUi4M705UpU$D+m^ivR2o^wz@85?oO3(!ySS?ECs zHorZ%a6=t%H7Ts%4BEvCOyQUmZvQZ>V92MTmO`s1FwI%7{IOkiz*%j`>22qx+5(V2>TbK{)x&Mas}>Z zg5WC=<~y7b06M6pBO0Vi#sQ!0m=w_hp8-6S2CYst8-1c3G0;FGeRe$Qj-CE3oKn6i zSnE>V-0WJ0N`NlqSke~E`ziW)8z2JEEC{%0MsvkjxN1JJR97?uE0_l0{H{aW887tO zC&NQ10NFezFA08zd2Dc3ka6UK??7JSCb0Vua9q3g$3PaEm=FT1BIC^P78pTuy>8Sh zXcd@gCos9Rq%p1f&ZOVxCcR@Zs&G zZO?qO!);Ks-lTXN2@WdFlK_z69#*u;lc2b2mmpB2W!3%|ofnQtx17}@45BtL2L&A)+~qP=w>PqPPKnv)|w(hXz-Kp zF#AX=rtkdlNxbqbAaMYdY1wezJqrOhCsXh90kpauYA`{uDcRjz@6t>yS<)d(|Kb=7 z1>>``h!8l$1E%1jP42N2aD8v#sTmCgHiLB^MLmOeg2#9uLf`=lykB+((v0v6Yxme3ca_2CUdIKRuYXv{8kH)G!=!yP60gm;y6(VC2;MW zAs^v-LDr?+JjD`=ivc~g-@6}Z|84l5bY3Ba8`+Sd(x4B9BDFlpPXC_sx2(uYY#RS|_u!8l=hGp$1b}!~?9L+vWsDtzU`v+nx5PHPJs(le`H- zV0@@JYMg4Pe$n z3t_F!CHR~_b`B6L;BNzXN-E>DTz~JAA8S#Gf79K(s^Qh zG`*{PWd%Zb81LVbNmT3Oy){JUj5S5GDo0p@!dwahy9Hi&TUZsnmF_z0QI&#v~W$_JZ5Q2h_y;N2U&`CONV&fq+<+^FoEBHbB zDTlH^Fc}FnWE%=rB%8?GW;(_xsE}C!-o_QodDhYKv?v9P$`g!M?prRJCgtbx(LH$Z zDnN<_IF{jr0w~IY+?;Bubcq_=850OTub87{XzPB-0JY$*M}zayyfL<2PsoTP9{1>7 z5C%F9@t7RslgIF#ElZPyi~@ZuEOW=>kET z8H+`h2RS{vF|_Vn@JVL?4{_kl=hEN`LQcfCL{7;0hZ*}Xi5TjEW_qm;eI&p?%kc%; zD*^!x1D>8}yJ7;+d5VOSv!>j`=ve0-nQpT57g$djE%!8`Fk}IDPgKSN#CPi-wL$?{ z<~2CQgjA+&^OhI9S#QPw4N}e(mYJdyO9H16SaNf%-fZ< zfM(hs`cs`R%o5t-{yGjK|8P~&Y=~B2wV&I}ive@R!cuG20KH2A-kltnt2J(@c^rSG z6}vQHSuO($m@LXls1<6iPD5^r|8$ncqlhm0-_W8#t@P8cYRwyG0~Rj+CMm?c+REBD a1MPoZg + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0002_128_data_start __asm("_binary_texture_walking_frame0002_128_data_start"); +extern uint32_t _binary_texture_walking_frame0002_128_data_end __asm("_binary_texture_walking_frame0002_128_data_end"); +extern uint32_t _binary_texture_walking_frame0002_128_data_size __asm("_binary_texture_walking_frame0002_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0003.png b/texture/walking/frame0003.png new file mode 100755 index 0000000000000000000000000000000000000000..521b0c065b91d40dccd0e6e68843fee1a65fd743 GIT binary patch literal 2545 zcmV@KwMZ381#0-IF)^(PQ3)8(uuxY>+_*x7 zs0n+@LQD)SUXrV%F`>x+NJ#(Eq z@7()-Xe)S<)BAJg%$fP-=gd8?mEj@$NP8ge)`aRbFo+%&j3707WJ*XGdXwuGVjL$cj|MpUt7+Op6(1u2pH7f6f3p`sW>K-sWaI?!4Ep zNpH?lk)Ky4Cuz&}gZ~0_t6VMu*7x)dT)%or#x)1Gi@v4~0^5pL#ypuaC{TKBV6dFn zF_3*^D!=(Qh(rK$KfNCYP~b&@MjK!QQ%(2y24T4@kr>9NJ)VBY5#n?|RjvtI`NGnQVeps@Ke{R|-g4}<82svxte zW@{0+n1T^c-qI-QlvfGekR9_zvvSz=EuBl1YJh3b6MPzB6!Zi)*ZK$U<#+-dm*P@+ zeee6LE0xM}zDv{e?2E5He-XT;*kKa`g#7;?ZiktIz<8+LI@)il9$;$-j49Z?jX>vk z*JA3FB$_50%n=~8DYylxOAKaZi|G&DzQlZbG7Z3YGjP^+NHg}L(2F_K4{aw1_%Pxnm#*QUVRXA7!9gK&Hy`fupmLne`at`dAD z0>7g<17Lt&I;@*illwqc?U)kL0-poiTZ2)jo{cf_ju>d5kuf`;bSKXJ>{-e)4Qo?s z;LV}M=mh9mK_qPk-%l{k(*QAmRzbi;E1F3Y;p+LsQd7}1qF@4m^SK6Z=YFBbJ~XJ9tH=^FIVcfxx1Lu>~C)+&edm}V+4PPKnvCYmBfsLPYcFb7C0 zp&#<_S={nlK=uK2mSsal=PU%=e3@oBA3$r`p$8KbTarCs0m1!`K|ybrtU8Mrfm1TT z6kNQMb1dbr_bpttqM^a2vF>B&=W$Q)xF3iS_<;r8{|?wuzbhdn(TQ|F7zt@emtUqg z^m;2(mU~Uu+HsbUxvxrF-}9b%KX`XPXlK5ZkX`~X>P-|bcJfMtbgf;oJUKHqa;inJ z>VC^8n{NzNM5Z}g$8{g#vqpfFsgxN#1@P31^Tf#jZg$MTGP4MDD}enH=6gl}8zVrP zei`dC0KY5TZ_^DB22k+n_3H5=T!=1$zt%3?)zO(u)~3a4@9$nl+6s&y8z1kLw!kqg zt6a5XHrgBwA4+)fE0)f9#jSf1{Ic`|@865@@jz2U8d1FJ)@t@e?n4Zda%qSHpTN;X zI5PO2Ohb9MEiBMaBS6U2W zFGp9v%gVXQOgMpi1z$lYUOfQ5uPp&0lO!!5bUrF#sGBK(e~2A)+k%(T>zCpFp5Q&2 z&X^zRNm&TPki4e>m?Nq1ZSa1kC)s=neq?<;Ynd%wm5-(x%E5CP%1YoZ_@rGECa`K@ zgs@j<6MXWIeFsPs@V5b6rIZO?uD|!mkF{w26Pxceg!v)ko4z~Df$20&Ix3a4hKmxy z`@f-*==6SDKev+aqg7Q{V+sy)&28)!c+qV^HS>o(pxv+X?cR52)_ zJ=b69$=WFo=aGl)DxZzYWKH+dI`GL0zA*)PDA)@0w<+MGPrOi=B~+hwuDJ*>o-qu7 z_3(^k7$boPOSxaYgR)%r)3CT6OAvH|A%gR`8@FBSdV1eF9S;6x=+o($4}iRbW3ziw zl|ec8S(#!5Wopw{zzE4tS1xH(C!LilqjN=?q!Z?l@(38ti2>?DTfvG{6S>pOpg0ZX zl@;Lqz5>4Epk=y|HTeeyVRU5?!S?`P$~Ohx0vxMwyaCFpAQcpIY>IqovR1>HeKK`+ z>>^3Llj*cOf?lQnZGj(Mgr29N78sn2&ghMWY>S=+f#5oX>~hLvrD=(KT_48TbtsoFOQr_j;kCa`E6+ z(0|nO3tRC0=2T{Y0#FJC#yaw|oo($JpsdtZ{?-UV)>gsK44`1UBZ*8E9dD()YtjMA z$--V>iK0p(yrZ)D96BpPwZKFj45`LfcgiKFkN0|?n&#aARDkJ7Lp8Q(7J*L00000NkvXX Hu0mjfZt} + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0003_128_data_start __asm("_binary_texture_walking_frame0003_128_data_start"); +extern uint32_t _binary_texture_walking_frame0003_128_data_end __asm("_binary_texture_walking_frame0003_128_data_end"); +extern uint32_t _binary_texture_walking_frame0003_128_data_size __asm("_binary_texture_walking_frame0003_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0004.png b/texture/walking/frame0004.png new file mode 100755 index 0000000000000000000000000000000000000000..ffe405abed032eb1187833fbb66f5f9c9739c8c8 GIT binary patch literal 2511 zcmV;=2{87FP)@>3I_#>BKnqY^ZtVWBPz5H_w5 zA!_0tScr*%g{&k-6C;|)#)Z*D7bdb|p%&u8XhIaD1Y8(vTo{zZ7HOeE?Q5UkcQ|J} zci!Cl?kz3ikm25U=ggTi-}$|BTd&<@ZQrZUEQd%-Dc0cwAO2oeJj`3`X{*dFyT*Lb z)nle_fBe#Od!Ib?{(LM}#8ZJM$6V<4A0#k7f`Rv+e2ajvD5GT&RN%s-<5oBi|fFEws1cI(RAF`*M5 zA97;;3TRRZv1|suS3*_!tJ2Q~k9f`kd+_D)H+OzNHqy=Cwh0XbvtGw<$nJe?_T!QD z#%t1=Lnw;p70F53qI~dQfbKV!@qqh#`v$LG{!_*+2G16K3mpWuidCj8nKBqqcI}|B zjMyoVW6v~xH(DX$0gU~$ekj0zmko4EfE|?67K1IhdaHB^H_6U>*t)1W8#RKghO32vqh4Bo-<8gN{R zOZ|=gAFQj_>#O;!)oPu6;k9QkfVUJoY@z^-|M%f`m>~#^hh|$x$4NB?*ee2K26kU3 z&^g|{jC-opEKGKoBS2U)aC1VJD9p>2+CTR81?JO|sQ~sC#o;|<<8_LB06u{y=xYSz ze-&`%$kBuJoEA#`T^tKJfZ>PT+I7T22|am<9M7M|@NVscxDG;i){lifLDK>M8aEUA z_6Hy8WB1S8J!RV3DX%~&k3mT@=uLLanM7|wHUZwXt{maoJVtT=;=jqDyY=Fl>90(2$ElQx6zF^uyxKonqA5OA@IX3BZESw69}P&5rMm;~VbJp*fJzOZAT z%pPI|i11`y68y~OA>i();>ZPGL0+s3yc`0KKDY4{$U>7+LgZE4I4isbPSISi2fYDW z17=bcM!rv=pHlG8xp2t?s&QBSm{HIZsE9fea0}pbswL_a@S`LkUHl>zHtJq{csl8y zXMS@)1r)1yCEiAYgHHD(0NijdJD$mvplJ6?5Gc~J+jxpDC`Z>3Ww4v&(`(R~+(iKd zJaILE7J-&)ldteT`t3Kb@T!TI$=BYK8crz-$rE9S;iikA@+il(jK$-*fX~*J1NcxZ zv%j_#u07-`Avp$cN@+VT_7w!~1$=FE`7X7}`1F;4P{3Ho8356ULI~O2qC9C`3|&2r z#uB5a69c2=Yn9hfFNn{;e0Z}pXrb@wdj3Uh7XY>@hw~U_>QGK&VDOqZC6v$>ClO%| zl2%+_~(JI$5}#V-YR{4&wIvwweA7XUVBqQcu`=?nkZbbx*soJ6b0P1 zYy}lU;23Y)zD*Q>N7^d%!3zp_TFf>Q%R~Ha9w23^%G?6*+!yDGkpbLr%)l};4|Fes ze-q|&dH@?eK$^W7+iw7VtKRRh1PBEf__TVnco9y$i{P*K3wJ{SQ!~?IwfFR_B5nQ5 z_^2d4-WzR>VR%-VYR4to3=Mx2@Zwu6jqy^n?kVsK;Rn{gALA2BGlMWRhnWx?Z#0&Us09Pqx)XMF9p9vPfVw2Qd*eu6`XU|w;KR(@R)w=3+ zQ$X+vDuJG$UcmVho+@Y|Syk!$CJg3El-ND+vbTkekgi5O?cM{2=KND_Sjl;Td>3G2 z1wd<8i)XxMNqHMPYi6|yf^MB42e$IqM#Jsw%UaPn0o%lCN*^0t*)kRYDZLV!#C8~+cX{K(Rii-IP@F~IFhaX>&WWJnj z=uXoAKgX0|2#Z_oCZGxFhV ze=cwjJd$TY7`+N1yQ2+<(zHN=t3?)LWA^7SpiN|;LxtYnT$|+5-yx$y=%y$b&y0$q5RX z@L>qx^Pnr!q6062FQ52)^9soGOs-Y*@|IBcl6Y-TgEF;JjH*Oj#+t8}1|P14#aAcZ zGGKD8(ywKpR0V)MU}$lrR + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0004_128_data_start __asm("_binary_texture_walking_frame0004_128_data_start"); +extern uint32_t _binary_texture_walking_frame0004_128_data_end __asm("_binary_texture_walking_frame0004_128_data_end"); +extern uint32_t _binary_texture_walking_frame0004_128_data_size __asm("_binary_texture_walking_frame0004_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0005.png b/texture/walking/frame0005.png new file mode 100755 index 0000000000000000000000000000000000000000..c00b67f0d09c37d84bf2d84869de1fcd9039e0ef GIT binary patch literal 2520 zcmV;}2`Bc6P)_1f+ae(P2|%v zyvJ|On&w+jvw8p@1G&g4rcDgB`Y?xzb1kKm`QA!p{y7EM?4QPeu5oj*TUX|e37z=( zkQ4J)K$A*{Wi#--5~|8ym3}sO#B+M>!RLox-}24mnSS2eCNvDpdL6$ZyY{i!k4M%U zuSshTp(vhLCMRjj^1;6Wy5C&R1MV9b9JzeqPZ_ruJX`cFbP(7oR++M7%3wg*ZwH0t z#7==6d#3Tb-U<;9VC<*$LjeZ7Y@kyD?4X>s7;MSaTcu05Np{{FUwLQy%9ORo%J6gI zHOl}lk_B^oHP(cnXV7V>)4*tb5e}I5DaIP;G<5c}pnt;COBJNam*Hmw@qZjd*Hi_$ zq#D*DaH$O@EO}!muQOgHbYp%jR+^W?ukY!iP-zNifS%w}36r2FxVbhwawo@Y!0}f6 zWUuaee^r)c%lWL;YMp$3|I>efw-h^Uq5zHm_u_J#Aqb4eW?M(cNi_!8D*|H%_FyN_ zIo`jRd#cqeOm>(fKv*+y3qqGD%*&SAKlb(+=F^g?0QMHe;WcFA?-cm}d;(9AmtaAk8R0NIZ3=B}_Cc<$q#tA+fBM8Cf zeE=6>s0X2@1ur;_=i&vfaZU?i{~)|zdniNw23;)7m46WVpv>%sS9jPo==6kt^laIuPJ%6Yh1KC!e=)PNUU0pPrE!rGZH?ARx_ zhgbn3JehY1es1#+a9dPy6oRiHFHi+jt6Op-Cwr@+xke6<)7XG}l{#UI(oK zb43+KzK@|FQ}9o@aLEIzbFTU^qo5~H5g8J23*d9ACF&IL6C@yA{2~@M>Rx)0QH$1?OXYxx>wEHCp6lvLQJVh6jqw9z=*v<0kHRw$4q5uM( z_%(p~K+CnsS9l-#>dTk;tBIG%*WQ!rPANB$C&CcJO%FlkQI2ali^p>TpRFwi@S#}d zP;Dbzd(2fratz><(so?zD+pW*_}b|5J!+Nl=_>)DfU%HG08x)Z2-)4NJZW7FT}vE| zB}Pvt21d)*DzC0y5TAkh@Mde!Lf_W){EOID0Bltb=P}G=P)>b#WX78kN@$Cdh%kFd zE3U6`_#`g*E+BaTon_fr(K!nNcWc z&Js%ClmM84i)V6^sIUgseHi^Tt_dFVfhd75SlIhj#g6+suOW#>Wcgr1 z!;me%%r0p4UZxOxo!k0xmXNu(N?+gensHyPdl=uCMzBo^e4B&=i29}w|CVtBQ!)$N1aix?*5 z!VrZxilYfVGWc51nknx#>jJ}60)$-U7Bs7fs~IcB0=VD96QBgrXRDVkU#m(WD|yBX z7r%YE+U@>wbOpS;oa@|#qqsKk4Rqo)0N{saB|u`5gax?BheZr6nF9Fx*+I8it&CQ` z4A*z4^;kG#e554>7ly)kO$9JUa>LU&nVOzzHu?a14P6p3lrYM!ve;S6Ty0lu;|U?|t&I7A=0o<}-6)6W)Wz zXD^@&pUch0!k#R%>L;Tj(5M7@!)VGIJhPJPWL2f~(=eDzQDT1-V|;66lfAj|2~WFY z_ue`GR2veb^8)!Uz{U!I)~*)M#KV&Ec6Qdx#8E*f@azQHz`qDSbX{{_vLs`x>FFuf z3^e8fvCuUG%hxI(7ShaeAWlZz|7x=p zUI9Y=4JAk-hY~g%pA;Mp7wxQ|Osxt8jX|ugH>-1>^9Fb)5~B8JlmJHebY-x@I|KiR)7iN|0R*yq_;e5xX|jmF&FhZ$u(;R2H!ib zUX`*nQ$jbPCt*Mm&)nPty!Ui4phEDw*-KTLQh%~PYQ;?b=I1&&K^c;?p@igDB~<_q zzH-eD!0^>eKJ_JlZA+q9>-U(>Gj)e*OwzfAk1feRepU65xeaJl)t{ipOR+rt;>a7m zdh%A91H(YFvlre2oWgy@08t4Y@2^AHvFgjWm zvEtKC?+yQZ1$1&ESZv7GUJ2e4>^kKMMF1h(N;uM%w0g6AQ$orUZg>TBQqZ-ILlL>q im*SW3wh)S{D&TLt0dY{F3>hx~0000 + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0005_128_data_start __asm("_binary_texture_walking_frame0005_128_data_start"); +extern uint32_t _binary_texture_walking_frame0005_128_data_end __asm("_binary_texture_walking_frame0005_128_data_end"); +extern uint32_t _binary_texture_walking_frame0005_128_data_size __asm("_binary_texture_walking_frame0005_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/texture/walking/frame0006.png b/texture/walking/frame0006.png new file mode 100755 index 0000000000000000000000000000000000000000..ff79111e7fea9312f032ceeb37abfafeffc105d9 GIT binary patch literal 2524 zcmV<22_yE2P)m>W`PNgJ zQi1O(l)dOfzDYC`S&%OUQBV&-KJ^fdK1G3)QKo^>L=RyN=%k}FIX3sF?_0ChX`Oxd zx#!&Lj7b|d=V!0I_S)b2J^S8r=@x7IUwy6*BK1m(i$PZo znZEtW%e(hIefWdLSgaLK1)e0mL#uBuou9bO`xyXvrNBH~q)*dRu&k5IT z1#p%unB%LlIt0ClPD`xvdci>Wf zpz(h_ZpRsdz<8|FIyy|MA;4Y{7&EX3^FZf# z&kF9TRI)IcGe>~1X5eOoE>W15Ew+E`?F-DOB~t=BwA{7c+S(w};0 z^B}u_=k6)f_Po3Tr92KL)zPc$m~$Py3fTmB*Sa!LR9&&CKsu=$*T zi!juMP}6`HOyIqEfoq)8K-fPDFW8%up?-rd7N*L-fRQ};6~ghQ=)a*ehs+`TOcQ(~ z0>7gv1z>-=S9akcH;8TEy+Mw5&Wn)aNBL*61WX#Ve-O2Mmhb-lpiuEB? zd2?t5Isv+t;Yr)T_fw4XG(Z$!RSVuIBg$Ym%cs|%Gr5Zb2zcab z04)VA*Ct=#eeBzBUg1>}FO#o*CsmwMmXIgH5W`IuLFG}7YblGzdjX%VDF^VSSmsb^ zJ6wCrRYGzM;FQvIT9xLU>VN%$g`%Vs$@FU$!tog;4Qq zO}|aF0FSio&?jEdf~Uo7Be6WhXY&9lQ_-mG27u?jI8TfW;3mfmEHjN!2)dWSe+lzF zJ%EiKAkDsv?HPdIsrNf90YU)=KCRv?UW8NcBKRBp!aeYSbt~r2?`LbZ#<}TBRD^+= zfSX|$o>i*aafvoX!-p2U_!UcIylRt__7wOf;Rn`#0OK=CQ%4vvyqeZ3`XcoqhDoU~ zL?KS%XhM$+z9UmD?{??{!&Cxb0f!tsE$C=v%efc$~R1 z$qGd1T>SRsYSI0r=rVYDIk)J9lX^Aq4Rqqw58#J75+E{3!UA06<1B`jOac6Z?4aAB zRz|BI!2R87Jr>RwA8AR63qz5-rvexwx#22Krm6&=>jLlwyU74$Y}(i_3JH_*LhRc@ z4dvju3}q$o20qu|J--FmShdhY*eeSOKAFe91H=pX+W@Xo%BYpw?|t%PEn4`A&3ER) zCcFo1oj!=S%+_nAu5#G`7Hd}}@V){Cl+YhOJvI3?p4*A{(W*+n(@PhwTo2=x#Kz+VY1W((FzFdVc!>TqK!YirQIsWJq zFJ?vw+e9bVlm|F%j{{&kJYyL~PvF5)>Q`^wEZ6-^7q?>xf=)0*a2|K#*2=_vMhk>T z>)5R}tC&(JiSz=DAJ5ucMwwa!i>)Mr*YQFe#Ok`sm5KFz1B(WDC|Hwg8(5KQB6XUn z8>gZ|o&tO}4s zk8FFvs=d_yaJFAWxrJ%66hH<&9h7vltrEIPMMVU_*;>6D`v;GlR;7C3@P2;2 z+xI-)os8eI9$;ReaX-^4gR^(RfS!;AhFNID6LKxzPB>e6!T-hs2q3)xm*skvZ)f@` mY`q5 + +#ifdef __cplusplus +extern "C" { +#endif + +extern uint32_t _binary_texture_walking_frame0006_128_data_start __asm("_binary_texture_walking_frame0006_128_data_start"); +extern uint32_t _binary_texture_walking_frame0006_128_data_end __asm("_binary_texture_walking_frame0006_128_data_end"); +extern uint32_t _binary_texture_walking_frame0006_128_data_size __asm("_binary_texture_walking_frame0006_128_data_size"); + +#ifdef __cplusplus +} +#endif diff --git a/tools/canvas_size.py b/tools/canvas_size.py new file mode 100644 index 0000000..08cce9a --- /dev/null +++ b/tools/canvas_size.py @@ -0,0 +1,17 @@ +from PIL import Image +import sys + +def main(): + in_file = sys.argv[1] + new_width = int(sys.argv[2]) + new_height = int(sys.argv[3]) + dst_file = sys.argv[4] + with Image.open(in_file) as im: + dst = Image.new(im.mode, (new_width, new_height)) + for y in range(im.height): + for x in range(im.width): + dst.putpixel((x, y), im.getpixel((x, y))) + dst.save(dst_file) + +if __name__ == "__main__": + main() diff --git a/tools/generate.py b/tools/generate.py new file mode 100644 index 0000000..d5805e9 --- /dev/null +++ b/tools/generate.py @@ -0,0 +1,42 @@ +import io + +def should_autonewline(line): + return ( + "static_assert" not in line + and "extern" not in line + and (len(line.split()) < 2 or line.split()[1] != '=') # hacky; meh + ) + +def _render(out, lines): + indent = " " + level = 0 + namespace = 0 + for l in lines: + if l and (l[0] == "}" or l[0] == ")"): + level -= 2 + if level < 0: + assert namespace >= 0 + namespace -= 1 + level = 0 + + if len(l) == 0: + out.write("\n") + else: + out.write(indent * level + l + "\n") + + if l and (l[-1] == "{" or l[-1] == "("): + #if l.startswith("namespace"): + # namespace += 1 + #else: + level += 2 + + if level == 0 and l and l[-1] == ";": + if should_autonewline(l): + out.write("\n") + return out + +def renderer(): + out = io.StringIO() + def render(lines): + return _render(out, lines) + return render, out diff --git a/tools/parse_map.py b/tools/parse_map.py new file mode 100644 index 0000000..02d1f01 --- /dev/null +++ b/tools/parse_map.py @@ -0,0 +1,151 @@ +from PIL import Image +import sys +from dataclasses import dataclass +from generate import renderer +from os import path + +visited = set() + +@dataclass +class vec3: + x: float + y: float + z: float + +@dataclass +class Platform: + scale: vec3 + position: vec3 + +def parse_width(x, y, get_pixel): + width = 0 + while True: + px = get_pixel(x, y) + if px[0] != 0: + width += 1 + x += 1 + else: + break + return width + +def parse_height(x, y, get_pixel): + height = 0 + while True: + px = get_pixel(x, y) + if px[0] != 0: + height += 1 + y += 1 + else: + break + return height + +def round_to_one(n): + if n == 0: + return 1 + else: + return n + +def visit_pixels(x, y, width, height): + for yi in range(round_to_one(height)): + for xi in range(round_to_one(width)): + xx = x + xi + yy = y + yi + location = (xx, yy) + assert location not in visited + visited.add(location) + +def parse_platform(x, y, get_pixel): + width = parse_width(x, y, get_pixel) + height = parse_height(x, y, get_pixel) + + visit_pixels(x, y, width, height) + + if width != 0 and height != 0: + px = get_pixel(x, y) + position = vec3( + x + (width / 2), + (px[0] - 128), + y + (height / 2), + ) + scale = vec3( + width, + 1, + height, + ) + + return Platform( + position=position, + scale=scale, + ) + else: + return None + +def find_platforms(im): + width, height = im.size + pixels = im.convert("RGB").getdata() + + def get_pixel(x, y): + return pixels[y * width + x] + + platforms = [] + + for y in range(height): + for x in range(width): + if (x, y) not in visited: + platform = parse_platform(x, y, get_pixel) + if platform is not None: + platforms.append(platform) + + return platforms + +def format_vec3(v): + return ", ".join(( + f"{n: 8.03f}" + for n in [v.x, v.y, v.z] + )) + +def generate_platform(platform): + yield "{" + yield f".position = vec3({format_vec3(platform.position)})," + yield f".scale = vec3({format_vec3(platform.scale)})," + yield "}," + +def generate_level(name, platforms): + yield f"world::platform {name}_platforms[] = {{" + for platform in platforms: + yield from generate_platform(platform) + yield "};" + + yield f"world::level {name}_level = {{" + yield f".platforms = {name}_platforms," + yield f".platforms_length = (sizeof ({name}_platforms)) / (sizeof (world::platform))," + yield "};" + +def generate_file(name_platforms_list): + yield '#include "demo/platform/world.hpp"' + yield "" + yield f"namespace demo::map {{" + yield "" + for name, platforms in name_platforms_list: + yield from generate_level(name, platforms) + + yield "" + yield '}' + +def level_name(p): + _, fn = path.split(p) + name, _ = path.splitext(fn) + return name + +def find_all_platforms(maps): + for filename in maps: + with Image.open(filename) as im: + name = level_name(filename) + platforms = find_platforms(im) + yield (name, platforms) + +maps = sys.argv[1:] + +render, out = renderer() +render(generate_file(find_all_platforms(maps))) +sys.stdout.write(out.getvalue())