diff --git a/CHANGELOG b/CHANGELOG index 33360095..47d90069 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,11 +1,26 @@ changelog --------- -Current Release: raylib 1.2 (16 September 2014) +Current Release: raylib 1.2.2 (31 December 2014) NOTE: Only versions marked as 'Release' are available in installer, updates are only available as source. NOTE: Current Release includes all previous updates. +----------------------------------------------- +Release: raylib 1.2.2 (31 December 2014) +----------------------------------------------- +[*] Added support for HTML5 compiling (emscripten, asm.js) +[core] Corrected bug on input handling (keyboard and mouse) +[textures] Renamed function CreateTexture() to LoadTextureFromImage() +[textures] Added function ConvertToPOT() +[models] Corrected bug on DrawBillboard() +[models] Corrected bug on DrawHeightmap() +[models] Renamed LoadCubesmap() to LoadCubicmap() +[audio] Added function LoadSoundFromWave() +[makefile] Added support for Linux compiling +[stb] Updated to latest headers versions +[*] Lots of tweaks around + --------------------------------------------------------------- Update: raylib 1.2.1 (17 October 2014) (Small Fixes Update) --------------------------------------------------------------- diff --git a/README.md b/README.md index 202193ab..64ee1684 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,9 @@ Allegro and SDL have also been analyzed for reference. Want to see how easy is making games with raylib? Jump to [code examples!] (http://www.raylib.com/examples.htm) +Since version 1.2.2 raylib can compile directly for web (html5) using emscripten and asm.js, +to see a demo of raylib features working on web, [check here!] (http://www.raylib.com/raylib_demo.html) + history ------- @@ -83,7 +86,7 @@ features * Powerful math module for Vector and Matrix operations [raymath] * Audio loading and playing with streaming support (WAV and OGG) * Custom color palette for fancy visuals on raywhite background - * Multiple platforms support: Windows, Linux, Mac, **Android** and **Raspberry Pi** + * Multiple platforms support: Windows, Linux, Mac, **Android**, **Raspberry Pi** and **HTML5** raylib uses on its core module the outstanding [GLFW3] (http://www.glfw.org/) library. The best option by far I found for multiplatform (Windows, Linux, Mac) window/context and input management (clean, focused, great license, well documented, modern, ...). @@ -160,6 +163,14 @@ _Step 3._ Navigate from command line to folder raylib/template_android/ and type NOTE: libraylib.a will be generated in folder raylib/src_android/obj/local/armeabi/, it must be copied to Android project; if using raylib/template_android project, copy it to raylib/template_android/jni/libs/. +**Building raylib sources for Web (HTML5)** + +_Step 1._ Make sure you have installed emscripten SDK: + +> Download latest version from [here].(http://kripken.github.io/emscripten-site/docs/getting_started/downloads.html) I recommend following the portable version installation instructions. + +_Step 2._ TODO + building examples ----------------- diff --git a/ROADMAP.md b/ROADMAP.md index b48c3044..0814e0b9 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -6,16 +6,18 @@ Here it is a list of features I would like to add and functions to improve. Around the source code there are some TODO points with pending revisions/bugs and here it is a list of features I would like to add. +This roadmap is quite outdated... a full list of all the features we are working on should be listed here at some point... + raylib v1.x - [DONE] Review Billboard Drawing functions - [DONE] Review Heightmap Loading and Drawing functions - Load Heightmap directly as a Model - Lighting support (only 3d mode) - [DONE] Simple Collision Detection functions - - Default scene Camera controls (zoom, pan, rotate) + - [IN PROGRESS] Default scene Camera controls (zoom, pan, rotate) - Basic Procedural Image Generation (Gradient, Checked, Spot, Noise, Cellular) - [DONE] Software mipmapping generation and POT conversion (custom implementation) - - TTF fonts support + - [IN PROGRESS] TTF fonts support Any feature missing? Do you have a request? [Let me know!][raysan5] diff --git a/examples/makefile b/examples/makefile index 076c9594..b9cdd15d 100644 --- a/examples/makefile +++ b/examples/makefile @@ -1,8 +1,6 @@ #************************************************************************************************** # -# raylib for Raspberry Pi and Windows desktop -# -# makefile to compile raylib examples +# raylib makefile for desktop platforms, Raspberry Pi and HTML5 (emscripten) # # Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com) # @@ -23,12 +21,19 @@ # #************************************************************************************************** -# define raylib platform (by default, compile for RPI) -# Other possible platforms: PLATFORM_DESKTOP PLATFORM_DESKTOP_LINUX -PLATFORM ?= PLATFORM_RPI +# define raylib platform to compile for +# possible platforms: PLATFORM_DESKTOP PLATFORM_RPI PLATFORM_WEB +# WARNING: To compile examples to HTML5, they must be redesigned to use emscripten.h and emscripten_set_main_loop() +PLATFORM ?= PLATFORM_DESKTOP # define compiler: gcc for C program, define as g++ for C++ -CC = gcc +ifeq ($(PLATFORM),PLATFORM_WEB) + # define emscripten compiler + CC = emcc +else + # define default gcc compiler + CC = gcc +endif # define compiler flags: # -O2 defines optimization level @@ -41,6 +46,12 @@ else endif #CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes +ifeq ($(PLATFORM),PLATFORM_WEB) + CFLAGS = -O1 -Wall -std=c99 -s USE_GLFW=3 -s ASSERTIONS=1 --preload-file resources + #-s ALLOW_MEMORY_GROWTH=1 # to allow memory resizing + #-s TOTAL_MEMORY=16777216 # to specify heap memory size (default = 16MB) +endif + # define any directories containing required header files ifeq ($(PLATFORM),PLATFORM_RPI) INCLUDES = -I. -I../src -I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads @@ -49,10 +60,10 @@ else endif # define library paths containing required libs -ifeq ($(PLATFORM),PLATFORM_DESKTOP_LINUX) - LFLAGS = -L. -L../src +ifeq ($(PLATFORM),PLATFORM_RPI) + LFLAGS = -L. -L../src -L/opt/vc/lib else - LFLAGS = -L. -L../src -L/opt/vc/lib + LFLAGS = -L. -L../src endif # define any libraries to link into executable @@ -74,6 +85,10 @@ else endif endif +ifeq ($(PLATFORM),PLATFORM_WEB) + LIBS = ../src/libraylib.bc +endif + # define additional parameters and flags for windows ifeq ($(PLATFORM),PLATFORM_DESKTOP) # resources file contains windows exe icon @@ -81,6 +96,10 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP) WINFLAGS = ../src/resources -Wl,--subsystem,windows endif +ifeq ($(PLATFORM),PLATFORM_WEB) + EXT = .html +endif + # define all object files required EXAMPLES = \ core_basic_window \ @@ -109,7 +128,7 @@ EXAMPLES = \ models_billboard \ models_obj_loading \ models_heightmap \ - models_cubesmap \ + models_cubicmap \ audio_sound_loading \ audio_music_stream \ #core_input_gamepad \ @@ -124,125 +143,125 @@ examples: $(EXAMPLES) # compile [core] example - basic window core_basic_window: core_basic_window.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [core] example - keyboard input core_input_keys: core_input_keys.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [core] example - mouse input core_input_mouse: core_input_mouse.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) ifeq ($(PLATFORM),PLATFORM_DESKTOP) # compile [core] example - gamepad input core_input_gamepad: core_input_gamepad.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) endif # compile [core] example - mouse wheel core_mouse_wheel: core_mouse_wheel.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [core] example - generate random values core_random_values: core_random_values.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [core] example - color selection (collision detection) core_color_select: core_color_select.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [core] example - 3d mode core_3d_mode: core_3d_mode.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [shapes] example - raylib logo (with basic shapes) shapes_logo_raylib: shapes_logo_raylib.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [shapes] example - basic shapes usage (rectangle, circle, ...) shapes_basic_shapes: shapes_basic_shapes.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [shapes] example - raylib color palette shapes_colors_palette: shapes_colors_palette.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [shapes] example - raylib logo animation shapes_logo_raylib_anim: shapes_logo_raylib_anim.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - raylib logo texture loading textures_logo_raylib: textures_logo_raylib.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - image loading and conversion to texture textures_image_loading: textures_image_loading.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - texture rectangle drawing textures_rectangle: textures_rectangle.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - compressed texture loading (DDS) textures_compressed_dds: textures_compressed_dds.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - texture mipmaps generation textures_mipmaps: textures_mipmaps.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [textures] example - texture source and destination rectangles textures_srcrec_dstrec: textures_srcrec_dstrec.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [text] example - sprite fonts loading text_sprite_fonts: text_sprite_fonts.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [text] example - raylib bitmap fonts (rBMF) text_rbmf_fonts: text_rbmf_fonts.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [text] example - text formatting text_format_text: text_format_text.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [text] example - font selection program text_font_select: text_font_select.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - basic geometric 3d shapes models_geometric_shapes: models_geometric_shapes.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - basic window models_planes: models_planes.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - billboard usage models_billboard: models_billboard.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - OBJ model loading models_obj_loading: models_obj_loading.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - heightmap loading models_heightmap: models_heightmap.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [models] example - cubesmap loading -models_cubesmap: models_cubesmap.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) +models_cubicmap: models_cubicmap.c + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [audio] example - sound loading and playing (WAV and OGG) audio_sound_loading: audio_sound_loading.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # compile [audio] example - music stream playing (OGG) audio_music_stream: audio_music_stream.c - $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) # clean everything clean: @@ -253,9 +272,13 @@ else ifeq ($(PLATFORM),PLATFORM_DESKTOP_LINUX) find . -type f -executable -delete rm -f *.o +else +ifeq ($(PLATFORM),PLATFORM_WEB) + del *.o *.html *.js else del *.o *.exe endif +endif endif @echo Cleaning done diff --git a/examples/text_font_select.c b/examples/text_font_select.c index d6976b4f..62538ebc 100644 --- a/examples/text_font_select.c +++ b/examples/text_font_select.c @@ -84,7 +84,7 @@ int main() btnNextInColor = PURPLE; } - if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) { framesCounter = 20; // Frames button is 'active' btnNextOutColor = MAROON; @@ -97,8 +97,8 @@ int main() btnNextOutColor = DARKBLUE; btnNextInColor = SKYBLUE; } - - if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON) && (framesCounter > 0)) framesCounter--; + + if (framesCounter > 0) framesCounter--; if (framesCounter == 1) // We change font on frame 1 { diff --git a/games/floppy/floppy.c b/games/floppy/floppy.c new file mode 100644 index 00000000..0617797e --- /dev/null +++ b/games/floppy/floppy.c @@ -0,0 +1,210 @@ +/******************************************************************************************* +* +* raylib game - Floppy Bird +* +* Welcome to raylib! +* +* To test examples, just press F6 and execute raylib_compile_execute script +* Note that compiled executable is placed in the same folder as .c file +* +* You can find all basic examples on C:\raylib\raylib\examples folder or +* raylib official webpage: www.raylib.com +* +* Enjoy using raylib. :) +* +* This game has been created using raylib 1.1 (www.raylib.com) +* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +* +* Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com) +* +********************************************************************************************/ + +#include "raylib.h" + +#define MAX_TUBES 100 + +int main() +{ + // Initialization + //-------------------------------------------------------------------------------------- + int screenWidth = 800; + int screenHeight = 450; + + InitWindow(screenWidth, screenHeight, "Floppy Bird"); + + InitAudioDevice(); // Initialize audio device + + Sound coin = LoadSound("resources/coin.wav"); + Sound jump = LoadSound("resources/jump.wav"); + + Texture2D background = LoadTexture("resources/background.png"); + Texture2D tubes = LoadTexture("resources/tubes.png"); + Texture2D floppy = LoadTexture("resources/floppy.png"); + + Vector2 floppyPos = { 80, screenHeight/2 - floppy.height/2 }; + + Vector2 tubesPos[MAX_TUBES]; + int tubesSpeedX = 2; + + for (int i = 0; i < MAX_TUBES; i++) + { + tubesPos[i].x = 400 + 280*i; + tubesPos[i].y = -GetRandomValue(0, 120); + } + + Rectangle tubesRecs[MAX_TUBES*2]; + bool tubesActive[MAX_TUBES]; + + for (int i = 0; i < MAX_TUBES*2; i += 2) + { + tubesRecs[i].x = tubesPos[i/2].x; + tubesRecs[i].y = tubesPos[i/2].y; + tubesRecs[i].width = tubes.width; + tubesRecs[i].height = 255; + + tubesRecs[i+1].x = tubesPos[i/2].x; + tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; + tubesRecs[i+1].width = tubes.width; + tubesRecs[i+1].height = 255; + + tubesActive[i/2] = true; + } + + int backScroll = 0; + + int score = 0; + int hiscore = 0; + + bool gameover = false; + bool superfx = false; + + SetTargetFPS(60); + //--------------------------------------------------------------------------------------- + + // Main game loop + while (!WindowShouldClose()) // Detect window close button or ESC key + { + // Update + //---------------------------------------------------------------------------------- + backScroll--; + + if (backScroll <= -800) backScroll = 0; + + for (int i = 0; i < MAX_TUBES; i++) tubesPos[i].x -= tubesSpeedX; + + for (int i = 0; i < MAX_TUBES*2; i += 2) + { + tubesRecs[i].x = tubesPos[i/2].x; + tubesRecs[i+1].x = tubesPos[i/2].x; + } + + if (IsKeyDown(KEY_SPACE) && !gameover) floppyPos.y -= 3; + else floppyPos.y += 1; + + if (IsKeyPressed(KEY_SPACE) && !gameover) PlaySound(jump); + + // Check Collisions + for (int i = 0; i < MAX_TUBES*2; i++) + { + if (CheckCollisionCircleRec((Vector2){ floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2 }, floppy.width/2, tubesRecs[i])) + { + gameover = true; + } + else if ((tubesPos[i/2].x < floppyPos.x) && tubesActive[i/2] && !gameover) + { + score += 100; + tubesActive[i/2] = false; + PlaySound(coin); + + superfx = true; + + if (score > hiscore) hiscore = score; + } + } + + if (gameover && IsKeyPressed(KEY_ENTER)) + { + for (int i = 0; i < MAX_TUBES; i++) + { + tubesPos[i].x = 400 + 280*i; + tubesPos[i].y = -GetRandomValue(0, 120); + } + + for (int i = 0; i < MAX_TUBES*2; i += 2) + { + tubesRecs[i].x = tubesPos[i/2].x; + tubesRecs[i].y = tubesPos[i/2].y; + + tubesRecs[i+1].x = tubesPos[i/2].x; + tubesRecs[i+1].y = 600 + tubesPos[i/2].y - 255; + + tubesActive[i/2] = true; + } + + floppyPos.x = 80; + floppyPos.y = screenHeight/2 - floppy.height/2; + + gameover = false; + score = 0; + } + + //---------------------------------------------------------------------------------- + + // Draw + //---------------------------------------------------------------------------------- + BeginDrawing(); + + ClearBackground(RAYWHITE); + + DrawTexture(background, backScroll, 0, WHITE); + DrawTexture(background, screenWidth + backScroll, 0, WHITE); + + if (!gameover) + { + DrawTextureEx(floppy, floppyPos, 0, 1.0, WHITE); + //DrawCircleLines(floppyPos.x + floppy.width/2, floppyPos.y + floppy.height/2, floppy.width/2, RED); + } + + for (int i = 0; i < MAX_TUBES; i++) + { + if (tubesPos[i].x <= 800) DrawTextureEx(tubes, tubesPos[i], 0, 1.0, WHITE); + + //DrawRectangleLines(tubesRecs[i*2].x, tubesRecs[i*2].y, tubesRecs[i*2].width, tubesRecs[i*2].height, RED); + //DrawRectangleLines(tubesRecs[i*2 + 1].x, tubesRecs[i*2 + 1].y, tubesRecs[i*2 + 1].width, tubesRecs[i*2 + 1].height, RED); + } + + DrawText(FormatText("%04i", score), 20, 20, 40, PINK); + DrawText(FormatText("HI-SCORE: %04i", hiscore), 20, 70, 20, VIOLET); + + if (gameover) + { + DrawText("GAME OVER", 100, 180, 100, MAROON); + DrawText("PRESS ENTER to RETRY!", 280, 280, 20, RED); + } + + if (superfx) + { + DrawRectangle(0, 0, screenWidth, screenHeight, GOLD); + superfx = false; + } + + EndDrawing(); + //---------------------------------------------------------------------------------- + } + + // De-Initialization + //-------------------------------------------------------------------------------------- + UnloadTexture(background); // Texture unloading + UnloadTexture(tubes); // Texture unloading + UnloadTexture(floppy); // Texture unloading + + UnloadSound(coin); // Unload sound data + UnloadSound(jump); // Unload sound data + + CloseAudioDevice(); // Close audio device + + CloseWindow(); // Close window and OpenGL context + //-------------------------------------------------------------------------------------- + + return 0; +} \ No newline at end of file diff --git a/games/floppy/resources/background.png b/games/floppy/resources/background.png new file mode 100644 index 00000000..eab9d865 Binary files /dev/null and b/games/floppy/resources/background.png differ diff --git a/games/floppy/resources/coin.wav b/games/floppy/resources/coin.wav new file mode 100644 index 00000000..d3b6e93c Binary files /dev/null and b/games/floppy/resources/coin.wav differ diff --git a/games/floppy/resources/floppy.png b/games/floppy/resources/floppy.png new file mode 100644 index 00000000..7c851086 Binary files /dev/null and b/games/floppy/resources/floppy.png differ diff --git a/games/floppy/resources/jump.wav b/games/floppy/resources/jump.wav new file mode 100644 index 00000000..1f68d336 Binary files /dev/null and b/games/floppy/resources/jump.wav differ diff --git a/games/floppy/resources/tubes.png b/games/floppy/resources/tubes.png new file mode 100644 index 00000000..a3ca8e7e Binary files /dev/null and b/games/floppy/resources/tubes.png differ diff --git a/games/raylib_demo/makefile b/games/raylib_demo/makefile new file mode 100644 index 00000000..3e2fe614 --- /dev/null +++ b/games/raylib_demo/makefile @@ -0,0 +1,123 @@ +#************************************************************************************************** +# +# raylib - Basic Game +# +# makefile to compile basic game +# +# Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com) +# +# This software is provided "as-is", without any express or implied warranty. In no event +# will the authors be held liable for any damages arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, including commercial +# applications, and to alter it and redistribute it freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not claim that you +# wrote the original software. If you use this software in a product, an acknowledgment +# in the product documentation would be appreciated but is not required. +# +# 2. Altered source versions must be plainly marked as such, and must not be misrepresented +# as being the original software. +# +# 3. This notice may not be removed or altered from any source distribution. +# +#************************************************************************************************** + +# define raylib platform (by default, compile for RPI) +# Other possible platform: PLATFORM_DESKTOP, PLATFORM_WEB, PLATFORM_RPI +PLATFORM ?= PLATFORM_WEB + +# define compiler: gcc for C program, define as g++ for C++ +ifeq ($(PLATFORM),PLATFORM_WEB) + # define emscripten compiler + CC = emcc +else + # define default gcc compiler + CC = gcc +endif + +# define compiler flags: +# -O2 defines optimization level +# -Wall turns on most, but not all, compiler warnings +# -std=c99 use standard C from 1999 revision +ifeq ($(PLATFORM),PLATFORM_RPI) + CFLAGS = -O1 -Wall -std=gnu99 -fgnu89-inline +else + CFLAGS = -O1 -Wall -std=c99 +endif + +ifeq ($(PLATFORM),PLATFORM_WEB) + CFLAGS = -O1 -Wall -std=c99 -s USE_GLFW=3 -s ASSERTIONS=1 --preload-file resources + #-s ALLOW_MEMORY_GROWTH=1 # to allow memory resizing + #-s TOTAL_MEMORY=16777216 # to specify heap memory size (default = 16MB) +endif + +#CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes + +# define any directories containing required header files +ifeq ($(PLATFORM),PLATFORM_RPI) + INCLUDES = -I. -I../../src -I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads +else + INCLUDES = -I. -I../../src +endif + +# define library paths containing required libs +ifeq ($(PLATFORM),PLATFORM_WEB) + LFLAGS = -L. +else + LFLAGS = -L. -L../../src -L/opt/vc/lib +endif + +# define any libraries to link into executable +# if you want to link libraries (libname.so or libname.a), use the -lname +ifeq ($(PLATFORM),PLATFORM_RPI) + # libraries for Raspberry Pi compiling + # NOTE: OpenAL Soft library should be installed (libopenal1 package) + LIBS = -lraylib -lGLESv2 -lEGL -lpthread -lrt -lm -lbcm_host -lopenal +else + # libraries for Windows desktop compiling + # NOTE: GLFW3 and OpenAL Soft libraries should be installed + LIBS = -lraylib -lglfw3 -lglew32 -lopengl32 -lopenal32 -lgdi32 +endif + +ifeq ($(PLATFORM),PLATFORM_WEB) + LIBS = ../../src/libraylib.bc +endif + +# define additional parameters and flags for windows +ifeq ($(PLATFORM),PLATFORM_DESKTOP) + # resources file contains windows exe icon + # -Wl,--subsystem,windows hides the console window + WINFLAGS = ../../src/resources -Wl,--subsystem,windows +endif + +ifeq ($(PLATFORM),PLATFORM_WEB) + EXT = .html +endif + +# typing 'make' will invoke the first target entry in the file, +# in this case, the 'default' target entry is qidv_raylib +default: raylib_demo + +# compile qidv_raylib +raylib_demo: raylib_demo.c + $(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS) + +# clean everything +clean: +ifeq ($(PLATFORM),PLATFORM_RPI) + rm -f *.o +# find . -executable -delete +else +ifeq ($(PLATFORM),PLATFORM_WEB) + del *.html *.js +else + del *.o *.exe +endif +endif + @echo Cleaning done + +# instead of defining every module one by one, we can define a pattern +# this pattern below will automatically compile every module defined on $(OBJS) +#%.exe : %.c +# $(CC) -o $@ $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) diff --git a/games/raylib_demo/raylib_demo.c b/games/raylib_demo/raylib_demo.c new file mode 100644 index 00000000..5bbccbe8 --- /dev/null +++ b/games/raylib_demo/raylib_demo.c @@ -0,0 +1,926 @@ +/******************************************************************************************* +* +* raylib - Talk: QIDV raylib (Learn Videogames Programming) +* +* Aprende a Programar Videojuegos con raylib +* +* This talk has been created using raylib v1.2 (www.raylib.com) +* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +* +* Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com) +* +********************************************************************************************/ + +#include "raylib.h" + +#if defined(PLATFORM_WEB) + #include +#endif + +#include +#include + +#define MAX_BALLS 16 + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +typedef enum TalkScreen { LOADING, LOGO, MODULES, ENDING, PONG } TalkScreen; +typedef enum Modules { CORE = 0, SHAPES, TEXTURES, TEXT, MODELS, AUDIO } Modules; + +//---------------------------------------------------------------------------------- +// Global Variables Definition (local to this module) +//---------------------------------------------------------------------------------- +int screenWidth = 1280; +int screenHeight = 720; + +const char msgLoading[30] = "LOADING..."; +const char msgPressEnter[30] = "Press ENTER to START"; + +const char msgCredits[40] = "by RAMON SANTAMARIA [@raysan5]"; +const char msgWeb[30] = "www.raylib.com"; + +const char msgLogoA[40] = "A simple and easy-to-use library"; +const char msgLogoB[40] = "to learn videogames programming"; + +const char msg1[50] = "THIS is a CUSTOM FONT..."; +const char msg2[50] = "...and ANOTHER CUSTOM ONE..."; +const char msg3[50] = "...AND ONE MORE! :)"; + +bool closeWindow = false; + +int totalTime = 60*60*60; // fps*sec*min +int timeCounter = 0; + +TalkScreen currentScreen = LOADING; + +// LOADING screen variables +int loadBarWidth = 0; +int loadBarMaxWidth = 600; + +// TITLE screen variables +SpriteFont fontAlagard; +SpriteFont fontPixelplay; +SpriteFont fontMecha; +SpriteFont fontSetback; +SpriteFont fontRomulus; + +Vector2 pongBallPosition; +Vector2 pongBallSpeed; +Rectangle pongPlayerRec; +Rectangle pongEnemyRec; +int pongScorePlayer = 0; +int pongScoreEnemy = 0; +bool pongAutoMode = true; +int pongAutoCounter = 0; +bool pongPaused = true; + +int lettersCounter = 0; +char msgBuffer[120] = { ' ' }; + +// LOGO screen variables +int logoPositionX; +int logoPositionY; + +int raylibLettersCount = 0; + +int topSideRecWidth = 16; +int leftSideRecHeight = 16; + +int bottomSideRecWidth = 16; +int rightSideRecHeight = 16; + +char raylib[8] = " \0"; // raylib text array, max 8 letters + +int logoScreenState = 0; // Tracking animation states (State Machine) +bool msgLogoADone = false; +bool msgLogoBDone = false; + +// MODULES screen variables +Modules selectedModule = CORE; + +Texture2D raylibWindow; +Texture2D raylibWindow01; +Texture2D raylibWindow02; +Texture2D raylibWindow03; +Texture2D platforms; +Texture2D raylibLogoB; +Texture2D lena; +Texture2D mandrill; +Texture2D texAlagard; +SpriteFont fontMechaC; +SpriteFont fontAlagardC; +SpriteFont fontJupiterC; + +int coreWindow = 1; + +int windowOffset = 0; +Vector2 ballPosition; + +Camera camera; + +Texture2D catTexture; +Model cat; + +Sound fxWav; +Sound fxOgg; + +Vector2 soundBallsPosition[MAX_BALLS]; +Color soundBallsColor[MAX_BALLS]; +bool soundBallsActive[MAX_BALLS]; +float soundBallsAlpha[MAX_BALLS]; +int soundBallsRadius[MAX_BALLS]; + +float scaleFactor = 0.0f; +float timePlayed = 0; + +// ENDING screen variables +Texture2D raylibLogoA; + +// Required variables to manage screen transitions (fade-in, fade-out) +float transAlpha = 0; +bool onTransition = false; +bool transFadeOut = false; +int transFromScreen = -1; +int transToScreen = -1; + +int framesCounter = 0; + +//---------------------------------------------------------------------------------- +// Local Functions Declaration +//---------------------------------------------------------------------------------- +void TransitionToScreen(int screen); +void UpdateTransition(void); +void DrawTransition(void); + +void UpdateDrawOneFrame(void); + +//---------------------------------------------------------------------------------- +// Main entry point +//---------------------------------------------------------------------------------- +int main() +{ + // Initialization + //-------------------------------------------------------------------------------------- + const char windowTitle[30] = "raylib functionality demo"; + + //SetupFlags(FLAG_FULLSCREEN_MODE); + InitWindow(screenWidth, screenHeight, windowTitle); + + InitAudioDevice(); // Initialize audio device + + // TITLE screen variables Initialization + fontAlagard = LoadSpriteFont("resources/fonts/alagard.rbmf"); // rBMF font loading + fontPixelplay = LoadSpriteFont("resources/fonts/pixelplay.rbmf"); // rBMF font loading + fontMecha = LoadSpriteFont("resources/fonts/mecha.rbmf"); // rBMF font loading + fontSetback = LoadSpriteFont("resources/fonts/setback.rbmf"); // rBMF font loading + fontRomulus = LoadSpriteFont("resources/fonts/romulus.rbmf"); // rBMF font loading + + pongBallPosition = (Vector2){ screenWidth/2, screenHeight/2 + 20 }; + pongBallSpeed = (Vector2){ 6, 6 }; + pongPlayerRec = (Rectangle){ 20, screenHeight/2 - 50 + 40, 20, 100 }; + pongEnemyRec = (Rectangle){ screenWidth - 40, screenHeight/2 - 60, 20, 120 }; + + // LOGO screen variables Initialization + logoPositionX = screenWidth/2 - 128; + logoPositionY = screenHeight/2 - 128; + + // MODULES screen variables Initialization + raylibWindow = LoadTexture("resources/raylib_window.png"); + raylibWindow01 = LoadTexture("resources/raylib_window_01.png"); + raylibWindow02 = LoadTexture("resources/raylib_window_02.png"); + raylibWindow03 = LoadTexture("resources/raylib_window_03.png"); + platforms = LoadTexture("resources/platforms.png"); + raylibLogoB = LoadTexture("resources/raylib_logo128x128.png"); + lena = LoadTexture("resources/lena.png"); + mandrill = LoadTexture("resources/mandrill.png"); + texAlagard = LoadTexture("resources/fonts/custom_alagard.png"); + fontMechaC = LoadSpriteFont("resources/fonts/custom_mecha.png"); + fontAlagardC = LoadSpriteFont("resources/fonts/custom_alagard.png"); + fontJupiterC = LoadSpriteFont("resources/fonts/custom_jupiter_crash.png"); + + ballPosition = (Vector2){ 520 + 656/2, 220 + 399/2 }; + + camera = (Camera){{ 0.0, 12.0, 15.0 }, { 0.0, 3.0, 0.0 }, { 0.0, 1.0, 0.0 }}; + + catTexture = LoadTexture("resources/catsham.png"); // Load model texture + cat = LoadModel("resources/cat.obj"); // Load OBJ model + SetModelTexture(&cat, catTexture); + + fxWav = LoadSound("resources/audio/weird.wav"); // Load WAV audio file + fxOgg = LoadSound("resources/audio/tanatana.ogg"); // Load OGG audio file + + for (int i = 0; i < MAX_BALLS; i++) + { + soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; + soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; + soundBallsRadius[i] = GetRandomValue(2, 50); + soundBallsAlpha[i] = 1.0f; + + soundBallsActive[i] = false; + } + + // ENDING screen variables Initialization + raylibLogoA = LoadTexture("resources/raylib_logo.png"); + +#ifndef PLATFORM_WEB + SetTargetFPS(60); +#endif + +#if defined(PLATFORM_WEB) + emscripten_set_main_loop(UpdateDrawOneFrame, 0, 1); +#else + //-------------------------------------------------------------------------------------- + + // Main game loop + while (!WindowShouldClose() && !closeWindow) // Detect window close button or ESC key + { + UpdateDrawOneFrame(); + } +#endif + + // De-Initialization + //-------------------------------------------------------------------------------------- + + // Unload all loaded data (textures, fonts, audio) + UnloadSpriteFont(fontAlagard); // SpriteFont unloading + UnloadSpriteFont(fontPixelplay); // SpriteFont unloading + UnloadSpriteFont(fontMecha); // SpriteFont unloading + UnloadSpriteFont(fontSetback); // SpriteFont unloading + UnloadSpriteFont(fontRomulus); // SpriteFont unloading + + UnloadTexture(raylibWindow); + UnloadTexture(raylibWindow01); + UnloadTexture(raylibWindow02); + UnloadTexture(raylibWindow03); + UnloadTexture(platforms); + UnloadTexture(raylibLogoA); + UnloadTexture(raylibLogoB); + UnloadTexture(lena); + UnloadTexture(mandrill); + UnloadTexture(texAlagard); + + UnloadSpriteFont(fontMechaC); + UnloadSpriteFont(fontAlagardC); + UnloadSpriteFont(fontJupiterC); + + UnloadTexture(catTexture); + UnloadModel(cat); + + UnloadSound(fxWav); + UnloadSound(fxOgg); + + CloseAudioDevice(); + + CloseWindow(); // Close window and OpenGL context + //-------------------------------------------------------------------------------------- + + return 0; +} + +void TransitionToScreen(int screen) +{ + onTransition = true; + transFromScreen = currentScreen; + transToScreen = screen; +} + +void UpdateTransition(void) +{ + if (!transFadeOut) + { + transAlpha += 0.02f; + + if (transAlpha >= 1.0) + { + transAlpha = 1.0; + currentScreen = transToScreen; + transFadeOut = true; + framesCounter = 0; + } + } + else // Transition fade out logic + { + transAlpha -= 0.02f; + + if (transAlpha <= 0) + { + transAlpha = 0; + transFadeOut = false; + onTransition = false; + transFromScreen = -1; + transToScreen = -1; + } + } +} + +void DrawTransition(void) +{ + DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), Fade(RAYWHITE, transAlpha)); +} + +void UpdateDrawOneFrame(void) +{ + // Update + //---------------------------------------------------------------------------------- + if (!onTransition) + { + switch(currentScreen) + { + case LOADING: + { + // Update LOADING screen variables + framesCounter++; // Count frames + + if ((loadBarWidth < loadBarMaxWidth) && ((framesCounter%30) == 0)) loadBarWidth++; + + if (IsKeyDown(KEY_SPACE) && (loadBarWidth < loadBarMaxWidth)) loadBarWidth += 4; + + if (IsKeyPressed(KEY_ENTER) && (loadBarWidth >= loadBarMaxWidth)) TransitionToScreen(LOGO); + + } break; + case LOGO: + { + // Update LOGO screen variables + if (logoScreenState == 0) // State 0: Small box blinking + { + framesCounter++; + + if (framesCounter == 120) + { + logoScreenState = 1; + framesCounter = 0; // Reset counter... will be used later... + } + } + else if (logoScreenState == 1) // State 1: Top and left bars growing + { + topSideRecWidth += 4; + leftSideRecHeight += 4; + + if (topSideRecWidth == 256) logoScreenState = 2; + } + else if (logoScreenState == 2) // State 2: Bottom and right bars growing + { + bottomSideRecWidth += 4; + rightSideRecHeight += 4; + + if (bottomSideRecWidth == 256) + { + lettersCounter = 0; + for (int i = 0; i < strlen(msgBuffer); i++) msgBuffer[i] = ' '; + + logoScreenState = 3; + } + } + else if (logoScreenState == 3) // State 3: Letters appearing (one by one) + { + framesCounter++; + + // Every 12 frames, one more letter! + if ((framesCounter%12) == 0) raylibLettersCount++; + + switch (raylibLettersCount) + { + case 1: raylib[0] = 'r'; break; + case 2: raylib[1] = 'a'; break; + case 3: raylib[2] = 'y'; break; + case 4: raylib[3] = 'l'; break; + case 5: raylib[4] = 'i'; break; + case 6: raylib[5] = 'b'; break; + default: break; + } + + if (raylibLettersCount >= 10) + { + // Write raylib description messages + if ((framesCounter%2) == 0) lettersCounter++; + + if (!msgLogoADone) + { + if (lettersCounter <= strlen(msgLogoA)) strncpy(msgBuffer, msgLogoA, lettersCounter); + else + { + for (int i = 0; i < strlen(msgBuffer); i++) msgBuffer[i] = ' '; + + lettersCounter = 0; + msgLogoADone = true; + } + } + else if (!msgLogoBDone) + { + if (lettersCounter <= strlen(msgLogoB)) strncpy(msgBuffer, msgLogoB, lettersCounter); + else + { + msgLogoBDone = true; + framesCounter = 0; + } + } + } + } + + // Press enter to change to MODULES screen + if (IsKeyPressed(KEY_ENTER) && msgLogoBDone) TransitionToScreen(MODULES); + else if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(LOGO); + + } break; + case MODULES: + { + // Update MODULES screen variables here! + framesCounter++; + + if (IsKeyPressed(KEY_RIGHT) && (selectedModule < 5)) + { + selectedModule++; + framesCounter = 0; + } + else if (IsKeyPressed(KEY_LEFT) && (selectedModule > 0)) + { + selectedModule--; + framesCounter = 0; + } + + if (selectedModule == CORE) + { + if ((framesCounter > 60) && (windowOffset < 40)) + { + windowOffset++; + ballPosition.x++; + ballPosition.y++; + } + + if (framesCounter > 140) + { + if (IsKeyDown('A')) ballPosition.x -= 5; + if (IsKeyDown('D')) ballPosition.x += 5; + if (IsKeyDown('W')) ballPosition.y -= 5; + if (IsKeyDown('S')) ballPosition.y += 5; + + if (IsKeyPressed('1')) coreWindow = 1; + if (IsKeyPressed('2')) coreWindow = 2; + if (IsKeyPressed('3')) coreWindow = 3; + if (IsKeyPressed('4')) coreWindow = 4; + } + } + + if (selectedModule == TEXTURES) scaleFactor = (sinf(2*PI/240*framesCounter) + 1.0f)/2; + + if (selectedModule == AUDIO) + { + if (IsKeyPressed(KEY_SPACE) && !MusicIsPlaying()) PlayMusicStream("resources/audio/guitar_noodling.ogg"); // Play music stream + + if (IsKeyPressed('S')) + { + StopMusicStream(); + timePlayed = 0.0f; + + for (int i = 0; i < MAX_BALLS; i++) + { + soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; + soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; + soundBallsRadius[i] = GetRandomValue(2, 50); + soundBallsAlpha[i] = 1.0f; + + soundBallsActive[i] = false; + } + } + + if (MusicIsPlaying()) + { + timePlayed = GetMusicTimePlayed() / GetMusicTimeLength() * 100 * 4; + + if ((framesCounter%10) == 0) + { + for (int i = 0; i < MAX_BALLS; i++) + { + if (!soundBallsActive[i]) + { + soundBallsActive[i] = true; + break; + } + } + } + + for (int i = 0; i < MAX_BALLS; i++) + { + if (soundBallsActive[i]) soundBallsAlpha[i] -= 0.005f; + + if (soundBallsAlpha[i] <= 0) + { + soundBallsActive[i] = false; + + // Reset ball random + soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) }; + soundBallsColor[i] = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 }; + soundBallsRadius[i] = GetRandomValue(2, 60); + soundBallsAlpha[i] = 1.0f; + } + } + } + + if (IsKeyPressed('N')) PlaySound(fxWav); + //if (IsKeyPressed('M')) PlaySound(fxOgg); + } + + // Press enter to change to ENDING screen + if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(ENDING); + else if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(LOGO); + + } break; + case PONG: + { + // Update SECRET screen variables here! + framesCounter++; + + if (IsKeyPressed('P')) pongPaused = !pongPaused; + + if (!pongPaused) + { + pongBallPosition.x += pongBallSpeed.x; + pongBallPosition.y += pongBallSpeed.y; + + if ((pongBallPosition.x >= screenWidth - 5) || (pongBallPosition.x <= 5)) pongBallSpeed.x *= -1; + if ((pongBallPosition.y >= screenHeight - 5) || (pongBallPosition.y <= 5)) pongBallSpeed.y *= -1; + + if (IsKeyDown(KEY_UP) || IsKeyDown('W')) + { + pongPlayerRec.y -= 5; + pongAutoMode = false; + pongAutoCounter = 180; + } + else if (IsKeyDown(KEY_DOWN) || IsKeyDown('S')) + { + pongPlayerRec.y += 5; + pongAutoMode = false; + pongAutoCounter = 180; + } + else if (pongAutoCounter > 0) + { + pongAutoCounter--; + + if (pongAutoCounter == 0) pongAutoMode = true; + } + + if ((pongBallPosition.x < 600) && pongAutoMode) + { + if (pongBallPosition.y > (pongPlayerRec.y + pongPlayerRec.height/2)) pongPlayerRec.y += 5; + else if (pongBallPosition.y < (pongPlayerRec.y + pongPlayerRec.height/2)) pongPlayerRec.y -= 5; + } + + if (pongPlayerRec.y <= 0) pongPlayerRec.y = 0; + else if ((pongPlayerRec.y + pongPlayerRec.height) >= screenHeight) pongPlayerRec.y = screenHeight - pongPlayerRec.height; + + if (pongBallPosition.x > screenWidth - 600) + { + if (pongBallPosition.y > (pongEnemyRec.y + pongEnemyRec.height/2)) pongEnemyRec.y += 5; + else if (pongBallPosition.y < (pongEnemyRec.y + pongEnemyRec.height/2)) pongEnemyRec.y -= 5; + + if (pongEnemyRec.y <= 0) pongEnemyRec.y = 0; + else if ((pongEnemyRec.y + pongEnemyRec.height) >= screenHeight) pongEnemyRec.y = screenHeight - pongEnemyRec.height; + } + + if ((CheckCollisionCircleRec(pongBallPosition, 10, pongPlayerRec)) || (CheckCollisionCircleRec(pongBallPosition, 10, pongEnemyRec))) pongBallSpeed.x *= -1; + + if (pongBallPosition.x >= screenWidth - 5) pongScorePlayer++; + else if (pongBallPosition.x <= 5) pongScoreEnemy++; + } + + // Press enter to move back to MODULES screen + if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(ENDING); + if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(ENDING); + } break; + case ENDING: + { + // Update ENDING screen + framesCounter++; + + // Press enter to move back to MODULES screen + if (IsKeyPressed(KEY_ENTER)) TransitionToScreen(PONG); + if (IsKeyPressed(KEY_BACKSPACE)) TransitionToScreen(MODULES); + + } break; + default: break; + } + + if ((currentScreen != LOADING) && (timeCounter < totalTime)) timeCounter++; + } + else UpdateTransition(); // Update transition (fade-in, fade-out) + //---------------------------------------------------------------------------------- + + // Draw + //---------------------------------------------------------------------------------- + BeginDrawing(); + + ClearBackground(RAYWHITE); + + switch(currentScreen) + { + case LOADING: + { + // Draw LOADING screen + if ((loadBarWidth < loadBarMaxWidth) && ((framesCounter/40)%2)) DrawText(msgLoading, 360, 240, 40, DARKGRAY); + + DrawRectangle(360 - 4, 300 - 4, loadBarMaxWidth + 8, 60 + 8, LIGHTGRAY); + DrawRectangle(360, 300, loadBarWidth - 1, 60, DARKGRAY); + DrawRectangleLines(360 - 4, 300 - 5, loadBarMaxWidth + 8, 60 + 8, DARKGRAY); + + if (loadBarWidth >= loadBarMaxWidth) + { + //DrawText(msgLoading, 360, 240, 40, DARKGRAY); + if ((framesCounter/30)%2) DrawText(msgPressEnter, screenWidth/2 - MeasureText(msgPressEnter, 40)/2 + 20, 400, 40, DARKGRAY); + } + else DrawText("PRESS SPACE to ACCELERATE LOADING! ;)", screenWidth/2 - 200, 400, 20, LIGHTGRAY); + + } break; + case LOGO: + { + // Draw LOGO screen + if (logoScreenState == 0) + { + if ((framesCounter/15)%2) DrawRectangle(logoPositionX, logoPositionY - 60, 16, 16, BLACK); + } + else if (logoScreenState == 1) + { + DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); + DrawRectangle(logoPositionX, logoPositionY - 60, 16, leftSideRecHeight, BLACK); + } + else if (logoScreenState == 2) + { + DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); + DrawRectangle(logoPositionX, logoPositionY - 60, 16, leftSideRecHeight, BLACK); + + DrawRectangle(logoPositionX + 240, logoPositionY - 60, 16, rightSideRecHeight, BLACK); + DrawRectangle(logoPositionX, logoPositionY + 240 - 60, bottomSideRecWidth, 16, BLACK); + } + else if (logoScreenState == 3) + { + DrawRectangle(logoPositionX, logoPositionY - 60, topSideRecWidth, 16, BLACK); + DrawRectangle(logoPositionX, logoPositionY + 16 - 60, 16, leftSideRecHeight - 32, BLACK); + + DrawRectangle(logoPositionX + 240, logoPositionY + 16 - 60, 16, rightSideRecHeight - 32, BLACK); + DrawRectangle(logoPositionX, logoPositionY + 240 - 60, bottomSideRecWidth, 16, BLACK); + + DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112 - 60, 224, 224, RAYWHITE); + + DrawText(raylib, screenWidth/2 - 44, screenHeight/2 + 48 - 60, 50, BLACK); + + if (!msgLogoADone) DrawText(msgBuffer, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 460, 30, GRAY); + else + { + DrawText(msgLogoA, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 460, 30, GRAY); + + if (!msgLogoBDone) DrawText(msgBuffer, screenWidth/2 - MeasureText(msgLogoB, 30)/2, 510, 30, GRAY); + else + { + DrawText(msgLogoB, screenWidth/2 - MeasureText(msgLogoA, 30)/2, 510, 30, GRAY); + + if ((framesCounter > 90) && ((framesCounter/30)%2)) DrawText("PRESS ENTER to CONTINUE", 930, 650, 20, GRAY); + } + } + } + } break; + case MODULES: + { + // Draw MODULES screen + DrawTexture(raylibLogoB, 40, 40, WHITE); + DrawText("raylib is composed of 6 main modules:", 128 + 40 + 30, 50, 20, GRAY); + + if (framesCounter < 120) + { + if (((framesCounter/30)%2) == 0) DrawRectangle(128 + 40 + 30 - 4 + 175*selectedModule, 128 + 40 - 70 - 8 - 4, 158, 78, RED); + } + else DrawRectangle(128 + 40 + 30 - 4 + 175*selectedModule, 128 + 40 - 70 - 8 - 4, 158, 78, RED); + + if (selectedModule != AUDIO) + { + DrawTriangle((Vector2){950 - 40, 685 - 10}, (Vector2){950 - 60, 685}, (Vector2){950 - 40, 685 + 10}, GRAY); + DrawTriangle((Vector2){950 - 30, 685 - 10}, (Vector2){950 - 30, 685 + 10}, (Vector2){950 - 10, 685}, GRAY); + DrawText("PRESS RIGHT or LEFT to EXPLORE MODULES", 960, 680, 10, GRAY); + } + + switch (selectedModule) + { + case CORE: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x5c5a5aff)); + + DrawTextEx(fontRomulus, "Open-Close Window", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); + DrawTextEx(fontRomulus, "Manage Drawing Area", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); + DrawTextEx(fontRomulus, "Manage Inputs", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); + DrawTextEx(fontRomulus, "Manage Timming", (Vector2){ 48, 320 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); + DrawTextEx(fontRomulus, "Auxiliar Functions", (Vector2){ 48, 350 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x5c5a5aff)); + + switch (coreWindow) + { + case 1: DrawTexture(raylibWindow, 520, 220, WHITE); break; + case 2: DrawTextureEx(raylibWindow01, (Vector2){ 450, 220 - 45 }, 0.0f, 4.0f, WHITE); break; + case 3: DrawTextureEx(raylibWindow02, (Vector2){ 430, 220 - 40 }, 0.0f, 4.0f, WHITE); break; + case 4: DrawTextureEx(raylibWindow03, (Vector2){ 470, 220 - 65 }, 0.0f, 4.0f, WHITE); break; + default: DrawTexture(raylibWindow, 520, 220, WHITE); break; + } + + if (framesCounter > 140) DrawText("Check the possible windows raylib can run on. PRESS KEY: 1, 2, 3 or 4", 520 + 8 + windowOffset + 160, 220 + windowOffset + 10, 10, LIGHTGRAY); + + DrawText("Compile raylib C code for the folowing platforms:", 48, 400, 10, MAROON); + + DrawTextureRec(platforms, (Rectangle){ 0, 0, platforms.width, platforms.height}, (Vector2){ 75, 420 }, WHITE); + + DrawRectangle(520 + 8 + windowOffset, 220 + 31 + windowOffset, 640, 360, RAYWHITE); + DrawRectangleLines(520 + 8 + windowOffset - 1, 220 + 31 + windowOffset - 2, 640 + 2, 360 + 2, GRAY); + DrawFPS(520 + 8 + windowOffset + 10, 220 + 31 + windowOffset + 10); + + DrawRectangle(ballPosition.x - 50, ballPosition.y - 50, 100, 100, Fade(MAROON, 0.5f)); + DrawRectangleRec(GetCollisionRec((Rectangle){ 520 + 8 + windowOffset - 1, 220 + 31 + windowOffset - 1, 640 + 2, 360 + 2 }, (Rectangle){ (int)ballPosition.x - 50, (int)ballPosition.y - 50, 100, 100 }), MAROON); + + if (framesCounter > 140) + { + DrawTextEx(fontMecha, "MOVE ME", (Vector2){ ballPosition.x - 26, ballPosition.y - 20 }, GetFontBaseSize(fontMecha), 2, BLACK); + DrawTextEx(fontMecha, "[ W A S D ]", (Vector2){ ballPosition.x - 36, ballPosition.y }, GetFontBaseSize(fontMecha), 2, BLACK); + } + } break; + case SHAPES: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0xcd5757ff)); + + DrawTextEx(fontRomulus, "Draw Basic Shapes", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0xcd5757ff)); + DrawTextEx(fontRomulus, "Basic Collision Detection", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0xcd5757ff)); + + DrawCircle(screenWidth/4, 120 + 240, 35, DARKBLUE); + DrawCircleGradient(screenWidth/4, 220 + 240, 60, GREEN, SKYBLUE); + DrawCircleLines(screenWidth/4, 340 + 240, 80, DARKBLUE); + + DrawRectangle(screenWidth/4*2 - 110, 100 + 180, 220, 100, LIME); + DrawRectangleGradient(screenWidth/4*2 - 90, 170 + 240, 180, 130, MAROON, GOLD); + DrawRectangleLines(screenWidth/4*2 - 80, 320 + 240, 160, 80, ORANGE); + + DrawTriangle((Vector2){screenWidth/4*3, 60 + 220}, (Vector2){screenWidth/4*3 - 60, 160 + 220}, (Vector2){screenWidth/4*3 + 60, 160 + 220}, VIOLET); + + DrawTriangleLines((Vector2){screenWidth/4*3, 140 + 220}, (Vector2){screenWidth/4*3 - 60, 210 + 260}, (Vector2){screenWidth/4*3 + 60, 210 + 260}, SKYBLUE); + + DrawPoly((Vector2){screenWidth/4*3, 320 + 240}, 6, 80, 0, BROWN); + + } break; + case TEXTURES: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x60815aff)); + + DrawTextEx(fontRomulus, "Load Images and Textures", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x60815aff)); + DrawTextEx(fontRomulus, "Draw Textures", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x60815aff)); + + DrawRectangle(138, 348, 260, 260, GRAY); + DrawTexturePro(lena, (Rectangle){ 0, 0, lena.width, lena.height }, (Rectangle){ 140 + 128, 350 + 128, lena.width/2*scaleFactor, lena.height/2*scaleFactor }, (Vector2){ lena.width/4*scaleFactor, lena.height/4*scaleFactor }, 0.0f, WHITE); + + DrawTexture(lena, 600, 180, Fade(WHITE, 0.3f)); + DrawTextureRec(lena, (Rectangle){ 225, 240, 155, 50 }, (Vector2){ 600 + 256 - 82 + 50, 180 + 241 }, PINK); + + DrawTexturePro(mandrill, (Rectangle){ 0, 0, mandrill.width, mandrill.height }, (Rectangle){ screenWidth/2 - 40, 350 + 128, mandrill.width/2, mandrill.height/2 }, + (Vector2){ mandrill.width/4, mandrill.height/4 }, framesCounter, GOLD); + + } break; + case TEXT: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x377764ff)); + + DrawTextEx(fontRomulus, "Load SpriteFonts", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); + DrawTextEx(fontRomulus, "Draw Text", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); + DrawTextEx(fontRomulus, "Text Formatting", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x377764ff)); + + DrawTexture(texAlagard, 60, 360, WHITE); + + DrawTextEx(fontMechaC, msg1, (Vector2){ 540 + 168, 210 }, GetFontBaseSize(fontMechaC), -3, WHITE); + DrawTextEx(fontAlagardC, msg2, (Vector2){ 460 + 140, 260 }, GetFontBaseSize(fontAlagardC), -2, WHITE); + DrawTextEx(fontJupiterC, msg3, (Vector2){ 640 + 70, 300 }, GetFontBaseSize(fontJupiterC), 2, WHITE); + + DrawTextEx(fontAlagard, "It also includes some...", (Vector2){ 650 + 70, 400 }, GetFontBaseSize(fontAlagard)*2, 2, MAROON); + DrawTextEx(fontPixelplay, "...free fonts in rBMF format...", (Vector2){ 705 - 26, 450 }, GetFontBaseSize(fontPixelplay)*2, 4, ORANGE); + DrawTextEx(fontMecha, "...to be used even in...", (Vector2){ 700 + 40, 500 }, GetFontBaseSize(fontMecha)*2, 4, DARKGREEN); + DrawTextEx(fontSetback, "...comercial projects...", (Vector2){ 710, 550 }, GetFontBaseSize(fontSetback)*2, 4, DARKBLUE); + DrawTextEx(fontRomulus, "...completely for free!", (Vector2){ 710 + 17, 600 }, GetFontBaseSize(fontRomulus)*2, 3, DARKPURPLE); + + DrawText("This is a custom font spritesheet, raylib can load it automatically!", 228, 360 + 295, 10, GRAY); + + } break; + case MODELS: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x417794ff)); + + DrawTextEx(fontRomulus, "Draw Geometric Models", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); + DrawTextEx(fontRomulus, "Load 3D Models", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); + DrawTextEx(fontRomulus, "Draw 3D Models", (Vector2){ 48, 290 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x417794ff)); + + Begin3dMode(camera); + + DrawCube((Vector3){-4, 0, 2}, 2, 5, 2, RED); + DrawCubeWires((Vector3){-4, 0, 2}, 2, 5, 2, GOLD); + DrawCubeWires((Vector3){-4, 0, -2}, 3, 6, 2, MAROON); + + DrawSphere((Vector3){-1, 0, -2}, 1, GREEN); + DrawSphereWires((Vector3){1, 0, 2}, 2, 16, 16, LIME); + + DrawCylinder((Vector3){4, 0, -2}, 1, 2, 3, 4, SKYBLUE); + DrawCylinderWires((Vector3){4, 0, -2}, 1, 2, 3, 4, DARKBLUE); + DrawCylinderWires((Vector3){4.5, -1, 2}, 1, 1, 2, 6, BROWN); + + DrawCylinder((Vector3){1, 0, -4}, 0, 1.5, 3, 8, GOLD); + DrawCylinderWires((Vector3){1, 0, -4}, 0, 1.5, 3, 8, PINK); + + DrawModelEx(cat, (Vector3){ 8.0f, 0.0f, 2.0f }, (Vector3){ 0.0f, 0.5f*framesCounter, 0.0f }, (Vector3){ 0.1f, 0.1f, 0.1f }, WHITE); + DrawGizmo((Vector3){ 8.0f, 0.0f, 2.0f }); + + DrawGrid(10.0, 1.0); // Draw a grid + + End3dMode(); + + DrawFPS(900, 220); + + } break; + case AUDIO: + { + DrawText("This module give you functions to:", 48, 200, 10, GetColor(0x8c7539ff)); + + DrawTextEx(fontRomulus, "Load and Play Sounds", (Vector2){ 48, 230 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x8c7539ff)); + DrawTextEx(fontRomulus, "Play Music (streaming)", (Vector2){ 48, 260 }, GetFontBaseSize(fontRomulus)*2, 4, GetColor(0x8c7539ff)); + + DrawText("PRESS SPACE to START PLAYING MUSIC", 135, 350, 20, GRAY); + DrawRectangle(150, 390, 400, 12, LIGHTGRAY); + DrawRectangle(150, 390, (int)timePlayed, 12, MAROON); + + if (MusicIsPlaying()) + { + DrawText("PRESS 'S' to STOP PLAYING MUSIC", 165, 425, 20, GRAY); + + for (int i = 0; i < MAX_BALLS; i++) + { + if (soundBallsActive[i]) DrawPoly(soundBallsPosition[i], 18, soundBallsRadius[i], 0.0f, Fade(soundBallsColor[i], soundBallsAlpha[i])); + } + } + + DrawText("PRESS 'N' to PLAY a SOUND", 200, 540, 20, VIOLET); + + if ((framesCounter/30)%2) DrawText("PRESS ENTER to CONTINUE", 930, 650, 20, GRAY); + + } break; + default: break; + } + + // Draw modules menu + DrawRectangle(128 + 40 + 30, 128 + 40 - 70 - 8, 150, 70, GetColor(0x898888ff)); + DrawRectangle(128 + 40 + 30 + 8, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xe1e1e1ff)); + DrawText("CORE", 128 + 40 + 30 + 8 + 38, 128 + 40 - 50, 20, GetColor(0x5c5a5aff)); + + DrawRectangle(128 + 40 + 30 + 175, 128 + 40 - 70 - 8, 150, 70, GetColor(0xe66666ff)); + DrawRectangle(128 + 40 + 30 + 8 + 175, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xf0d6d6ff)); + DrawText("SHAPES", 128 + 40 + 30 + 8 + 175 + 28, 128 + 40 - 50, 20, GetColor(0xcd5757ff)); + + DrawRectangle(128 + 40 + 30 + 175*2, 128 + 40 - 70 - 8, 150, 70, GetColor(0x75a06dff)); + DrawRectangle(128 + 40 + 30 + 8 + 175*2, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xc8eabfff)); + DrawText("TEXTURES", 128 + 40 + 30 + 175*2 + 8 + 9, 128 + 40 - 50, 20, GetColor(0x60815aff)); + + DrawRectangle(128 + 40 + 30 + 175*3, 128 + 40 - 70 - 8, 150, 70, GetColor(0x52b296ff)); + DrawRectangle(128 + 40 + 30 + 8 + 175*3, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xbef0ddff)); + DrawText("TEXT", 128 + 40 + 30 + 8 + 175*3 + 38, 128 + 40 - 50, 20, GetColor(0x377764ff)); + + DrawRectangle(128 + 40 + 30 + 175*4, 128 + 40 - 70 - 8, 150, 70, GetColor(0x5d9cbdff)); + DrawRectangle(128 + 40 + 30 + 8 + 175*4, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xbedce8ff)); + DrawText("MODELS", 128 + 40 + 30 + 8 + 175*4 + 28, 128 + 40 - 50, 20, GetColor(0x417794ff)); + + DrawRectangle(128 + 40 + 30 + 175*5, 128 + 40 - 70 - 8, 150, 70, GetColor(0xd3b157ff)); + DrawRectangle(128 + 40 + 30 + 8 + 175*5, 128 + 40 - 70, 150 - 16, 70 - 16, GetColor(0xebddaeff)); + DrawText("AUDIO", 128 + 40 + 30 + 8 + 175*5 + 36, 128 + 40 - 50, 20, GetColor(0x8c7539ff)); + + } break; + case ENDING: + { + // Draw ENDING screen + DrawTextEx(fontAlagard, "LEARN VIDEOGAMES PROGRAMMING", (Vector2){ screenWidth/2 - MeasureTextEx(fontAlagard, "LEARN VIDEOGAMES PROGRAMMING", GetFontBaseSize(fontAlagard)*4, 4).x/2, 80 }, GetFontBaseSize(fontAlagard)*4, 4, MAROON); + + DrawTexture(raylibLogoA, logoPositionX, logoPositionY - 40, WHITE); + + DrawText(msgWeb, screenWidth/2 - MeasureText(msgWeb, 40)/2, 470, 40, DARKGRAY); + + if (framesCounter > 60) DrawText(msgCredits, screenWidth/2 - MeasureText(msgCredits, 30)/2, 550, 30, GRAY); + + if (framesCounter > 120) if ((framesCounter/30)%2) DrawText("PRESS ENTER to CONTINUE", screenWidth/2 - MeasureText("PRESS ENTER to CONTINUE", 20)/2, 640, 20, LIGHTGRAY); + + } break; + case PONG: + { + // Pong + DrawCircleV(pongBallPosition, 10, LIGHTGRAY); + DrawRectangleRec(pongPlayerRec, GRAY); + DrawRectangleRec(pongEnemyRec, GRAY); + + DrawText(FormatText("%02i", pongScorePlayer), 150, 10, 80, LIGHTGRAY); + DrawText(FormatText("%02i", pongScoreEnemy), screenWidth - MeasureText("00", 80) - 150, 10, 80, LIGHTGRAY); + + if (pongPaused) if ((framesCounter/30)%2) DrawText("GAME PAUSED [P]", screenWidth/2 - 100, 40, 20, MAROON); + } break; + default: break; + } + + if (currentScreen != LOADING) DrawRectangle(0, screenHeight - 10, ((float)timeCounter/(float)totalTime)*screenWidth, 10, LIGHTGRAY); + + if (onTransition) DrawTransition(); + + EndDrawing(); + //---------------------------------------------------------------------------------- +} \ No newline at end of file diff --git a/games/raylib_demo/resources/audio/coin.wav b/games/raylib_demo/resources/audio/coin.wav new file mode 100644 index 00000000..6007509b Binary files /dev/null and b/games/raylib_demo/resources/audio/coin.wav differ diff --git a/games/raylib_demo/resources/audio/guitar_noodling.ogg b/games/raylib_demo/resources/audio/guitar_noodling.ogg new file mode 100644 index 00000000..f5022040 Binary files /dev/null and b/games/raylib_demo/resources/audio/guitar_noodling.ogg differ diff --git a/games/raylib_demo/resources/audio/spring.wav b/games/raylib_demo/resources/audio/spring.wav new file mode 100644 index 00000000..c7fbf1b9 Binary files /dev/null and b/games/raylib_demo/resources/audio/spring.wav differ diff --git a/games/raylib_demo/resources/audio/tanatana.ogg b/games/raylib_demo/resources/audio/tanatana.ogg new file mode 100644 index 00000000..90b1795a Binary files /dev/null and b/games/raylib_demo/resources/audio/tanatana.ogg differ diff --git a/games/raylib_demo/resources/audio/weird.wav b/games/raylib_demo/resources/audio/weird.wav new file mode 100644 index 00000000..101029c5 Binary files /dev/null and b/games/raylib_demo/resources/audio/weird.wav differ diff --git a/games/raylib_demo/resources/cat.obj b/games/raylib_demo/resources/cat.obj new file mode 100644 index 00000000..1faa9846 --- /dev/null +++ b/games/raylib_demo/resources/cat.obj @@ -0,0 +1,4731 @@ +# +# object Cat +# + +v -0.00 30.40 -1.43 +v -0.00 30.01 1.57 +v 3.07 28.57 1.88 +v 3.23 28.74 -1.28 +v 2.93 30.52 -14.47 +v 0.00 31.65 -14.07 +v 0.00 32.03 -11.02 +v 3.49 30.39 -11.43 +v -0.00 22.66 -19.14 +v 1.98 22.94 -18.73 +v 2.33 19.32 -17.01 +v -0.00 18.98 -17.55 +v 6.09 25.02 -0.72 +v 6.05 25.40 2.15 +v 6.20 18.84 -0.16 +v 5.74 18.56 2.35 +v 6.32 19.78 -7.20 +v 4.52 16.56 -7.33 +v 4.70 16.75 -9.21 +v 6.65 19.94 -8.17 +v -0.00 30.43 5.21 +v 3.15 29.21 6.20 +v 3.46 15.19 3.29 +v 4.18 15.67 0.04 +v 2.28 13.77 0.12 +v 2.04 14.08 2.60 +v 2.38 14.74 -7.70 +v 2.27 15.37 -10.06 +v 5.58 26.84 7.17 +v 2.87 30.20 8.03 +v 4.93 27.37 9.73 +v 5.61 2.21 8.37 +v 6.14 3.22 9.74 +v 6.68 1.73 10.18 +v 5.68 -0.03 9.83 +v 4.08 -0.03 9.37 +v 4.02 1.99 7.98 +v 2.54 -0.03 10.04 +v 2.39 2.21 8.56 +v 1.77 1.73 10.48 +v 2.34 3.22 10.01 +v 2.52 3.27 11.56 +v 2.80 3.64 11.26 +v 3.32 3.62 11.86 +v 5.34 3.62 11.75 +v 5.75 3.64 11.07 +v 4.32 3.96 11.73 +v 4.34 3.73 12.02 +v 6.03 3.27 11.36 +v 7.00 1.16 12.70 +v 7.05 1.09 14.30 +v 6.62 -0.01 14.46 +v 6.67 -0.01 12.74 +v 5.94 -0.01 14.95 +v 5.34 -0.01 14.87 +v 4.29 -0.01 12.84 +v 4.47 -0.01 15.37 +v 3.58 -0.01 14.94 +v 1.67 1.17 12.96 +v 1.91 -0.01 12.93 +v 2.27 -0.01 14.65 +v 1.87 1.10 14.53 +v 2.04 2.51 14.08 +v 2.41 2.98 12.86 +v 3.07 3.33 12.99 +v 2.87 2.89 14.41 +v 4.95 3.61 13.06 +v 4.38 3.90 13.27 +v 4.41 3.41 14.79 +v 5.47 2.54 14.56 +v 6.74 2.51 13.88 +v 6.27 3.03 12.63 +v 5.58 1.24 15.03 +v 4.51 1.34 15.66 +v 3.48 1.25 15.07 +v 2.66 1.19 15.14 +v 3.54 2.56 14.63 +v 2.19 14.25 6.54 +v 1.39 14.12 6.98 +v 2.42 14.98 8.43 +v 1.36 14.78 9.20 +v 2.01 16.83 -13.60 +v -0.00 16.45 -13.91 +v 6.29 19.22 -3.91 +v 5.78 25.21 -4.36 +v 3.33 29.17 -4.90 +v 0.00 31.15 -4.95 +v -0.00 26.87 -17.74 +v 2.39 27.13 -17.55 +v -0.00 14.93 -10.66 +v -0.00 31.09 -16.51 +v 2.17 29.72 -16.78 +v 1.49 36.84 -24.79 +v 1.27 41.55 -26.64 +v 0.00 42.08 -25.44 +v -0.00 37.36 -23.33 +v 1.10 48.04 -27.60 +v 0.00 41.08 -28.03 +v 0.00 47.89 -28.89 +v -0.00 36.18 -26.27 +v -0.02 31.50 -23.55 +v 1.65 32.74 -22.14 +v 1.80 30.64 -19.84 +v -0.00 29.11 -21.24 +v -0.02 33.60 -20.56 +v -0.01 31.57 -18.45 +v 0.00 48.20 -26.51 +v 0.64 48.90 -27.72 +v -0.00 48.99 -27.04 +v 0.00 48.81 -28.52 +v 2.01 29.52 -17.72 +v -0.00 19.75 14.29 +v -0.00 17.45 12.46 +v 1.88 17.93 12.35 +v 1.57 20.12 14.04 +v 2.56 30.98 9.13 +v 4.46 28.79 10.92 +v -0.00 31.95 8.21 +v -0.00 31.29 7.02 +v 5.94 25.26 11.51 +v 4.93 26.82 12.64 +v -0.00 32.95 8.95 +v 2.56 32.43 9.79 +v 1.36 23.45 15.57 +v -0.00 23.15 15.81 +v 3.19 24.31 14.77 +v 3.17 20.72 13.42 +v 5.00 22.20 12.86 +v 4.13 24.96 14.05 +v 4.39 31.01 11.80 +v 4.76 29.65 13.36 +v 4.26 28.06 14.68 +v 3.28 27.06 15.56 +v -0.00 25.73 16.48 +v 1.41 26.15 16.41 +v 2.33 34.56 22.15 +v 2.25 34.47 22.31 +v 3.19 34.48 22.08 +v 3.11 34.55 21.97 +v 1.82 34.76 22.51 +v 1.98 34.86 22.25 +v 4.11 41.24 16.12 +v 4.12 40.53 17.30 +v 5.12 39.89 15.46 +v 5.50 40.64 14.98 +v 3.81 42.25 16.18 +v 5.77 38.26 15.33 +v 5.91 39.09 13.80 +v 7.55 38.39 15.53 +v 6.54 36.03 14.95 +v 5.79 37.39 13.19 +v 1.95 41.74 16.78 +v 1.50 41.82 17.78 +v 1.91 41.74 17.62 +v 4.44 44.21 17.57 +v 3.38 43.19 17.82 +v 4.27 42.62 18.08 +v 4.86 43.93 17.63 +v 6.27 42.25 15.15 +v 4.55 43.61 16.50 +v 8.27 41.13 15.27 +v 7.96 39.76 15.42 +v 6.37 40.27 13.65 +v 8.04 39.75 15.23 +v 7.03 42.62 14.09 +v 4.88 41.33 13.82 +v 5.86 43.29 14.36 +v 5.09 43.90 15.39 +v 3.78 42.25 15.07 +v 5.51 45.24 17.16 +v 5.70 45.19 17.08 +v 7.48 46.20 17.08 +v 7.08 44.48 15.93 +v 7.79 45.24 16.33 +v 8.24 43.92 15.60 +v 8.30 43.97 15.38 +v 7.56 44.53 15.35 +v 7.82 45.29 16.17 +v 6.80 44.94 15.49 +v 6.20 45.28 16.21 +v 7.45 46.19 16.92 +v 5.18 43.72 17.22 +v 8.33 42.51 15.28 +v 8.40 42.58 15.07 +v 5.09 41.88 17.65 +v 3.26 19.02 11.83 +v 4.39 16.04 -3.75 +v 2.33 13.93 -3.88 +v 0.00 13.05 0.04 +v 0.00 13.35 2.73 +v 0.00 14.05 -7.91 +v 0.00 13.86 7.43 +v 0.00 14.78 9.65 +v 2.74 18.21 -13.21 +v 0.00 13.25 -4.01 +v 5.80 25.70 -8.38 +v 3.34 30.05 -8.19 +v 0.00 31.71 -7.95 +v 2.16 35.87 22.31 +v 2.57 36.23 22.18 +v 2.55 36.31 22.34 +v 2.13 35.91 22.52 +v 1.80 35.20 22.55 +v 1.94 35.25 22.33 +v 4.17 35.18 21.38 +v 4.25 35.81 21.29 +v 4.16 35.76 21.28 +v 4.10 35.18 21.41 +v 3.86 34.75 21.73 +v 3.78 34.80 21.68 +v 3.07 36.36 21.96 +v 3.13 36.47 22.14 +v 3.78 3.59 13.14 +v 5.65 3.37 12.82 +v 6.11 2.84 14.28 +v 6.30 1.18 14.99 +v 2.96 -0.01 15.07 +v 6.25 36.31 15.33 +v 7.47 38.42 15.69 +v 3.13 41.25 17.80 +v 2.03 41.16 19.56 +v 2.31 41.56 17.79 +v 7.09 2.43 -19.06 +v 7.57 3.28 -17.72 +v 7.74 1.96 -17.50 +v 7.12 0.00 -18.53 +v 5.75 0.00 -19.00 +v 5.72 2.06 -19.83 +v 4.44 0.00 -18.31 +v 4.40 2.43 -18.89 +v 3.76 1.96 -17.22 +v 3.89 3.29 -17.47 +v 4.49 3.30 -16.19 +v 4.57 3.62 -16.49 +v 5.21 3.62 -15.90 +v 5.96 3.97 -15.94 +v 5.96 3.72 -15.75 +v 6.70 3.61 -16.01 +v 7.24 3.61 -16.67 +v 7.39 3.30 -16.39 +v 8.75 1.24 -15.02 +v 8.64 1.16 -12.80 +v 8.22 0.00 -12.58 +v 8.27 0.00 -14.95 +v 7.55 0.00 -11.91 +v 6.95 0.00 -12.02 +v 5.92 0.00 -14.81 +v 6.10 0.00 -11.32 +v 5.22 0.00 -11.92 +v 3.53 1.16 -12.48 +v 3.19 1.24 -14.66 +v 3.57 0.00 -14.69 +v 3.93 0.00 -12.32 +v 3.70 3.02 -13.10 +v 4.06 3.53 -14.81 +v 4.51 3.43 -12.65 +v 4.71 3.91 -14.62 +v 6.01 4.53 -14.23 +v 6.04 4.00 -12.13 +v 7.09 3.06 -12.44 +v 6.57 4.22 -14.52 +v 8.34 3.02 -13.38 +v 7.88 3.59 -15.12 +v 7.20 1.32 -11.80 +v 6.14 1.42 -10.92 +v 5.12 1.33 -11.73 +v 4.30 1.26 -11.65 +v 5.18 3.08 -12.34 +v 5.42 4.19 -14.41 +v 7.26 3.95 -14.86 +v 7.72 3.38 -12.82 +v 7.91 1.26 -11.85 +v 4.60 0.00 -11.75 +v 8.34 41.12 15.05 +v 1.05 31.27 23.35 +v 1.91 30.72 22.80 +v -0.00 30.42 21.70 +v 0.99 31.21 23.60 +v 0.44 31.50 23.77 +v -0.00 31.85 23.98 +v -0.00 31.64 23.83 +v 0.19 31.62 23.81 +v 0.77 31.44 23.53 +v 4.07 40.21 13.27 +v 2.70 41.60 14.81 +v 9.35 21.36 -11.82 +v 7.34 20.08 -8.75 +v 7.54 15.35 -9.52 +v 9.91 16.45 -13.25 +v 6.26 25.80 -8.91 +v 7.71 25.97 -11.69 +v 7.69 23.23 -16.57 +v 6.48 26.48 -15.68 +v 4.67 24.17 -19.26 +v 4.29 27.08 -17.03 +v 5.40 13.46 -20.28 +v 5.10 15.57 -19.07 +v 8.29 14.42 -17.91 +v 8.49 11.41 -19.26 +v 8.44 18.60 -17.05 +v 4.95 19.86 -19.38 +v 4.86 29.06 -14.93 +v 5.76 28.94 -11.95 +v 8.39 10.36 -17.19 +v 8.26 8.96 -17.63 +v 8.15 9.26 -19.80 +v 5.37 9.04 -22.20 +v 5.39 12.45 -21.46 +v 7.56 6.58 -19.65 +v 7.75 6.67 -17.92 +v 5.46 6.28 -20.78 +v 9.55 12.52 -15.65 +v 3.21 10.61 -16.85 +v 2.99 11.59 -19.22 +v 3.15 9.53 -19.54 +v 3.35 9.18 -17.26 +v 3.93 6.80 -17.69 +v 5.84 6.61 -16.48 +v 6.07 8.72 -15.66 +v 3.87 6.53 -19.23 +v 6.24 9.51 -15.18 +v 6.94 10.91 -13.09 +v 3.41 12.28 -13.94 +v 3.04 13.84 -15.32 +v 3.10 15.11 -17.16 +v 6.80 11.45 5.31 +v 5.08 11.25 4.62 +v 5.44 13.30 3.26 +v 7.01 13.17 4.27 +v 3.68 11.50 5.38 +v 3.96 13.36 4.06 +v 2.61 12.50 6.46 +v 3.54 12.74 10.35 +v 5.44 11.32 10.79 +v 5.71 12.69 10.92 +v 7.21 12.61 9.49 +v 6.74 10.48 9.44 +v 5.54 15.60 2.65 +v 7.56 15.57 3.60 +v 3.35 15.84 10.75 +v 5.70 16.02 11.41 +v 7.55 16.03 10.25 +v 7.92 12.48 7.83 +v 8.73 15.76 7.82 +v 7.08 21.62 3.10 +v 7.64 18.57 3.15 +v 6.65 24.62 10.50 +v 7.22 23.54 7.84 +v 7.48 10.15 8.22 +v 6.52 9.31 6.17 +v 6.51 9.30 6.16 +v 4.96 9.40 5.37 +v 2.67 3.40 8.13 +v 4.14 3.11 7.38 +v 2.39 4.06 8.96 +v 2.88 4.43 10.82 +v 8.62 19.59 7.86 +v 5.89 19.71 11.97 +v 7.55 19.76 10.61 +v 4.84 8.62 10.62 +v 4.95 9.57 10.50 +v 3.02 9.48 10.01 +v 2.97 8.56 10.21 +v 6.17 8.46 9.79 +v 6.32 9.42 9.66 +v 6.98 9.13 8.55 +v 6.79 8.23 8.68 +v 4.50 8.16 6.43 +v 6.08 8.40 7.10 +v 5.96 7.46 7.26 +v 4.41 7.23 6.64 +v 6.51 7.32 8.81 +v 3.52 10.12 5.88 +v 2.46 8.83 7.68 +v 2.69 6.46 7.45 +v 4.31 6.29 6.86 +v 2.48 7.01 8.20 +v 3.10 7.52 10.42 +v 4.48 4.59 11.31 +v 5.68 4.40 10.51 +v 6.11 4.22 9.23 +v 5.55 3.27 7.82 +v 2.19 28.58 17.74 +v -0.00 28.19 17.89 +v 0.00 27.08 17.06 +v 1.97 27.54 16.97 +v 4.13 28.54 16.42 +v 4.34 29.37 17.58 +v 5.44 30.14 15.70 +v 6.10 31.05 16.90 +v 5.84 30.72 18.56 +v 0.00 34.44 9.58 +v 3.01 33.84 10.45 +v 5.46 32.87 12.29 +v 5.78 31.44 14.37 +v 5.89 35.55 12.68 +v 3.31 36.61 10.82 +v -0.00 37.13 9.86 +v 0.92 34.95 23.68 +v -0.00 35.17 23.93 +v -0.00 34.52 24.34 +v 1.00 34.24 24.10 +v 1.13 33.50 24.60 +v -0.00 33.71 24.97 +v -0.00 32.81 24.82 +v 1.16 33.35 24.54 +v 0.17 32.79 24.76 +v 1.88 32.27 24.20 +v 1.06 32.47 24.68 +v 0.92 32.04 24.48 +v 1.63 31.75 24.03 +v 0.74 31.73 24.22 +v 1.35 31.33 23.89 +v 1.29 34.04 23.96 +v 3.21 30.53 21.75 +v 3.96 31.60 22.04 +v 2.75 31.57 23.20 +v 0.00 41.90 18.20 +v -0.00 41.15 20.18 +v 4.22 29.82 19.06 +v 6.42 33.99 19.85 +v 6.16 32.01 19.66 +v 6.88 32.41 18.06 +v 7.09 34.21 18.13 +v -0.00 36.61 23.40 +v -0.00 35.79 23.62 +v 0.93 35.61 23.37 +v 1.12 36.42 23.17 +v -0.00 31.48 23.97 +v 0.40 31.42 23.92 +v 4.14 32.81 22.39 +v 3.02 32.48 23.28 +v 1.78 36.12 22.84 +v 1.42 35.35 23.08 +v 2.07 40.06 21.08 +v -0.00 40.08 21.59 +v 3.19 36.68 22.18 +v 3.82 36.35 21.67 +v 4.00 36.52 21.64 +v 3.51 37.03 22.04 +v 3.07 40.70 12.84 +v -0.00 41.05 12.30 +v 0.00 41.95 14.79 +v 1.34 29.48 22.43 +v 1.78 29.30 21.35 +v 2.55 29.83 21.48 +v 1.89 29.97 22.46 +v 5.17 30.55 19.50 +v 4.32 30.50 20.82 +v 3.37 29.88 20.50 +v 2.28 29.22 19.09 +v 2.10 29.36 20.32 +v -0.00 33.98 24.85 +v 4.63 37.76 21.16 +v 3.35 38.38 21.86 +v 2.79 37.40 22.61 +v 3.80 39.63 20.44 +v 4.97 38.68 19.91 +v 1.86 38.83 22.55 +v 1.56 37.79 23.12 +v 5.08 36.64 20.39 +v 5.59 37.08 19.06 +v 4.94 39.75 16.71 +v 4.92 39.26 18.02 +v 5.85 37.70 17.08 +v 5.89 38.20 15.93 +v 0.84 29.87 23.02 +v -0.00 29.64 23.08 +v 0.00 29.17 22.48 +v -0.00 28.93 21.37 +v -0.00 29.08 20.37 +v -0.00 28.97 19.19 +v 5.06 31.74 21.03 +v 3.76 40.47 18.68 +v -0.00 38.87 22.78 +v 1.33 34.72 23.44 +v 5.28 36.00 20.21 +v 4.40 36.18 21.25 +v 4.48 35.84 21.14 +v -0.00 37.84 23.28 +v 2.39 33.29 23.39 +v 1.36 33.84 23.79 +v 1.63 32.77 24.35 +v 2.56 36.62 22.56 +v 4.19 36.02 21.35 +v 3.56 33.77 22.69 +v 3.37 39.54 11.68 +v -0.00 39.65 10.81 +v 6.54 34.68 14.01 +v 1.15 31.06 23.46 +v 1.39 30.16 23.06 +v 0.18 32.36 24.61 +v 0.15 32.09 24.44 +v -0.00 32.76 24.73 +v -0.00 32.34 24.55 +v -0.00 32.10 24.37 +v 0.81 31.29 23.67 +v 4.73 34.55 21.49 +v 5.24 33.33 21.28 +v 6.91 32.96 15.56 +v 7.07 34.54 16.53 +v 6.04 36.45 16.75 +v 5.76 36.16 18.45 +v -0.00 30.54 23.72 +v 0.85 30.42 23.55 +v 3.73 36.27 21.50 +v 4.11 35.97 21.31 +v 2.30 35.42 22.46 +v 2.29 35.79 22.39 +v 2.37 35.17 22.43 +v 2.58 34.97 22.35 +v 3.08 34.88 22.13 +v 3.42 35.10 21.98 +v 3.55 35.34 21.89 +v 3.46 35.98 21.87 +v 3.56 35.68 21.85 +v 3.04 36.19 22.04 +v 2.61 36.15 22.23 +v 2.97 35.56 22.36 +v 4.73 7.67 10.74 +v 5.94 7.50 9.91 +v 5.76 6.50 7.43 +v 2.55 7.46 7.26 +v 2.39 7.97 7.91 +v 2.76 8.38 7.02 +v 0.00 49.12 -27.78 +v -3.23 28.74 -1.28 +v -3.07 28.57 1.88 +v -2.93 30.52 -14.47 +v -3.49 30.39 -11.43 +v -2.33 19.32 -17.01 +v -1.98 22.94 -18.73 +v -6.09 25.02 -0.72 +v -6.05 25.40 2.15 +v -6.20 18.84 -0.16 +v -5.74 18.55 2.35 +v -6.32 19.78 -7.20 +v -6.65 19.94 -8.17 +v -4.70 16.75 -9.21 +v -4.52 16.56 -7.33 +v -3.15 29.21 6.20 +v -3.46 15.18 3.30 +v -4.18 15.67 0.04 +v -2.28 13.77 0.12 +v -2.04 14.08 2.60 +v -2.38 14.74 -7.70 +v -2.27 15.37 -10.06 +v -5.58 26.84 7.17 +v -4.93 27.37 9.73 +v -2.87 30.20 8.03 +v -5.61 2.21 8.37 +v -5.68 -0.03 9.83 +v -6.68 1.73 10.18 +v -6.14 3.22 9.74 +v -4.02 1.99 7.98 +v -4.08 -0.03 9.37 +v -2.39 2.21 8.56 +v -2.54 -0.03 10.04 +v -1.77 1.73 10.48 +v -2.34 3.22 10.01 +v -2.52 3.27 11.56 +v -2.80 3.64 11.26 +v -3.32 3.62 11.86 +v -4.32 3.96 11.73 +v -5.75 3.64 11.07 +v -5.34 3.62 11.75 +v -4.34 3.73 12.02 +v -6.03 3.27 11.36 +v -7.00 1.16 12.70 +v -6.67 -0.01 12.74 +v -6.62 -0.01 14.46 +v -7.05 1.09 14.30 +v -5.94 -0.01 14.95 +v -4.29 -0.01 12.84 +v -5.34 -0.01 14.87 +v -4.47 -0.01 15.37 +v -3.58 -0.01 14.94 +v -1.67 1.17 12.96 +v -1.87 1.10 14.53 +v -2.27 -0.01 14.65 +v -1.91 -0.01 12.93 +v -2.04 2.51 14.08 +v -2.41 2.98 12.86 +v -3.07 3.33 12.99 +v -2.87 2.89 14.41 +v -4.95 3.61 13.06 +v -5.47 2.54 14.56 +v -4.41 3.41 14.79 +v -4.38 3.90 13.27 +v -6.74 2.51 13.88 +v -6.27 3.03 12.63 +v -5.58 1.24 15.03 +v -4.51 1.34 15.66 +v -3.48 1.25 15.07 +v -2.66 1.19 15.14 +v -3.54 2.56 14.63 +v -2.19 14.25 6.54 +v -1.39 14.12 6.98 +v -2.42 14.98 8.43 +v -1.36 14.78 9.20 +v -2.01 16.83 -13.60 +v -6.29 19.22 -3.91 +v -5.78 25.21 -4.36 +v -3.33 29.17 -4.90 +v -2.39 27.13 -17.55 +v -2.17 29.71 -16.77 +v -1.49 36.84 -24.79 +v -1.27 41.55 -26.64 +v -1.10 48.04 -27.60 +v -1.80 30.62 -19.83 +v -1.73 32.71 -22.16 +v -0.64 48.90 -27.72 +v -2.01 29.49 -17.69 +v -1.57 20.12 14.04 +v -1.88 17.93 12.35 +v -2.56 30.98 9.13 +v -4.46 28.79 10.92 +v -5.94 25.30 11.45 +v -4.93 26.82 12.64 +v -2.56 32.43 9.79 +v -1.36 23.45 15.57 +v -3.19 24.31 14.77 +v -4.13 24.96 14.05 +v -5.00 22.20 12.86 +v -3.17 20.72 13.42 +v -4.39 31.01 11.80 +v -4.26 28.06 14.68 +v -4.76 29.65 13.36 +v -3.28 27.06 15.56 +v -1.41 26.15 16.41 +v -2.36 34.54 22.12 +v -3.17 34.53 21.93 +v -3.24 34.45 22.04 +v -2.28 34.44 22.27 +v -1.85 34.74 22.48 +v -2.01 34.84 22.21 +v -4.11 41.25 16.12 +v -5.14 39.91 15.45 +v -4.10 40.52 17.32 +v -5.51 40.65 14.97 +v -3.82 42.26 16.17 +v -5.78 38.23 15.31 +v -5.93 39.07 13.75 +v -5.77 37.37 13.20 +v -6.53 36.04 14.96 +v -7.55 38.38 15.52 +v -1.95 41.75 16.78 +v -1.91 41.74 17.62 +v -1.50 41.83 17.78 +v -4.44 44.22 17.56 +v -4.87 43.94 17.63 +v -4.27 42.64 18.07 +v -3.39 43.20 17.82 +v -4.55 43.63 16.49 +v -6.28 42.27 15.14 +v -8.27 41.15 15.26 +v -7.97 39.78 15.41 +v -6.38 40.27 13.63 +v -8.05 39.76 15.23 +v -7.04 42.64 14.09 +v -5.86 43.30 14.35 +v -4.81 41.35 13.62 +v -3.78 42.26 15.07 +v -5.09 43.91 15.39 +v -5.51 45.25 17.16 +v -7.48 46.22 17.08 +v -5.70 45.21 17.08 +v -7.08 44.49 15.93 +v -7.79 45.26 16.33 +v -8.24 43.93 15.60 +v -8.30 43.98 15.38 +v -7.82 45.31 16.17 +v -7.57 44.55 15.34 +v -6.80 44.96 15.49 +v -7.45 46.20 16.92 +v -6.20 45.30 16.21 +v -5.19 43.74 17.22 +v -8.33 42.53 15.28 +v -8.40 42.59 15.07 +v -5.08 41.92 17.73 +v -3.26 19.02 11.83 +v -4.39 16.04 -3.75 +v -2.33 13.93 -3.88 +v -2.74 18.21 -13.21 +v -5.80 25.70 -8.38 +v -3.34 30.05 -8.19 +v -2.22 35.87 22.27 +v -2.18 35.91 22.49 +v -2.62 36.32 22.31 +v -2.64 36.24 22.14 +v -1.99 35.24 22.30 +v -1.84 35.19 22.52 +v -4.24 35.17 21.32 +v -4.17 35.17 21.36 +v -4.22 35.77 21.22 +v -4.32 35.81 21.24 +v -3.84 34.78 21.64 +v -3.92 34.73 21.68 +v -3.20 36.48 22.11 +v -3.14 36.37 21.92 +v -3.78 3.59 13.14 +v -6.11 2.84 14.28 +v -5.65 3.37 12.82 +v -6.30 1.18 14.99 +v -2.96 -0.01 15.07 +v -7.48 38.41 15.68 +v -6.27 36.31 15.32 +v -3.13 41.25 17.80 +v -2.31 41.56 17.79 +v -2.03 41.16 19.56 +v -7.09 2.43 -19.06 +v -7.12 0.00 -18.53 +v -7.74 1.96 -17.50 +v -7.57 3.28 -17.72 +v -5.72 2.06 -19.83 +v -5.75 0.00 -19.00 +v -4.40 2.43 -18.89 +v -4.44 0.00 -18.31 +v -3.76 1.96 -17.22 +v -3.89 3.29 -17.47 +v -4.57 3.62 -16.49 +v -4.49 3.30 -16.19 +v -5.96 3.97 -15.94 +v -5.21 3.62 -15.90 +v -5.96 3.72 -15.75 +v -6.70 3.61 -16.01 +v -7.39 3.30 -16.39 +v -7.24 3.61 -16.67 +v -8.75 1.24 -15.02 +v -8.27 0.00 -14.95 +v -8.22 0.00 -12.58 +v -8.64 1.16 -12.80 +v -7.55 0.00 -11.91 +v -5.92 0.00 -14.81 +v -6.95 0.00 -12.02 +v -6.10 0.00 -11.32 +v -5.22 0.00 -11.92 +v -3.53 1.16 -12.48 +v -3.93 0.00 -12.32 +v -3.57 0.00 -14.69 +v -3.19 1.24 -14.66 +v -3.70 3.02 -13.10 +v -4.06 3.53 -14.81 +v -4.71 3.91 -14.62 +v -4.51 3.43 -12.65 +v -6.01 4.53 -14.23 +v -6.57 4.22 -14.52 +v -7.09 3.06 -12.44 +v -6.04 4.00 -12.13 +v -8.34 3.02 -13.38 +v -7.88 3.59 -15.12 +v -7.20 1.32 -11.80 +v -6.14 1.42 -10.92 +v -5.12 1.33 -11.73 +v -4.30 1.26 -11.65 +v -5.18 3.08 -12.34 +v -5.42 4.19 -14.41 +v -7.26 3.95 -14.86 +v -7.72 3.38 -12.82 +v -7.91 1.26 -11.85 +v -4.60 0.00 -11.75 +v -8.35 41.13 15.05 +v -1.05 31.27 23.35 +v -1.91 30.72 22.80 +v -0.44 31.50 23.77 +v -0.99 31.21 23.60 +v -0.18 31.62 23.81 +v -0.76 31.44 23.53 +v -3.97 40.15 13.10 +v -2.70 41.61 14.81 +v -9.35 21.36 -11.82 +v -9.91 16.45 -13.25 +v -7.54 15.35 -9.52 +v -7.34 20.08 -8.75 +v -6.26 25.80 -8.91 +v -7.71 25.97 -11.69 +v -6.48 26.48 -15.68 +v -7.69 23.23 -16.57 +v -4.67 24.17 -19.26 +v -4.29 27.08 -17.03 +v -5.40 13.46 -20.27 +v -8.49 11.41 -19.26 +v -8.29 14.42 -17.91 +v -5.10 15.57 -19.07 +v -4.95 19.86 -19.38 +v -8.44 18.60 -17.05 +v -5.76 28.94 -11.95 +v -4.86 29.06 -14.93 +v -8.39 10.36 -17.19 +v -8.15 9.26 -19.79 +v -8.25 8.95 -17.63 +v -5.39 12.45 -21.46 +v -5.37 9.04 -22.20 +v -7.55 6.57 -19.63 +v -7.74 6.66 -17.92 +v -5.46 6.28 -20.75 +v -9.55 12.52 -15.65 +v -3.21 10.61 -16.85 +v -3.35 9.18 -17.26 +v -3.15 9.53 -19.54 +v -2.99 11.59 -19.22 +v -3.95 6.80 -17.69 +v -6.07 8.71 -15.66 +v -5.84 6.61 -16.49 +v -3.89 6.53 -19.21 +v -6.24 9.51 -15.18 +v -3.41 12.28 -13.94 +v -6.94 10.91 -13.09 +v -3.04 13.84 -15.32 +v -3.10 15.11 -17.16 +v -6.80 11.45 5.31 +v -7.01 13.17 4.27 +v -5.44 13.30 3.26 +v -5.08 11.25 4.62 +v -3.96 13.36 4.06 +v -3.68 11.50 5.38 +v -2.61 12.50 6.46 +v -3.54 12.74 10.35 +v -5.71 12.69 10.92 +v -5.44 11.32 10.79 +v -7.21 12.61 9.49 +v -6.74 10.48 9.44 +v -7.56 15.56 3.62 +v -5.54 15.58 2.66 +v -3.35 15.84 10.75 +v -5.70 16.04 11.42 +v -7.55 16.04 10.26 +v -7.92 12.48 7.83 +v -8.73 15.76 7.84 +v -7.64 18.53 3.16 +v -7.08 21.58 3.09 +v -6.65 24.64 10.45 +v -7.22 23.54 7.80 +v -7.48 10.15 8.22 +v -6.51 9.30 6.16 +v -4.96 9.40 5.37 +v -6.52 9.31 6.17 +v -4.14 3.11 7.38 +v -2.67 3.40 8.13 +v -2.39 4.06 8.96 +v -2.88 4.43 10.82 +v -8.62 19.59 7.86 +v -5.89 19.76 11.97 +v -7.55 19.80 10.61 +v -4.84 8.62 10.62 +v -2.97 8.56 10.21 +v -3.02 9.48 10.01 +v -4.95 9.57 10.50 +v -6.17 8.46 9.79 +v -6.32 9.42 9.66 +v -6.98 9.13 8.55 +v -6.79 8.23 8.68 +v -4.50 8.16 6.43 +v -4.41 7.23 6.64 +v -5.96 7.46 7.26 +v -6.08 8.40 7.10 +v -6.51 7.32 8.81 +v -3.52 10.12 5.88 +v -2.46 8.83 7.68 +v -4.31 6.29 6.86 +v -2.69 6.46 7.45 +v -2.48 7.01 8.20 +v -3.10 7.52 10.42 +v -4.48 4.59 11.31 +v -5.68 4.40 10.51 +v -6.11 4.22 9.23 +v -5.55 3.27 7.82 +v -2.19 28.58 17.74 +v -1.97 27.54 16.97 +v -4.34 29.37 17.58 +v -4.13 28.54 16.42 +v -5.84 30.72 18.56 +v -6.10 31.05 16.90 +v -5.44 30.14 15.70 +v -3.01 33.84 10.45 +v -5.78 31.44 14.37 +v -5.46 32.87 12.29 +v -5.71 35.59 12.81 +v -3.31 36.61 10.82 +v -0.93 34.94 23.68 +v -1.00 34.24 24.10 +v -1.16 33.35 24.54 +v -0.17 32.79 24.76 +v -1.13 33.50 24.60 +v -1.88 32.27 24.20 +v -1.63 31.75 24.03 +v -0.92 32.04 24.48 +v -1.06 32.47 24.68 +v -1.35 31.33 23.89 +v -0.74 31.73 24.22 +v -1.30 34.03 23.96 +v -3.21 30.53 21.75 +v -2.75 31.57 23.20 +v -3.96 31.60 22.04 +v -4.22 29.82 19.06 +v -6.42 33.99 19.85 +v -7.09 34.21 18.13 +v -6.88 32.41 18.06 +v -6.16 32.01 19.66 +v -1.13 36.42 23.17 +v -0.94 35.60 23.36 +v -0.40 31.42 23.92 +v -3.03 32.48 23.28 +v -4.15 32.81 22.39 +v -1.82 36.12 22.82 +v -1.44 35.34 23.07 +v -2.07 40.06 21.08 +v -4.07 36.54 21.59 +v -3.89 36.36 21.63 +v -3.25 36.70 22.15 +v -3.56 37.05 22.01 +v -2.94 40.68 12.68 +v -1.34 29.48 22.43 +v -1.89 29.97 22.46 +v -2.55 29.83 21.48 +v -1.78 29.30 21.35 +v -5.17 30.55 19.50 +v -3.37 29.88 20.50 +v -4.32 30.50 20.82 +v -2.28 29.22 19.09 +v -2.10 29.36 20.32 +v -2.83 37.42 22.60 +v -3.36 38.39 21.85 +v -4.65 37.77 21.15 +v -3.79 39.63 20.44 +v -4.96 38.68 19.91 +v -1.86 38.83 22.55 +v -1.57 37.79 23.12 +v -5.57 37.08 19.06 +v -5.09 36.65 20.37 +v -4.94 39.76 16.71 +v -5.87 38.17 15.92 +v -5.83 37.68 17.08 +v -4.92 39.25 18.02 +v -0.84 29.87 23.02 +v -5.06 31.74 21.03 +v -3.72 40.46 18.75 +v -1.34 34.71 23.44 +v -5.29 36.00 20.18 +v -4.55 35.85 21.09 +v -4.47 36.19 21.20 +v -2.41 33.28 23.39 +v -1.63 32.77 24.35 +v -1.37 33.83 23.79 +v -2.62 36.63 22.54 +v -4.26 36.03 21.29 +v -3.60 33.75 22.67 +v -3.34 39.51 11.62 +v -6.49 34.69 14.03 +v -1.15 31.06 23.46 +v -1.39 30.16 23.06 +v -0.18 32.36 24.61 +v -0.15 32.09 24.44 +v -0.81 31.29 23.67 +v -4.78 34.53 21.45 +v -5.25 33.32 21.27 +v -6.91 32.96 15.56 +v -7.07 34.54 16.53 +v -6.06 36.46 16.74 +v -5.78 36.16 18.45 +v -0.85 30.42 23.55 +v -3.80 36.28 21.45 +v -4.18 35.98 21.26 +v -2.36 35.40 22.43 +v -2.35 35.78 22.36 +v -2.43 35.15 22.39 +v -2.64 34.95 22.32 +v -3.14 34.86 22.10 +v -3.48 35.09 21.94 +v -3.62 35.34 21.85 +v -3.62 35.68 21.80 +v -3.53 35.99 21.82 +v -3.11 36.20 22.00 +v -2.68 36.15 22.20 +v -3.03 35.56 22.32 +v -4.73 7.67 10.74 +v -5.94 7.50 9.91 +v -5.76 6.50 7.43 +v -2.55 7.46 7.26 +v -2.39 7.97 7.91 +v -2.76 8.38 7.02 +v 6.85 37.87 15.86 +v 7.57 39.02 15.60 +v 6.61 39.54 15.81 +v 6.25 40.55 15.97 +v 5.65 41.65 16.34 +v 5.11 42.24 16.66 +v 8.70 40.27 15.35 +v 7.52 41.07 15.29 +v 8.25 42.23 15.29 +v 6.63 42.67 15.79 +v 6.24 43.68 16.20 +v 4.53 42.44 16.97 +v 3.63 40.71 17.31 +v 4.99 43.52 16.35 +v 8.25 38.26 15.78 +v 6.14 36.94 15.33 +v -6.26 40.55 15.97 +v -6.62 39.52 15.80 +v -7.58 39.01 15.59 +v -6.85 37.85 15.85 +v -5.11 42.25 16.66 +v -5.66 41.66 16.34 +v -8.70 40.28 15.34 +v -7.53 41.09 15.28 +v -6.63 42.68 15.79 +v -8.25 42.24 15.29 +v -6.24 43.69 16.20 +v -3.61 40.71 17.32 +v -4.53 42.45 16.97 +v -5.00 43.53 16.35 +v -8.25 38.27 15.78 +v -6.16 36.93 15.32 +# 1013 vertices + +vn -0.00 0.99 0.14 +vn -0.00 1.00 0.00 +vn 0.61 0.79 -0.04 +vn 0.65 0.76 0.07 +vn 0.49 0.82 -0.29 +vn 0.00 0.99 -0.17 +vn 0.00 1.00 0.02 +vn 0.56 0.82 0.10 +vn -0.00 -0.08 -1.00 +vn -0.08 -0.02 -1.00 +vn -0.34 -0.51 -0.79 +vn -0.00 -0.63 -0.78 +vn 0.94 0.33 -0.02 +vn 0.90 0.42 -0.11 +vn 0.96 -0.27 0.06 +vn 0.80 -0.25 -0.55 +vn 0.97 -0.22 0.10 +vn 0.77 -0.64 -0.03 +vn 0.31 -0.83 0.46 +vn 0.77 -0.12 0.62 +vn -0.00 0.97 -0.26 +vn 0.60 0.77 -0.22 +vn 0.28 -0.83 -0.48 +vn 0.78 -0.62 0.03 +vn 0.50 -0.86 0.04 +vn 0.45 -0.89 0.10 +vn 0.47 -0.86 -0.18 +vn 0.41 -0.85 -0.32 +vn 0.82 0.57 -0.03 +vn 0.65 0.71 -0.27 +vn 0.86 0.51 -0.01 +vn 0.65 -0.32 -0.69 +vn 0.98 0.17 -0.11 +vn 0.95 -0.02 -0.30 +vn 0.44 -0.79 -0.42 +vn -0.04 -0.84 -0.53 +vn -0.08 -0.49 -0.87 +vn -0.52 -0.78 -0.35 +vn -0.76 -0.19 -0.62 +vn -0.99 0.03 -0.16 +vn -0.95 0.30 0.02 +vn -0.75 0.64 0.15 +vn -0.67 0.63 0.40 +vn -0.33 0.91 0.24 +vn 0.36 0.91 0.18 +vn 0.70 0.63 0.35 +vn 0.04 0.73 0.69 +vn 0.02 0.96 0.30 +vn 0.77 0.63 0.07 +vn 1.00 -0.00 -0.09 +vn 0.93 -0.01 0.37 +vn 0.60 -0.72 0.35 +vn 0.63 -0.78 -0.06 +vn 0.14 -0.67 0.73 +vn 0.14 -0.82 0.55 +vn 0.00 -1.00 0.00 +vn 0.01 -0.69 0.72 +vn -0.08 -0.82 0.57 +vn -1.00 0.03 0.03 +vn -0.66 -0.75 0.02 +vn -0.56 -0.71 0.42 +vn -0.87 -0.01 0.49 +vn -0.78 0.53 0.34 +vn -0.73 0.68 0.07 +vn -0.43 0.89 0.17 +vn -0.25 0.73 0.63 +vn 0.39 0.91 0.14 +vn 0.00 0.99 0.12 +vn -0.02 0.76 0.65 +vn 0.35 0.54 0.77 +vn 0.82 0.52 0.25 +vn 0.74 0.68 0.01 +vn 0.30 0.11 0.95 +vn 0.02 0.09 1.00 +vn -0.21 0.11 0.97 +vn -0.31 0.12 0.94 +vn -0.29 0.53 0.80 +vn -0.41 -0.91 0.06 +vn 0.27 -0.94 0.19 +vn 0.15 -0.89 0.43 +vn 0.33 -0.81 0.49 +vn 0.54 -0.71 -0.46 +vn 0.00 -0.87 -0.50 +vn 0.97 -0.24 -0.02 +vn 0.94 0.33 0.01 +vn 0.70 0.70 0.14 +vn -0.00 0.98 0.21 +vn -0.00 -0.07 -1.00 +vn 0.22 0.35 -0.91 +vn 0.00 -0.93 -0.36 +vn -0.00 0.99 -0.12 +vn 0.77 0.53 -0.35 +vn 1.00 0.02 -0.04 +vn 1.00 0.03 -0.03 +vn 0.00 0.28 0.96 +vn 0.00 0.51 0.86 +vn 0.97 0.23 0.00 +vn 0.00 -0.23 -0.97 +vn -0.00 0.11 -0.99 +vn 0.00 -0.42 -0.91 +vn 0.00 -0.61 -0.79 +vn 1.00 0.00 -0.05 +vn 1.00 0.03 -0.05 +vn 0.00 -0.77 -0.64 +vn -0.00 0.68 0.74 +vn -0.01 0.90 0.43 +vn 0.00 0.36 0.93 +vn 0.73 0.68 -0.05 +vn -0.00 0.77 0.64 +vn -0.00 0.61 -0.80 +vn 0.92 0.22 -0.32 +vn -0.00 -0.51 0.86 +vn -0.00 -0.68 0.73 +vn 0.44 -0.60 0.67 +vn 0.37 -0.47 0.80 +vn 0.67 0.52 -0.52 +vn 0.92 0.31 -0.22 +vn -0.00 0.75 -0.66 +vn -0.00 0.89 -0.46 +vn 0.86 0.28 0.42 +vn 0.94 0.13 0.31 +vn -0.00 0.46 -0.89 +vn 0.54 0.26 -0.80 +vn 0.35 -0.31 0.88 +vn 0.00 -0.34 0.94 +vn 0.57 -0.23 0.79 +vn 0.43 -0.43 0.80 +vn 0.65 -0.10 0.75 +vn 0.76 -0.09 0.65 +vn 0.85 -0.06 -0.53 +vn 0.97 -0.18 -0.15 +vn 0.90 -0.33 0.29 +vn 0.65 -0.42 0.63 +vn 0.33 -0.37 0.87 +vn 0.34 0.72 0.61 +vn 0.48 0.61 0.63 +vn 0.03 0.84 0.55 +vn 0.04 0.85 0.53 +vn 0.79 0.23 0.57 +vn 0.76 0.30 0.58 +vn 0.84 0.28 0.46 +vn 0.97 0.12 -0.19 +vn 0.68 0.22 0.70 +vn 0.29 0.04 0.96 +vn 0.93 -0.27 0.23 +vn -0.13 0.06 0.99 +vn 0.55 -0.05 -0.83 +vn 0.92 -0.39 -0.07 +vn 0.99 0.12 -0.04 +vn 0.81 0.20 -0.56 +vn -0.21 0.97 -0.11 +vn 0.17 0.97 0.15 +vn -0.07 0.95 0.31 +vn -0.50 0.70 0.50 +vn -0.56 0.64 0.53 +vn 0.18 0.03 0.98 +vn 0.43 0.09 0.90 +vn 0.15 -0.24 0.96 +vn 0.84 -0.52 0.16 +vn -0.10 0.04 0.99 +vn -0.11 0.19 0.98 +vn 0.38 -0.08 -0.92 +vn 0.93 -0.31 -0.20 +vn 0.30 0.25 -0.92 +vn -0.16 0.43 -0.89 +vn -0.21 0.50 -0.84 +vn -0.56 0.64 -0.52 +vn -0.49 0.67 -0.55 +vn -0.32 0.78 0.54 +vn 0.36 -0.26 0.89 +vn 0.12 0.99 -0.05 +vn 0.28 -0.58 0.77 +vn 0.47 -0.61 0.64 +vn 0.20 -0.48 0.85 +vn 0.12 -0.55 0.83 +vn 0.03 -0.35 0.94 +vn 0.88 0.32 -0.35 +vn 0.30 0.56 -0.77 +vn 0.78 0.54 -0.31 +vn -0.07 0.68 -0.73 +vn -0.42 0.77 -0.47 +vn 0.19 0.93 -0.32 +vn 0.71 -0.10 0.70 +vn -0.05 -0.13 0.99 +vn 0.95 0.06 -0.32 +vn 0.70 -0.26 -0.66 +vn 0.75 -0.25 -0.61 +vn 0.24 -0.51 0.82 +vn 0.78 -0.62 -0.05 +vn 0.51 -0.85 -0.10 +vn 0.00 -1.00 0.04 +vn 0.00 -1.00 0.09 +vn 0.00 -0.97 -0.25 +vn 0.00 -0.97 0.23 +vn -0.00 -0.82 0.57 +vn -0.11 -0.94 -0.33 +vn 0.00 -0.99 -0.12 +vn 0.85 0.39 0.35 +vn 0.68 0.72 0.14 +vn 0.83 -0.50 0.25 +vn 0.52 -0.75 0.41 +vn 0.56 -0.73 0.40 +vn 0.83 -0.49 0.26 +vn 0.84 -0.16 0.51 +vn 0.85 -0.22 0.48 +vn 0.43 0.22 0.88 +vn -0.12 -0.11 0.99 +vn -0.16 -0.00 0.99 +vn 0.44 0.29 0.85 +vn 0.04 0.65 0.76 +vn 0.02 0.67 0.75 +vn 0.26 -0.87 0.42 +vn 0.28 -0.86 0.43 +vn -0.38 0.91 0.18 +vn 0.43 0.89 0.13 +vn 0.35 0.71 0.61 +vn 0.39 0.12 0.91 +vn -0.10 -0.68 0.73 +vn -0.20 -0.05 0.98 +vn -0.17 0.11 0.98 +vn 0.34 -0.17 0.93 +vn 0.37 0.39 0.84 +vn 0.72 0.46 0.52 +vn 0.29 0.86 0.42 +vn 0.08 0.66 0.74 +vn 0.76 -0.13 -0.64 +vn 0.95 0.07 -0.32 +vn 0.54 -0.69 -0.48 +vn -0.05 -0.76 -0.64 +vn -0.05 -0.25 -0.97 +vn -0.57 -0.71 -0.41 +vn -0.80 -0.15 -0.58 +vn -0.98 0.05 -0.21 +vn -0.99 0.05 0.11 +vn -0.70 0.71 0.07 +vn -0.68 0.41 0.62 +vn -0.33 0.94 0.08 +vn 0.07 0.47 0.88 +vn 0.00 0.99 0.16 +vn 0.34 0.94 0.02 +vn 0.79 0.41 0.45 +vn 0.74 0.67 -0.09 +vn 0.99 -0.03 -0.16 +vn 0.94 -0.02 0.33 +vn 0.61 -0.73 0.30 +vn 0.60 -0.80 -0.09 +vn 0.17 -0.66 0.73 +vn 0.16 -0.85 0.49 +vn -0.09 -0.85 0.51 +vn -0.90 -0.02 0.43 +vn -1.00 -0.01 -0.05 +vn -0.64 -0.77 -0.03 +vn -0.59 -0.73 0.36 +vn -0.80 0.51 0.31 +vn -0.70 0.70 -0.12 +vn -0.28 0.76 0.59 +vn -0.41 0.91 -0.09 +vn -0.01 1.00 0.01 +vn -0.03 0.81 0.59 +vn 0.46 0.58 0.68 +vn 0.39 0.92 -0.06 +vn 0.84 0.50 0.22 +vn 0.69 0.70 -0.20 +vn 0.39 0.09 0.92 +vn 0.02 0.07 1.00 +vn -0.27 0.10 0.96 +vn -0.37 0.11 0.92 +vn -0.37 0.57 0.74 +vn -0.37 0.93 -0.04 +vn 0.37 0.92 -0.09 +vn 0.32 0.78 0.54 +vn 0.47 0.11 0.88 +vn -0.13 -0.67 0.73 +vn 0.95 -0.12 -0.30 +vn 0.96 0.14 0.25 +vn 0.81 -0.37 0.46 +vn 0.92 0.15 0.37 +vn 0.89 -0.20 0.42 +vn 0.96 0.09 0.27 +vn 0.94 -0.03 0.34 +vn 0.94 -0.11 0.33 +vn 0.17 0.83 -0.53 +vn 0.40 -0.78 -0.48 +vn 0.00 -0.41 -0.91 +vn -0.21 -0.86 0.46 +vn -0.35 -0.80 0.49 +vn 0.00 -0.85 0.53 +vn -0.00 0.87 -0.50 +vn 0.07 0.87 -0.49 +vn 0.08 0.86 -0.51 +vn 0.39 0.56 -0.73 +vn -0.06 0.92 -0.38 +vn 0.97 0.17 0.19 +vn 0.74 0.03 0.67 +vn 0.42 -0.42 0.81 +vn 0.99 -0.05 0.13 +vn 0.71 0.41 0.58 +vn 0.89 0.44 0.14 +vn 0.83 0.28 -0.49 +vn 0.75 0.50 -0.43 +vn 0.25 0.29 -0.92 +vn 0.38 0.60 -0.70 +vn -0.04 0.60 -0.80 +vn -0.21 0.19 -0.96 +vn 0.76 0.15 -0.64 +vn 0.90 0.14 -0.42 +vn 0.81 0.16 -0.56 +vn 0.02 -0.04 -1.00 +vn 0.58 0.69 -0.44 +vn 0.70 0.69 0.16 +vn 0.93 -0.31 0.18 +vn 0.92 -0.22 0.32 +vn 0.88 -0.10 -0.47 +vn -0.09 -0.11 -0.99 +vn -0.05 0.50 -0.86 +vn 0.83 -0.21 -0.52 +vn 0.93 -0.12 0.34 +vn -0.14 -0.34 -0.93 +vn 0.95 -0.30 -0.03 +vn -0.90 -0.29 0.33 +vn -0.92 0.13 -0.37 +vn -0.94 -0.13 -0.33 +vn -0.85 -0.25 0.47 +vn -0.87 -0.12 0.48 +vn 0.02 -0.06 1.00 +vn 0.06 -0.42 0.91 +vn -0.92 -0.19 -0.35 +vn 0.08 -0.74 0.67 +vn 0.21 -0.74 0.64 +vn -0.77 -0.45 0.45 +vn -0.99 -0.09 0.06 +vn -0.92 0.02 -0.39 +vn 0.71 -0.39 -0.58 +vn -0.07 -0.47 -0.88 +vn 0.00 -0.40 -0.92 +vn 0.72 -0.38 -0.58 +vn -0.65 -0.28 -0.70 +vn -0.61 -0.37 -0.70 +vn -0.97 -0.13 -0.22 +vn -0.70 -0.06 0.71 +vn 0.22 -0.17 0.96 +vn 0.25 -0.16 0.95 +vn 0.80 -0.18 0.57 +vn 0.73 -0.19 0.66 +vn 0.06 -0.20 -0.98 +vn 0.76 -0.20 -0.62 +vn -0.66 -0.23 0.72 +vn 0.17 -0.18 0.97 +vn 0.75 -0.13 0.65 +vn 0.98 -0.21 0.04 +vn 0.99 -0.13 0.09 +vn 0.84 0.13 -0.53 +vn 0.76 0.01 -0.65 +vn 0.89 0.36 0.26 +vn 0.93 0.36 -0.03 +vn 0.95 -0.29 0.11 +vn 0.67 -0.51 -0.54 +vn 0.39 -0.61 -0.69 +vn -0.04 -0.50 -0.87 +vn -0.77 -0.14 -0.62 +vn -0.08 -0.32 -0.94 +vn -1.00 0.00 -0.05 +vn -0.76 0.28 0.59 +vn 0.99 0.15 0.06 +vn 0.45 -0.15 0.88 +vn 0.81 0.05 0.58 +vn 0.17 0.11 0.98 +vn 0.15 -0.03 0.99 +vn -0.75 0.11 0.66 +vn -0.71 0.12 0.69 +vn 0.71 -0.05 0.70 +vn 0.69 -0.07 0.72 +vn 0.94 -0.31 0.16 +vn 0.97 -0.23 0.06 +vn -0.03 -0.42 -0.91 +vn 0.69 -0.48 -0.54 +vn 0.70 -0.25 -0.67 +vn 0.03 -0.23 -0.97 +vn 0.98 -0.21 0.06 +vn -0.58 -0.25 -0.77 +vn -1.00 0.03 -0.08 +vn -0.75 -0.15 -0.65 +vn 0.01 -0.19 -0.98 +vn -1.00 -0.03 0.04 +vn -0.67 0.12 0.73 +vn 0.18 0.34 0.92 +vn 0.80 0.23 0.55 +vn 1.00 -0.03 -0.04 +vn 0.68 -0.23 -0.70 +vn 0.28 -0.77 0.57 +vn 0.00 -0.74 0.68 +vn 0.00 -0.49 0.87 +vn 0.35 -0.56 0.75 +vn 0.66 -0.65 0.39 +vn 0.54 -0.79 0.29 +vn 0.85 -0.52 -0.02 +vn 0.83 -0.56 -0.05 +vn 0.74 -0.65 0.19 +vn 0.00 0.23 -0.97 +vn 0.48 0.15 -0.86 +vn 0.80 -0.15 -0.58 +vn 0.89 -0.36 -0.28 +vn 0.79 0.09 -0.60 +vn 0.47 0.16 -0.87 +vn 0.00 0.22 -0.98 +vn 0.48 0.43 0.77 +vn -0.00 0.48 0.88 +vn 0.00 0.61 0.79 +vn 0.50 0.52 0.69 +vn 0.65 0.14 0.75 +vn 0.00 0.15 0.99 +vn -0.00 -0.52 0.85 +vn 0.59 0.10 0.80 +vn 0.12 -0.29 0.95 +vn 0.58 -0.20 0.79 +vn 0.25 -0.18 0.95 +vn 0.41 -0.51 0.76 +vn -0.10 -0.71 0.69 +vn 0.18 -0.70 0.69 +vn 0.84 0.30 0.46 +vn 0.52 -0.61 0.60 +vn 0.63 -0.44 0.64 +vn 0.53 -0.47 0.71 +vn 0.47 -0.51 0.72 +vn 0.00 0.98 0.20 +vn 0.00 0.87 0.50 +vn 0.42 -0.86 0.28 +vn 0.86 0.11 0.50 +vn 0.83 -0.34 0.45 +vn 0.95 -0.30 0.13 +vn -0.00 0.16 0.99 +vn -0.00 0.35 0.94 +vn 0.42 0.25 0.87 +vn 0.32 0.05 0.95 +vn -0.00 0.25 0.97 +vn 0.38 0.31 0.87 +vn 0.27 0.68 0.68 +vn -0.00 0.66 0.75 +vn 0.67 -0.07 0.74 +vn 0.60 -0.04 0.80 +vn 0.51 -0.10 0.85 +vn 0.70 0.08 0.71 +vn 0.30 0.74 0.61 +vn 0.00 0.76 0.65 +vn 0.50 -0.23 0.84 +vn 0.49 -0.32 0.81 +vn 0.57 -0.18 0.80 +vn 0.58 -0.01 0.81 +vn -0.26 -0.76 0.59 +vn -0.16 -0.83 0.54 +vn 0.36 0.80 -0.48 +vn 0.01 0.84 -0.54 +vn 0.00 0.98 -0.18 +vn 0.36 -0.80 0.48 +vn 0.33 -0.93 0.17 +vn 0.51 -0.75 0.42 +vn 0.57 -0.53 0.62 +vn 0.62 -0.70 0.36 +vn 0.57 -0.66 0.48 +vn 0.41 -0.87 0.26 +vn 0.23 -0.93 0.28 +vn 0.25 -0.96 0.08 +vn 0.00 0.55 0.83 +vn 0.75 0.21 0.63 +vn 0.54 0.43 0.73 +vn 0.52 0.06 0.85 +vn 0.55 0.66 0.51 +vn 0.84 0.44 0.32 +vn 0.31 0.56 0.77 +vn 0.26 0.19 0.95 +vn 0.86 0.07 0.50 +vn 0.95 0.16 0.25 +vn 0.82 0.55 0.19 +vn 0.84 0.50 0.19 +vn 0.95 0.26 0.17 +vn 0.95 0.31 0.03 +vn 0.23 -0.68 0.70 +vn -0.00 -0.70 0.71 +vn -0.00 -0.90 0.44 +vn -0.00 -1.00 0.04 +vn -0.00 -1.00 -0.01 +vn 0.00 -0.96 0.30 +vn 0.72 -0.37 0.59 +vn 0.63 0.73 0.28 +vn 0.86 0.49 0.13 +vn 0.94 0.31 -0.16 +vn 0.00 0.57 0.82 +vn 0.77 0.29 0.57 +vn 0.83 0.23 0.51 +vn 0.67 -0.10 0.74 +vn 0.64 0.08 0.76 +vn 0.50 0.45 0.74 +vn 0.79 0.39 0.48 +vn 0.61 0.14 0.78 +vn 0.77 0.33 0.55 +vn 0.50 -0.31 0.81 +vn 0.54 -0.04 0.84 +vn 0.51 -0.15 0.85 +vn 0.59 -0.46 0.67 +vn 0.43 -0.27 0.86 +vn 0.42 0.43 0.80 +vn 0.14 0.69 0.72 +vn 0.42 0.64 0.64 +vn 0.47 0.49 -0.74 +vn 0.01 0.54 -0.84 +vn 0.95 -0.01 -0.32 +vn 0.62 0.13 0.77 +vn 0.56 -0.40 0.72 +vn -0.15 -0.42 0.90 +vn -0.23 -0.66 0.72 +vn -0.30 -0.78 0.55 +vn -0.04 -0.71 0.70 +vn -0.25 -0.45 0.86 +vn -0.32 -0.71 0.62 +vn 0.60 0.31 0.74 +vn 0.56 0.64 0.53 +vn 0.79 -0.15 0.60 +vn 0.62 -0.28 0.74 +vn 0.29 0.58 0.76 +vn 0.58 0.32 0.75 +vn 0.74 -0.00 0.67 +vn 0.24 0.32 0.92 +vn 0.95 -0.23 -0.23 +vn 0.98 0.19 -0.04 +vn 0.95 0.30 0.14 +vn 0.92 0.30 0.23 +vn -0.00 -0.44 0.90 +vn 0.36 -0.41 0.84 +vn 0.67 0.57 0.48 +vn -0.14 -0.87 0.47 +vn -0.04 -0.88 0.47 +vn -0.05 -0.48 0.87 +vn -0.14 -0.48 0.87 +vn -0.12 0.02 0.99 +vn -0.18 0.29 0.94 +vn -0.34 0.36 0.87 +vn -0.29 -0.10 0.95 +vn -0.15 -0.33 0.93 +vn -0.02 -0.23 0.97 +vn 0.17 -0.36 0.92 +vn 0.07 -0.45 0.89 +vn 0.41 -0.33 0.85 +vn 0.37 -0.37 0.85 +vn 0.55 -0.16 0.82 +vn 0.59 -0.11 0.80 +vn 0.67 0.06 0.74 +vn 0.64 0.03 0.77 +vn 0.63 0.12 0.76 +vn 0.41 -0.07 0.91 +vn 0.62 0.26 0.74 +vn 0.59 0.30 0.75 +vn 0.66 0.14 0.74 +vn 0.45 0.33 0.83 +vn 0.50 0.27 0.82 +vn 0.14 0.44 0.89 +vn 0.06 0.54 0.84 +vn 0.19 0.14 0.97 +vn 0.74 -0.02 0.67 +vn 0.70 -0.21 -0.69 +vn -0.78 -0.13 -0.62 +vn -1.00 0.02 -0.03 +vn -0.70 -0.14 -0.70 +vn -0.65 0.76 0.07 +vn -0.61 0.79 -0.04 +vn -0.49 0.82 -0.29 +vn -0.56 0.82 0.10 +vn 0.34 -0.51 -0.79 +vn 0.08 -0.02 -1.00 +vn -0.94 0.33 -0.02 +vn -0.90 0.42 -0.11 +vn -0.96 -0.27 0.06 +vn -0.80 -0.26 -0.55 +vn -0.97 -0.22 0.10 +vn -0.77 -0.12 0.62 +vn -0.31 -0.83 0.46 +vn -0.77 -0.64 -0.03 +vn -0.60 0.77 -0.22 +vn -0.28 -0.83 -0.48 +vn -0.78 -0.62 0.03 +vn -0.50 -0.86 0.04 +vn -0.45 -0.89 0.10 +vn -0.47 -0.86 -0.18 +vn -0.41 -0.85 -0.32 +vn -0.82 0.57 -0.03 +vn -0.86 0.51 -0.01 +vn -0.65 0.71 -0.27 +vn -0.65 -0.32 -0.69 +vn -0.44 -0.79 -0.42 +vn -0.95 -0.02 -0.30 +vn -0.98 0.17 -0.11 +vn 0.08 -0.49 -0.87 +vn 0.04 -0.84 -0.53 +vn 0.76 -0.19 -0.62 +vn 0.52 -0.78 -0.35 +vn 0.99 0.03 -0.16 +vn 0.95 0.30 0.02 +vn 0.75 0.64 0.15 +vn 0.67 0.63 0.40 +vn 0.33 0.91 0.24 +vn -0.04 0.73 0.69 +vn -0.70 0.63 0.35 +vn -0.36 0.91 0.18 +vn -0.02 0.96 0.30 +vn -0.77 0.63 0.07 +vn -1.00 -0.00 -0.09 +vn -0.63 -0.78 -0.06 +vn -0.60 -0.72 0.35 +vn -0.93 -0.01 0.37 +vn -0.14 -0.67 0.73 +vn -0.00 -1.00 0.00 +vn -0.14 -0.82 0.55 +vn -0.01 -0.69 0.72 +vn 0.08 -0.82 0.57 +vn 1.00 0.03 0.03 +vn 0.87 -0.01 0.49 +vn 0.56 -0.71 0.42 +vn 0.66 -0.75 0.02 +vn 0.78 0.53 0.34 +vn 0.73 0.68 0.07 +vn 0.43 0.89 0.17 +vn 0.25 0.73 0.63 +vn -0.39 0.91 0.14 +vn -0.35 0.54 0.77 +vn 0.02 0.76 0.65 +vn -0.00 0.99 0.12 +vn -0.82 0.52 0.25 +vn -0.74 0.68 0.01 +vn -0.30 0.11 0.95 +vn -0.02 0.09 1.00 +vn 0.21 0.11 0.97 +vn 0.31 0.12 0.94 +vn 0.29 0.53 0.80 +vn 0.41 -0.91 0.06 +vn -0.27 -0.94 0.19 +vn -0.15 -0.89 0.43 +vn -0.33 -0.81 0.49 +vn -0.54 -0.71 -0.46 +vn -0.97 -0.24 -0.02 +vn -0.94 0.33 0.01 +vn -0.70 0.70 0.14 +vn -0.21 0.35 -0.91 +vn -0.76 0.53 -0.36 +vn -1.00 0.02 -0.05 +vn -1.00 0.03 -0.03 +vn -0.97 0.23 0.00 +vn -1.00 -0.01 -0.06 +vn -0.73 0.68 -0.05 +vn -0.92 0.22 -0.33 +vn -0.37 -0.47 0.80 +vn -0.44 -0.60 0.67 +vn -0.67 0.52 -0.52 +vn -0.92 0.31 -0.22 +vn -0.87 0.28 0.41 +vn -0.94 0.13 0.31 +vn -0.54 0.26 -0.80 +vn -0.35 -0.31 0.88 +vn -0.57 -0.23 0.79 +vn -0.76 -0.09 0.65 +vn -0.66 -0.10 0.75 +vn -0.43 -0.43 0.79 +vn -0.85 -0.06 -0.53 +vn -0.90 -0.33 0.29 +vn -0.97 -0.18 -0.15 +vn -0.65 -0.42 0.63 +vn -0.33 -0.37 0.87 +vn -0.33 0.72 0.61 +vn -0.04 0.85 0.53 +vn -0.03 0.84 0.55 +vn -0.48 0.61 0.63 +vn -0.79 0.22 0.58 +vn -0.84 0.28 0.46 +vn -0.69 0.22 0.69 +vn -0.98 0.12 -0.16 +vn -0.29 0.04 0.96 +vn -0.93 -0.27 0.24 +vn 0.14 0.05 0.99 +vn -0.57 -0.07 -0.82 +vn -0.79 0.15 -0.60 +vn -0.99 0.10 -0.07 +vn -0.92 -0.38 -0.07 +vn 0.22 0.97 -0.11 +vn 0.07 0.95 0.31 +vn -0.17 0.97 0.15 +vn 0.51 0.70 0.50 +vn -0.43 0.09 0.90 +vn -0.16 0.05 0.99 +vn -0.83 -0.53 0.17 +vn -0.15 -0.24 0.96 +vn 0.10 0.04 0.99 +vn 0.11 0.18 0.98 +vn -0.41 -0.08 -0.91 +vn -0.93 -0.30 -0.20 +vn -0.32 0.26 -0.91 +vn 0.20 0.53 -0.82 +vn 0.17 0.43 -0.88 +vn 0.51 0.68 -0.53 +vn 0.56 0.64 -0.52 +vn -0.12 0.99 -0.05 +vn -0.36 -0.26 0.89 +vn -0.20 -0.48 0.85 +vn -0.47 -0.61 0.64 +vn -0.28 -0.58 0.77 +vn -0.12 -0.55 0.83 +vn -0.03 -0.35 0.94 +vn -0.88 0.32 -0.35 +vn -0.78 0.54 -0.31 +vn -0.30 0.56 -0.77 +vn 0.07 0.68 -0.73 +vn -0.19 0.93 -0.32 +vn 0.42 0.77 -0.47 +vn -0.71 -0.09 0.70 +vn 0.05 -0.13 0.99 +vn -0.95 0.06 -0.32 +vn -0.72 -0.27 -0.64 +vn -0.74 -0.27 -0.61 +vn -0.25 -0.51 0.83 +vn -0.78 -0.62 -0.05 +vn -0.51 -0.85 -0.10 +vn 0.11 -0.94 -0.33 +vn -0.85 0.39 0.35 +vn -0.68 0.72 0.14 +vn -0.82 -0.51 0.25 +vn -0.83 -0.49 0.27 +vn -0.56 -0.73 0.40 +vn -0.53 -0.74 0.42 +vn -0.84 -0.24 0.49 +vn -0.84 -0.18 0.52 +vn -0.43 0.22 0.87 +vn -0.45 0.29 0.85 +vn 0.16 -0.00 0.99 +vn 0.12 -0.11 0.99 +vn -0.02 0.67 0.75 +vn -0.04 0.65 0.76 +vn -0.29 -0.85 0.43 +vn -0.27 -0.86 0.42 +vn 0.38 0.91 0.18 +vn -0.35 0.71 0.61 +vn -0.43 0.89 0.13 +vn -0.39 0.12 0.91 +vn 0.10 -0.68 0.73 +vn 0.17 0.10 0.98 +vn 0.21 -0.05 0.98 +vn -0.31 -0.14 0.94 +vn -0.71 0.47 0.52 +vn -0.36 0.38 0.85 +vn -0.08 0.66 0.74 +vn -0.29 0.86 0.42 +vn -0.76 -0.13 -0.64 +vn -0.54 -0.69 -0.48 +vn -0.95 0.07 -0.32 +vn -1.00 0.03 -0.04 +vn 0.05 -0.25 -0.97 +vn 0.05 -0.76 -0.64 +vn 0.80 -0.14 -0.58 +vn 0.57 -0.71 -0.41 +vn 0.98 0.05 -0.21 +vn 0.99 0.05 0.11 +vn 0.68 0.41 0.62 +vn 0.70 0.71 0.07 +vn -0.07 0.47 0.88 +vn 0.33 0.94 0.08 +vn -0.00 0.99 0.16 +vn -0.34 0.94 0.02 +vn -0.74 0.67 -0.09 +vn -0.79 0.41 0.45 +vn -0.99 -0.03 -0.16 +vn -0.60 -0.80 -0.09 +vn -0.61 -0.73 0.30 +vn -0.94 -0.02 0.33 +vn -0.17 -0.66 0.73 +vn -0.16 -0.85 0.49 +vn 0.09 -0.85 0.51 +vn 0.90 -0.02 0.43 +vn 0.59 -0.73 0.36 +vn 0.64 -0.77 -0.03 +vn 1.00 -0.01 -0.05 +vn 0.80 0.51 0.31 +vn 0.70 0.70 -0.12 +vn 0.41 0.91 -0.09 +vn 0.28 0.76 0.59 +vn 0.01 1.00 0.01 +vn -0.39 0.92 -0.06 +vn -0.46 0.58 0.68 +vn 0.03 0.81 0.59 +vn -0.84 0.50 0.22 +vn -0.69 0.70 -0.20 +vn -0.39 0.09 0.92 +vn -0.02 0.07 1.00 +vn 0.27 0.10 0.96 +vn 0.37 0.11 0.92 +vn 0.37 0.57 0.74 +vn 0.37 0.93 -0.04 +vn -0.37 0.92 -0.09 +vn -0.47 0.11 0.88 +vn 0.13 -0.67 0.73 +vn -0.95 -0.12 -0.30 +vn -0.96 0.14 0.25 +vn -0.92 0.14 0.36 +vn -0.81 -0.37 0.46 +vn -0.89 -0.19 0.41 +vn -0.96 0.09 0.27 +vn -0.94 -0.11 0.33 +vn -0.94 -0.03 0.34 +vn -0.17 0.83 -0.53 +vn -0.40 -0.79 -0.47 +vn 0.35 -0.80 0.49 +vn 0.21 -0.86 0.46 +vn -0.07 0.87 -0.49 +vn -0.08 0.86 -0.51 +vn -0.40 0.56 -0.72 +vn 0.07 0.92 -0.38 +vn -0.97 0.17 0.19 +vn -0.99 -0.05 0.13 +vn -0.42 -0.42 0.81 +vn -0.74 0.03 0.67 +vn -0.71 0.41 0.58 +vn -0.89 0.44 0.14 +vn -0.75 0.50 -0.43 +vn -0.83 0.28 -0.49 +vn -0.25 0.29 -0.92 +vn -0.38 0.60 -0.70 +vn 0.04 0.60 -0.80 +vn -0.90 0.14 -0.42 +vn -0.76 0.15 -0.64 +vn 0.21 0.19 -0.96 +vn -0.02 -0.04 -1.00 +vn -0.81 0.16 -0.56 +vn -0.70 0.69 0.16 +vn -0.58 0.69 -0.44 +vn -0.93 -0.31 0.18 +vn -0.88 -0.11 -0.47 +vn -0.92 -0.22 0.32 +vn 0.05 0.50 -0.86 +vn 0.09 -0.12 -0.99 +vn -0.83 -0.21 -0.52 +vn -0.93 -0.12 0.34 +vn 0.14 -0.34 -0.93 +vn -0.95 -0.30 -0.03 +vn 0.90 -0.29 0.33 +vn 0.85 -0.25 0.47 +vn 0.94 -0.13 -0.33 +vn 0.92 0.13 -0.37 +vn 0.87 -0.12 0.48 +vn -0.06 -0.42 0.91 +vn -0.02 -0.06 1.00 +vn 0.92 -0.19 -0.35 +vn -0.08 -0.74 0.67 +vn 0.77 -0.45 0.45 +vn -0.21 -0.74 0.64 +vn 0.99 -0.09 0.06 +vn 0.92 0.02 -0.39 +vn -0.71 -0.39 -0.58 +vn -0.72 -0.38 -0.58 +vn -0.00 -0.40 -0.92 +vn 0.07 -0.47 -0.88 +vn 0.61 -0.37 -0.70 +vn 0.65 -0.28 -0.70 +vn 0.97 -0.13 -0.22 +vn 0.70 -0.06 0.71 +vn -0.25 -0.17 0.95 +vn -0.22 -0.17 0.96 +vn -0.80 -0.18 0.57 +vn -0.73 -0.19 0.66 +vn -0.76 -0.21 -0.62 +vn -0.06 -0.20 -0.98 +vn 0.66 -0.23 0.72 +vn -0.17 -0.18 0.97 +vn -0.75 -0.13 0.65 +vn -0.98 -0.21 0.04 +vn -0.99 -0.13 0.09 +vn -0.76 0.00 -0.65 +vn -0.83 0.12 -0.54 +vn -0.89 0.36 0.26 +vn -0.93 0.36 -0.03 +vn -0.95 -0.29 0.11 +vn -0.39 -0.61 -0.69 +vn 0.04 -0.50 -0.87 +vn -0.67 -0.51 -0.54 +vn 0.08 -0.32 -0.94 +vn 0.77 -0.14 -0.62 +vn 0.76 0.28 0.59 +vn -0.99 0.15 0.06 +vn -0.46 -0.15 0.88 +vn -0.81 0.05 0.58 +vn 0.71 0.12 0.69 +vn 0.75 0.11 0.66 +vn -0.15 -0.03 0.99 +vn -0.71 -0.05 0.70 +vn -0.69 -0.07 0.72 +vn -0.94 -0.31 0.16 +vn -0.97 -0.23 0.06 +vn 0.03 -0.42 -0.91 +vn -0.03 -0.23 -0.97 +vn -0.70 -0.25 -0.67 +vn -0.69 -0.48 -0.54 +vn -0.98 -0.21 0.06 +vn 0.58 -0.25 -0.77 +vn 1.00 0.03 -0.08 +vn -0.01 -0.19 -0.98 +vn 0.75 -0.15 -0.65 +vn 1.00 -0.03 0.04 +vn 0.67 0.12 0.73 +vn -0.18 0.34 0.92 +vn -0.80 0.23 0.55 +vn -1.00 -0.03 -0.04 +vn -0.68 -0.23 -0.70 +vn -0.28 -0.77 0.57 +vn -0.35 -0.56 0.75 +vn -0.54 -0.79 0.29 +vn -0.66 -0.65 0.39 +vn -0.74 -0.65 0.19 +vn -0.83 -0.56 -0.05 +vn -0.85 -0.52 -0.02 +vn -0.49 0.15 -0.86 +vn -0.89 -0.36 -0.28 +vn -0.80 -0.12 -0.58 +vn -0.76 0.08 -0.64 +vn -0.48 0.43 0.77 +vn -0.50 0.52 0.69 +vn -0.58 0.10 0.80 +vn -0.28 -0.34 0.90 +vn -0.65 0.14 0.75 +vn -0.58 -0.21 0.79 +vn -0.41 -0.51 0.76 +vn -0.25 -0.18 0.95 +vn -0.18 -0.70 0.69 +vn 0.10 -0.71 0.69 +vn -0.84 0.30 0.46 +vn -0.52 -0.61 0.60 +vn -0.47 -0.51 0.72 +vn -0.53 -0.47 0.71 +vn -0.63 -0.44 0.64 +vn -0.42 -0.86 0.28 +vn -0.86 0.11 0.50 +vn -0.95 -0.30 0.13 +vn -0.83 -0.34 0.45 +vn -0.32 0.05 0.95 +vn -0.43 0.25 0.87 +vn -0.27 0.68 0.68 +vn -0.38 0.31 0.87 +vn -0.60 -0.04 0.80 +vn -0.67 -0.07 0.74 +vn -0.51 -0.10 0.86 +vn -0.70 0.07 0.71 +vn -0.30 0.74 0.61 +vn -0.58 -0.18 0.79 +vn -0.49 -0.32 0.81 +vn -0.51 -0.22 0.83 +vn -0.59 -0.01 0.81 +vn 0.16 -0.83 0.54 +vn 0.26 -0.76 0.59 +vn -0.35 0.80 -0.49 +vn -0.36 -0.80 0.48 +vn -0.57 -0.53 0.62 +vn -0.51 -0.75 0.42 +vn -0.33 -0.93 0.17 +vn -0.62 -0.70 0.36 +vn -0.41 -0.87 0.26 +vn -0.57 -0.66 0.48 +vn -0.23 -0.93 0.28 +vn -0.25 -0.96 0.08 +vn -0.52 0.07 0.85 +vn -0.54 0.43 0.73 +vn -0.75 0.21 0.62 +vn -0.55 0.66 0.50 +vn -0.84 0.44 0.32 +vn -0.31 0.56 0.77 +vn -0.26 0.19 0.95 +vn -0.95 0.18 0.25 +vn -0.87 0.07 0.48 +vn -0.82 0.54 0.20 +vn -0.95 0.31 0.06 +vn -0.95 0.27 0.17 +vn -0.84 0.50 0.19 +vn -0.23 -0.68 0.70 +vn -0.72 -0.37 0.59 +vn -0.63 0.73 0.29 +vn -0.87 0.48 0.15 +vn -0.95 0.31 -0.10 +vn -0.77 0.29 0.57 +vn -0.84 0.24 0.50 +vn -0.65 0.08 0.76 +vn -0.68 -0.09 0.73 +vn -0.50 0.45 0.74 +vn -0.60 0.14 0.79 +vn -0.79 0.39 0.48 +vn -0.77 0.33 0.55 +vn -0.51 -0.30 0.81 +vn -0.55 -0.04 0.84 +vn -0.51 -0.15 0.85 +vn -0.44 -0.27 0.86 +vn -0.59 -0.46 0.67 +vn -0.42 0.43 0.80 +vn -0.42 0.66 0.63 +vn -0.13 0.70 0.71 +vn -0.48 0.47 -0.74 +vn -0.93 0.00 -0.36 +vn -0.62 0.13 0.77 +vn -0.56 -0.40 0.72 +vn 0.15 -0.42 0.90 +vn 0.04 -0.24 0.97 +vn 0.24 -0.66 0.72 +vn 0.30 -0.78 0.55 +vn 0.26 -0.45 0.86 +vn 0.10 -0.39 0.92 +vn 0.33 -0.71 0.62 +vn -0.60 0.31 0.74 +vn -0.61 -0.29 0.74 +vn -0.78 -0.17 0.61 +vn -0.28 0.58 0.76 +vn -0.58 0.32 0.75 +vn -0.75 -0.01 0.67 +vn -0.23 0.32 0.92 +vn -0.94 -0.23 -0.24 +vn -0.98 0.19 -0.04 +vn -0.94 0.31 0.14 +vn -0.92 0.32 0.24 +vn -0.36 -0.40 0.84 +vn -0.67 0.57 0.48 +vn 0.03 -0.88 0.47 +vn 0.14 -0.87 0.47 +vn 0.14 -0.48 0.87 +vn 0.05 -0.49 0.87 +vn 0.12 0.03 0.99 +vn 0.29 -0.10 0.95 +vn 0.34 0.37 0.87 +vn 0.18 0.30 0.94 +vn 0.15 -0.33 0.93 +vn 0.02 -0.23 0.97 +vn -0.17 -0.37 0.91 +vn -0.06 -0.45 0.89 +vn -0.41 -0.34 0.85 +vn -0.37 -0.37 0.85 +vn -0.56 -0.16 0.81 +vn -0.59 -0.12 0.80 +vn -0.65 0.02 0.76 +vn -0.68 0.05 0.73 +vn -0.63 0.26 0.73 +vn -0.42 -0.06 0.91 +vn -0.64 0.12 0.76 +vn -0.66 0.13 0.74 +vn -0.60 0.29 0.75 +vn -0.45 0.33 0.83 +vn -0.50 0.27 0.82 +vn -0.14 0.44 0.89 +vn -0.06 0.54 0.84 +vn -0.19 0.14 0.97 +vn -0.74 -0.02 0.67 +vn -0.70 -0.21 -0.69 +vn 0.78 -0.13 -0.62 +vn 1.00 0.02 -0.03 +vn 0.70 -0.14 -0.70 +vn 0.04 -0.08 1.00 +vn 0.16 0.09 0.98 +vn 0.31 -0.03 0.95 +vn 0.16 -0.17 0.97 +vn 0.42 0.01 0.91 +vn 0.51 -0.06 0.86 +vn 0.51 -0.03 0.86 +vn 0.44 0.07 0.90 +vn 0.34 0.14 0.93 +vn 0.25 0.15 0.96 +vn 0.47 0.02 0.88 +vn 0.39 -0.09 0.92 +vn 0.46 -0.04 0.89 +vn 0.37 0.04 0.93 +vn 0.49 0.07 0.87 +vn 0.20 0.22 0.96 +vn 0.20 0.25 0.95 +vn -0.01 0.23 0.97 +vn -0.09 -0.44 0.89 +vn -0.51 -0.06 0.86 +vn -0.42 0.01 0.91 +vn -0.31 -0.03 0.95 +vn -0.16 -0.18 0.97 +vn -0.16 0.09 0.98 +vn -0.04 -0.09 1.00 +vn -0.34 0.15 0.93 +vn -0.44 0.07 0.90 +vn -0.51 -0.03 0.86 +vn -0.25 0.15 0.96 +vn -0.47 0.02 0.88 +vn -0.46 -0.04 0.89 +vn -0.39 -0.09 0.92 +vn -0.37 0.04 0.93 +vn -0.19 0.23 0.95 +vn -0.49 0.07 0.87 +vn -0.20 0.25 0.95 +vn 0.02 0.23 0.97 +vn 0.08 -0.45 0.89 +# 1090 vertex normals + +vt 0.95 0.25 0.00 +vt 0.94 0.29 0.00 +vt 0.90 0.30 0.00 +vt 0.90 0.26 0.00 +vt 0.91 0.09 0.00 +vt 0.95 0.09 0.00 +vt 0.96 0.13 0.00 +vt 0.91 0.13 0.00 +vt 0.80 0.03 0.00 +vt 0.81 0.06 0.00 +vt 0.76 0.07 0.00 +vt 0.75 0.05 0.00 +vt 0.84 0.27 0.00 +vt 0.85 0.30 0.00 +vt 0.76 0.28 0.00 +vt 0.76 0.31 0.00 +vt 0.77 0.19 0.00 +vt 0.72 0.19 0.00 +vt 0.73 0.17 0.00 +vt 0.77 0.18 0.00 +vt 0.95 0.34 0.00 +vt 0.90 0.35 0.00 +vt 0.70 0.32 0.00 +vt 0.71 0.28 0.00 +vt 0.67 0.28 0.00 +vt 0.68 0.31 0.00 +vt 0.69 0.18 0.00 +vt 0.70 0.15 0.00 +vt 0.86 0.37 0.00 +vt 0.91 0.38 0.00 +vt 0.87 0.40 0.00 +vt 0.62 0.88 0.00 +vt 0.63 0.85 0.00 +vt 0.66 0.87 0.00 +vt 0.67 0.92 0.00 +vt 0.60 0.94 0.00 +vt 0.60 0.89 0.00 +vt 0.52 0.92 0.00 +vt 0.57 0.88 0.00 +vt 0.53 0.87 0.00 +vt 0.55 0.86 0.00 +vt 0.55 0.83 0.00 +vt 0.55 0.84 0.00 +vt 0.56 0.83 0.00 +vt 0.61 0.83 0.00 +vt 0.63 0.84 0.00 +vt 0.59 0.84 0.00 +vt 0.59 0.83 0.00 +vt 0.63 0.83 0.00 +vt 0.68 0.80 0.00 +vt 0.67 0.76 0.00 +vt 0.69 0.74 0.00 +vt 0.70 0.80 0.00 +vt 0.39 0.37 0.00 +vt 0.38 0.37 0.00 +vt 0.35 0.31 0.00 +vt 0.42 0.31 0.00 +vt 0.41 0.36 0.00 +vt 0.35 0.38 0.00 +vt 0.33 0.37 0.00 +vt 0.50 0.81 0.00 +vt 0.48 0.81 0.00 +vt 0.49 0.75 0.00 +vt 0.51 0.76 0.00 +vt 0.53 0.78 0.00 +vt 0.55 0.80 0.00 +vt 0.56 0.80 0.00 +vt 0.55 0.77 0.00 +vt 0.60 0.80 0.00 +vt 0.59 0.80 0.00 +vt 0.59 0.76 0.00 +vt 0.62 0.75 0.00 +vt 0.64 0.77 0.00 +vt 0.63 0.80 0.00 +vt 0.63 0.72 0.00 +vt 0.59 0.71 0.00 +vt 0.59 0.68 0.00 +vt 0.63 0.69 0.00 +vt 0.55 0.72 0.00 +vt 0.54 0.69 0.00 +vt 0.53 0.73 0.00 +vt 0.56 0.75 0.00 +vt 0.68 0.36 0.00 +vt 0.67 0.37 0.00 +vt 0.69 0.38 0.00 +vt 0.68 0.40 0.00 +vt 0.72 0.10 0.00 +vt 0.70 0.09 0.00 +vt 0.77 0.23 0.00 +vt 0.85 0.23 0.00 +vt 0.90 0.21 0.00 +vt 0.95 0.21 0.00 +vt 0.87 0.03 0.00 +vt 0.87 0.06 0.00 +vt 0.67 0.13 0.00 +vt 0.94 0.06 0.00 +vt 0.90 0.06 0.00 +vt 0.55 0.41 0.00 +vt 0.56 0.28 0.00 +vt 0.60 0.28 0.00 +vt 0.60 0.41 0.00 +vt 0.57 0.17 0.00 +vt 0.51 0.28 0.00 +vt 0.52 0.17 0.00 +vt 0.51 0.42 0.00 +vt 0.52 0.52 0.00 +vt 0.56 0.51 0.00 +vt 0.57 0.58 0.00 +vt 0.53 0.58 0.00 +vt 0.60 0.50 0.00 +vt 0.61 0.57 0.00 +vt 0.61 0.17 0.00 +vt 0.57 0.15 0.00 +vt 0.60 0.15 0.00 +vt 0.55 0.15 0.00 +vt 0.58 0.62 0.00 +vt 0.54 0.64 0.00 +vt 0.62 0.62 0.00 +vt 0.73 0.48 0.00 +vt 0.70 0.45 0.00 +vt 0.72 0.44 0.00 +vt 0.74 0.46 0.00 +vt 0.92 0.39 0.00 +vt 0.88 0.42 0.00 +vt 0.96 0.38 0.00 +vt 0.96 0.36 0.00 +vt 0.84 0.41 0.00 +vt 0.85 0.44 0.00 +vt 0.90 0.05 0.00 +vt 0.97 0.39 0.00 +vt 0.94 0.41 0.00 +vt 0.78 0.49 0.00 +vt 0.77 0.51 0.00 +vt 0.81 0.47 0.00 +vt 0.76 0.45 0.00 +vt 0.79 0.43 0.00 +vt 0.82 0.46 0.00 +vt 0.91 0.44 0.00 +vt 0.88 0.45 0.00 +vt 0.86 0.47 0.00 +vt 0.84 0.48 0.00 +vt 0.81 0.52 0.00 +vt 0.82 0.51 0.00 +vt 0.83 0.38 0.00 +vt 0.83 0.39 0.00 +vt 0.80 0.41 0.00 +vt 0.81 0.40 0.00 +vt 0.84 0.36 0.00 +vt 0.83 0.36 0.00 +vt 0.11 0.49 0.00 +vt 0.13 0.50 0.00 +vt 0.09 0.51 0.00 +vt 0.08 0.50 0.00 +vt 0.12 0.47 0.00 +vt 0.06 0.54 0.00 +vt 0.06 0.93 0.00 +vt 0.09 0.98 0.00 +vt 0.05 0.99 0.00 +vt 0.04 0.94 0.00 +vt 0.07 0.79 0.00 +vt 0.07 0.77 0.00 +vt 0.08 0.76 0.00 +vt 0.14 0.78 0.00 +vt 0.11 0.77 0.00 +vt 0.12 0.75 0.00 +vt 0.15 0.77 0.00 +vt 0.07 0.46 0.00 +vt 0.13 0.44 0.00 +vt 0.02 0.46 0.00 +vt 0.02 0.49 0.00 +vt 0.09 0.91 0.00 +vt 0.11 0.96 0.00 +vt 0.13 0.89 0.00 +vt 0.08 0.87 0.00 +vt 0.13 0.86 0.00 +vt 0.13 0.83 0.00 +vt 0.09 0.83 0.00 +vt 0.17 0.80 0.00 +vt 0.18 0.79 0.00 +vt 0.22 0.82 0.00 +vt 0.09 0.36 0.00 +vt 0.12 0.39 0.00 +vt 0.08 0.40 0.00 +vt 0.07 0.38 0.00 +vt 0.05 0.40 0.00 +vt 0.19 0.89 0.00 +vt 0.18 0.87 0.00 +vt 0.20 0.85 0.00 +vt 0.18 0.85 0.00 +vt 0.18 0.82 0.00 +vt 0.22 0.83 0.00 +vt 0.16 0.76 0.00 +vt 0.03 0.43 0.00 +vt 0.16 0.91 0.00 +vt 0.16 0.48 0.00 +vt 0.14 0.43 0.00 +vt 0.74 0.42 0.00 +vt 0.71 0.23 0.00 +vt 0.68 0.23 0.00 +vt 0.64 0.28 0.00 +vt 0.65 0.31 0.00 +vt 0.66 0.17 0.00 +vt 0.66 0.38 0.00 +vt 0.67 0.41 0.00 +vt 0.74 0.11 0.00 +vt 0.64 0.22 0.00 +vt 0.85 0.18 0.00 +vt 0.91 0.17 0.00 +vt 0.96 0.17 0.00 +vt 0.80 0.33 0.00 +vt 0.78 0.32 0.00 +vt 0.80 0.32 0.00 +vt 0.83 0.34 0.00 +vt 0.75 0.40 0.00 +vt 0.74 0.39 0.00 +vt 0.74 0.38 0.00 +vt 0.76 0.40 0.00 +vt 0.77 0.41 0.00 +vt 0.78 0.41 0.00 +vt 0.77 0.33 0.00 +vt 0.76 0.32 0.00 +vt 0.58 0.80 0.00 +vt 0.61 0.80 0.00 +vt 0.63 0.76 0.00 +vt 0.65 0.73 0.00 +vt 0.66 0.71 0.00 +vt 0.51 0.71 0.00 +vt 0.31 0.23 0.00 +vt 0.35 0.22 0.00 +vt 0.39 0.23 0.00 +vt 0.29 0.31 0.00 +vt 0.31 0.37 0.00 +vt 0.29 0.36 0.00 +vt 0.03 0.57 0.00 +vt 0.02 0.53 0.00 +vt 0.13 0.73 0.00 +vt 0.09 0.73 0.00 +vt 0.11 0.71 0.00 +vt 0.24 0.37 0.00 +vt 0.21 0.35 0.00 +vt 0.24 0.36 0.00 +vt 0.66 0.86 0.00 +vt 0.67 0.91 0.00 +vt 0.56 0.84 0.00 +vt 0.58 0.84 0.00 +vt 0.61 0.84 0.00 +vt 0.62 0.76 0.00 +vt 0.35 0.21 0.00 +vt 0.39 0.22 0.00 +vt 0.28 0.31 0.00 +vt 0.14 0.94 0.00 +vt 0.07 0.37 0.00 +vt 0.01 0.53 0.00 +vt 0.02 0.57 0.00 +vt 0.01 0.49 0.00 +vt 0.04 0.40 0.00 +vt 0.68 0.51 0.00 +vt 0.72 0.54 0.00 +vt 0.65 0.56 0.00 +vt 0.70 0.59 0.00 +vt 0.69 0.60 0.00 +vt 0.68 0.62 0.00 +vt 0.66 0.49 0.00 +vt 0.06 0.88 0.00 +vt 0.06 0.83 0.00 +vt 0.28 0.69 0.00 +vt 0.22 0.68 0.00 +vt 0.23 0.61 0.00 +vt 0.29 0.61 0.00 +vt 0.24 0.77 0.00 +vt 0.23 0.78 0.00 +vt 0.20 0.68 0.00 +vt 0.28 0.76 0.00 +vt 0.35 0.71 0.00 +vt 0.35 0.77 0.00 +vt 0.40 0.73 0.00 +vt 0.38 0.79 0.00 +vt 0.41 0.55 0.00 +vt 0.42 0.59 0.00 +vt 0.36 0.57 0.00 +vt 0.36 0.53 0.00 +vt 0.36 0.64 0.00 +vt 0.41 0.66 0.00 +vt 0.35 0.82 0.00 +vt 0.30 0.81 0.00 +vt 0.36 0.85 0.00 +vt 0.30 0.85 0.00 +vt 0.33 0.51 0.00 +vt 0.33 0.49 0.00 +vt 0.36 0.50 0.00 +vt 0.41 0.49 0.00 +vt 0.41 0.54 0.00 +vt 0.37 0.46 0.00 +vt 0.34 0.45 0.00 +vt 0.41 0.45 0.00 +vt 0.31 0.55 0.00 +vt 0.50 0.53 0.00 +vt 0.46 0.54 0.00 +vt 0.46 0.50 0.00 +vt 0.50 0.50 0.00 +vt 0.26 0.43 0.00 +vt 0.29 0.44 0.00 +vt 0.28 0.48 0.00 +vt 0.24 0.46 0.00 +vt 0.46 0.46 0.00 +vt 0.48 0.46 0.00 +vt 0.28 0.50 0.00 +vt 0.23 0.46 0.00 +vt 0.26 0.53 0.00 +vt 0.21 0.51 0.00 +vt 0.50 0.59 0.00 +vt 0.46 0.60 0.00 +vt 0.18 0.50 0.00 +vt 0.18 0.61 0.00 +vt 0.41 0.80 0.00 +vt 0.44 0.72 0.00 +vt 0.46 0.66 0.00 +vt 0.33 0.40 0.00 +vt 0.35 0.40 0.00 +vt 0.38 0.39 0.00 +vt 0.41 0.39 0.00 +vt 0.27 0.38 0.00 +vt 0.29 0.39 0.00 +vt 0.31 0.40 0.00 +vt 0.47 0.40 0.00 +vt 0.44 0.39 0.00 +vt 0.89 0.71 0.00 +vt 0.92 0.71 0.00 +vt 0.92 0.74 0.00 +vt 0.90 0.74 0.00 +vt 0.94 0.70 0.00 +vt 0.94 0.73 0.00 +vt 0.97 0.70 0.00 +vt 0.76 0.70 0.00 +vt 0.80 0.69 0.00 +vt 0.79 0.71 0.00 +vt 0.82 0.72 0.00 +vt 0.83 0.68 0.00 +vt 0.93 0.77 0.00 +vt 0.90 0.77 0.00 +vt 0.96 0.76 0.00 +vt 0.99 0.72 0.00 +vt 0.75 0.74 0.00 +vt 0.71 0.69 0.00 +vt 0.72 0.68 0.00 +vt 0.78 0.76 0.00 +vt 0.81 0.76 0.00 +vt 0.85 0.72 0.00 +vt 0.84 0.77 0.00 +vt 0.90 0.85 0.00 +vt 0.90 0.81 0.00 +vt 0.93 0.81 0.00 +vt 0.91 0.91 0.00 +vt 0.79 0.88 0.00 +vt 0.80 0.92 0.00 +vt 0.78 0.88 0.00 +vt 0.83 0.87 0.00 +vt 0.84 0.92 0.00 +vt 0.85 0.68 0.00 +vt 0.89 0.68 0.00 +vt 0.92 0.68 0.00 +vt 0.90 0.57 0.00 +vt 0.93 0.56 0.00 +vt 0.93 0.58 0.00 +vt 0.90 0.58 0.00 +vt 0.95 0.57 0.00 +vt 0.94 0.58 0.00 +vt 0.77 0.57 0.00 +vt 0.78 0.56 0.00 +vt 0.80 0.57 0.00 +vt 0.80 0.58 0.00 +vt 0.83 0.82 0.00 +vt 0.75 0.84 0.00 +vt 0.77 0.81 0.00 +vt 0.72 0.81 0.00 +vt 0.74 0.78 0.00 +vt 0.80 0.81 0.00 +vt 0.72 0.72 0.00 +vt 0.81 0.65 0.00 +vt 0.80 0.66 0.00 +vt 0.78 0.65 0.00 +vt 0.79 0.64 0.00 +vt 0.83 0.65 0.00 +vt 0.83 0.66 0.00 +vt 0.85 0.66 0.00 +vt 0.85 0.65 0.00 +vt 0.91 0.65 0.00 +vt 0.88 0.65 0.00 +vt 0.88 0.64 0.00 +vt 0.91 0.64 0.00 +vt 0.85 0.64 0.00 +vt 0.94 0.68 0.00 +vt 0.75 0.63 0.00 +vt 0.94 0.62 0.00 +vt 0.91 0.62 0.00 +vt 0.95 0.62 0.00 +vt 0.76 0.61 0.00 +vt 0.79 0.62 0.00 +vt 0.82 0.58 0.00 +vt 0.82 0.59 0.00 +vt 0.84 0.59 0.00 +vt 0.84 0.58 0.00 +vt 0.86 0.60 0.00 +vt 0.86 0.58 0.00 +vt 0.88 0.59 0.00 +vt 0.88 0.57 0.00 +vt 0.10 0.09 0.00 +vt 0.06 0.07 0.00 +vt 0.06 0.05 0.00 +vt 0.10 0.07 0.00 +vt 0.14 0.03 0.00 +vt 0.14 0.08 0.00 +vt 0.14 0.11 0.00 +vt 0.18 0.10 0.00 +vt 0.18 0.13 0.00 +vt 0.15 0.15 0.00 +vt 0.32 0.03 0.00 +vt 0.38 0.01 0.00 +vt 0.40 0.05 0.00 +vt 0.33 0.08 0.00 +vt 0.07 0.01 0.00 +vt 0.10 0.02 0.00 +vt 0.22 0.04 0.00 +vt 0.26 0.04 0.00 +vt 0.27 0.10 0.00 +vt 0.22 0.11 0.00 +vt 0.17 0.04 0.00 +vt 0.30 0.15 0.00 +vt 0.36 0.13 0.00 +vt 0.43 0.10 0.00 +vt 0.08 0.28 0.00 +vt 0.07 0.29 0.00 +vt 0.06 0.29 0.00 +vt 0.07 0.27 0.00 +vt 0.06 0.26 0.00 +vt 0.04 0.27 0.00 +vt 0.04 0.25 0.00 +vt 0.06 0.25 0.00 +vt 0.07 0.23 0.00 +vt 0.05 0.24 0.00 +vt 0.05 0.23 0.00 +vt 0.06 0.22 0.00 +vt 0.04 0.23 0.00 +vt 0.05 0.22 0.00 +vt 0.07 0.26 0.00 +vt 0.09 0.18 0.00 +vt 0.10 0.20 0.00 +vt 0.09 0.20 0.00 +vt 0.07 0.19 0.00 +vt 0.23 0.40 0.00 +vt 0.18 0.39 0.00 +vt 0.12 0.13 0.00 +vt 0.17 0.21 0.00 +vt 0.15 0.18 0.00 +vt 0.18 0.17 0.00 +vt 0.19 0.19 0.00 +vt 0.09 0.32 0.00 +vt 0.08 0.30 0.00 +vt 0.09 0.29 0.00 +vt 0.10 0.30 0.00 +vt 0.02 0.21 0.00 +vt 0.03 0.21 0.00 +vt 0.02 0.22 0.00 +vt 0.11 0.21 0.00 +vt 0.09 0.22 0.00 +vt 0.11 0.29 0.00 +vt 0.10 0.28 0.00 +vt 0.18 0.34 0.00 +vt 0.15 0.37 0.00 +vt 0.14 0.28 0.00 +vt 0.15 0.26 0.00 +vt 0.16 0.26 0.00 +vt 0.15 0.28 0.00 +vt 0.03 0.22 0.00 +vt 0.04 0.21 0.00 +vt 0.42 0.25 0.00 +vt 0.40 0.21 0.00 +vt 0.46 0.20 0.00 +vt 0.47 0.25 0.00 +vt 0.04 0.16 0.00 +vt 0.06 0.15 0.00 +vt 0.08 0.16 0.00 +vt 0.06 0.17 0.00 +vt 0.13 0.16 0.00 +vt 0.11 0.17 0.00 +vt 0.10 0.15 0.00 +vt 0.09 0.11 0.00 +vt 0.08 0.13 0.00 +vt 0.05 0.28 0.00 +vt 0.17 0.27 0.00 +vt 0.16 0.30 0.00 +vt 0.14 0.29 0.00 +vt 0.19 0.31 0.00 +vt 0.20 0.28 0.00 +vt 0.14 0.32 0.00 +vt 0.12 0.31 0.00 +vt 0.18 0.25 0.00 +vt 0.20 0.25 0.00 +vt 0.26 0.28 0.00 +vt 0.23 0.28 0.00 +vt 0.23 0.24 0.00 +vt 0.26 0.24 0.00 +vt 0.03 0.17 0.00 +vt 0.02 0.17 0.00 +vt 0.02 0.15 0.00 +vt 0.03 0.13 0.00 +vt 0.04 0.11 0.00 +vt 0.05 0.09 0.00 +vt 0.12 0.19 0.00 +vt 0.47 0.32 0.00 +vt 0.45 0.31 0.00 +vt 0.44 0.29 0.00 +vt 0.22 0.31 0.00 +vt 0.28 0.27 0.00 +vt 0.27 0.23 0.00 +vt 0.12 0.35 0.00 +vt 0.09 0.27 0.00 +vt 0.18 0.24 0.00 +vt 0.16 0.25 0.00 +vt 0.10 0.33 0.00 +vt 0.09 0.24 0.00 +vt 0.08 0.26 0.00 +vt 0.06 0.24 0.00 +vt 0.10 0.26 0.00 +vt 0.13 0.29 0.00 +vt 0.13 0.28 0.00 +vt 0.14 0.27 0.00 +vt 0.11 0.23 0.00 +vt 0.12 0.24 0.00 +vt 0.11 0.25 0.00 +vt 0.39 0.18 0.00 +vt 0.45 0.16 0.00 +vt 0.26 0.16 0.00 +vt 0.31 0.18 0.00 +vt 0.26 0.18 0.00 +vt 0.04 0.20 0.00 +vt 0.04 0.18 0.00 +vt 0.04 0.24 0.00 +vt 0.03 0.24 0.00 +vt 0.03 0.23 0.00 +vt 0.03 0.20 0.00 +vt 0.11 0.27 0.00 +vt 0.12 0.28 0.00 +vt 0.14 0.24 0.00 +vt 0.14 0.23 0.00 +vt 0.14 0.21 0.00 +vt 0.15 0.24 0.00 +vt 0.22 0.15 0.00 +vt 0.22 0.18 0.00 +vt 0.26 0.19 0.00 +vt 0.23 0.21 0.00 +vt 0.20 0.22 0.00 +vt 0.01 0.19 0.00 +vt 0.03 0.18 0.00 +vt 0.25 0.30 0.00 +vt 0.24 0.34 0.00 +vt 0.38 0.21 0.00 +vt 0.75 0.35 0.00 +vt 0.74 0.35 0.00 +vt 0.73 0.37 0.00 +vt 0.74 0.37 0.00 +vt 0.80 0.12 0.00 +vt 0.80 0.13 0.00 +vt 0.80 0.14 0.00 +vt 0.79 0.12 0.00 +vt 0.79 0.10 0.00 +vt 0.80 0.11 0.00 +vt 0.81 0.11 0.00 +vt 0.80 0.09 0.00 +vt 0.82 0.10 0.00 +vt 0.83 0.10 0.00 +vt 0.84 0.11 0.00 +vt 0.85 0.10 0.00 +vt 0.86 0.12 0.00 +vt 0.84 0.12 0.00 +vt 0.86 0.13 0.00 +vt 0.86 0.14 0.00 +vt 0.85 0.15 0.00 +vt 0.84 0.14 0.00 +vt 0.84 0.13 0.00 +vt 0.83 0.15 0.00 +vt 0.81 0.14 0.00 +vt 0.81 0.15 0.00 +vt 0.82 0.13 0.00 +vt 0.13 0.56 0.00 +vt 0.52 0.66 0.00 +vt 0.81 0.63 0.00 +vt 0.83 0.64 0.00 +vt 0.88 0.63 0.00 +vt 0.94 0.63 0.00 +vt 0.95 0.63 0.00 +vt 0.75 0.62 0.00 +vt 0.94 0.64 0.00 +vt 0.95 0.65 0.00 +vt 0.08 0.75 0.00 +vt 0.58 0.13 0.00 +vt 0.46 0.85 0.00 +vt 0.44 0.89 0.00 +vt 0.40 0.88 0.00 +vt 0.41 0.83 0.00 +vt 0.37 0.90 0.00 +vt 0.36 0.86 0.00 +vt 0.32 0.92 0.00 +vt 0.29 0.92 0.00 +vt 0.32 0.87 0.00 +vt 0.44 0.95 0.00 +vt 0.39 0.95 0.00 +vt 0.37 0.99 0.00 +vt 0.32 0.97 0.00 +vt 0.28 0.98 0.00 +vt 0.28 0.91 0.00 +vt 0.31 0.86 0.00 +vt 0.26 0.94 0.00 +vt 0.48 0.89 0.00 +vt 0.46 0.82 0.00 +# 615 texture coords + +g CatBombay +f 1/1/1 2/2/2 3/3/3 +f 3/3/3 4/4/4 1/1/1 +f 5/5/5 6/6/6 7/7/7 +f 7/7/7 8/8/8 5/5/5 +f 9/9/9 10/10/10 11/11/11 +f 11/11/11 12/12/12 9/9/9 +f 13/13/13 4/4/4 3/3/3 +f 3/3/3 14/14/14 13/13/13 +f 15/15/15 13/13/13 14/14/14 +f 14/14/14 16/16/16 15/15/15 +f 17/17/17 18/18/18 19/19/19 +f 19/19/19 20/20/20 17/17/17 +f 2/2/2 21/21/21 22/22/22 +f 22/22/22 3/3/3 2/2/2 +f 23/23/23 24/24/24 15/15/15 +f 15/15/15 16/16/16 23/23/23 +f 25/25/25 24/24/24 23/23/23 +f 23/23/23 26/26/26 25/25/25 +f 27/27/27 28/28/28 19/19/19 +f 19/19/19 18/18/18 27/27/27 +f 29/29/29 22/22/22 30/30/30 +f 30/30/30 31/31/31 29/29/29 +f 32/32/32 33/33/33 34/34/34 +f 34/34/34 35/35/35 32/32/32 +f 35/35/35 36/36/36 37/37/37 +f 37/37/37 32/32/32 35/35/35 +f 36/36/36 38/38/38 39/39/39 +f 39/39/39 37/37/37 36/36/36 +f 40/40/40 41/41/41 39/39/39 +f 39/39/39 38/38/38 40/40/40 +f 42/42/42 43/43/43 41/41/41 +f 41/41/41 40/40/40 42/42/42 +f 42/42/42 44/44/44 43/43/43 +f 45/45/45 46/46/46 47/47/47 +f 47/47/47 48/48/48 45/45/45 +f 33/33/33 46/46/46 49/49/49 +f 49/49/49 34/34/34 33/33/33 +f 50/50/50 51/51/51 52/52/52 +f 52/52/52 53/53/53 50/50/50 +f 54/54/54 55/55/55 56/56/56 +f 56/56/56 53/57/53 54/54/54 +f 53/57/53 52/58/52 54/54/54 +f 56/56/56 55/55/55 57/59/57 +f 57/59/57 58/60/58 56/56/56 +f 59/61/59 60/62/60 61/63/61 +f 61/63/61 62/64/62 59/61/59 +f 63/65/63 64/66/64 59/61/59 +f 59/61/59 62/64/62 63/65/63 +f 65/67/65 64/66/64 63/65/63 +f 63/65/63 66/68/66 65/67/65 +f 67/69/67 68/70/68 69/71/69 +f 69/71/69 70/72/70 67/69/67 +f 71/73/71 51/51/51 50/50/50 +f 50/50/50 72/74/72 71/73/71 +f 73/75/73 74/76/74 57/77/57 +f 57/77/57 55/78/55 73/75/73 +f 75/79/75 58/80/58 57/77/57 +f 57/77/57 74/76/74 75/79/75 +f 76/81/76 77/82/77 66/68/66 +f 66/68/66 63/65/63 76/81/76 +f 63/65/63 62/64/62 76/81/76 +f 70/72/70 69/71/69 74/76/74 +f 74/76/74 73/75/73 70/72/70 +f 78/83/78 79/84/79 26/26/26 +f 26/26/26 23/23/23 78/83/78 +f 80/85/80 81/86/81 79/84/79 +f 79/84/79 78/83/78 80/85/80 +f 82/87/82 83/88/83 12/12/12 +f 12/12/12 11/11/11 82/87/82 +f 22/22/22 29/29/29 14/14/14 +f 14/14/14 3/3/3 22/22/22 +f 84/89/84 85/90/85 13/13/13 +f 13/13/13 15/15/15 84/89/84 +f 85/90/85 86/91/86 4/4/4 +f 4/4/4 13/13/13 85/90/85 +f 86/91/86 87/92/87 1/1/1 +f 1/1/1 4/4/4 86/91/86 +f 88/93/88 89/94/89 10/10/10 +f 10/10/10 9/9/9 88/93/88 +f 82/87/82 28/28/28 90/95/90 +f 90/95/90 83/88/83 82/87/82 +f 91/96/91 6/6/6 5/5/5 +f 5/5/5 92/97/92 91/96/91 +f 93/98/93 94/99/94 95/100/95 +f 95/100/95 96/101/96 93/98/93 +f 97/102/97 94/99/94 98/103/98 +f 98/103/98 99/104/99 97/102/97 +f 98/103/98 94/99/94 93/98/93 +f 93/98/93 100/105/100 98/103/98 +f 101/106/101 102/107/102 103/108/103 +f 103/108/103 104/109/104 101/106/101 +f 103/108/103 102/107/102 105/110/105 +f 105/110/105 106/111/106 103/108/103 +f 93/98/93 96/101/96 105/110/105 +f 105/110/105 102/107/102 93/98/93 +f 94/99/94 97/102/97 107/112/107 +f 107/112/107 95/100/95 94/99/94 +f 107/112/107 97/102/97 108/113/108 +f 108/113/108 109/114/109 107/112/107 +f 99/104/99 110/115/110 108/113/108 +f 108/113/108 97/102/97 99/104/99 +f 101/106/101 100/105/100 93/98/93 +f 93/98/93 102/107/102 101/106/101 +f 104/109/104 103/108/103 111/116/111 +f 111/116/111 88/117/88 104/109/104 +f 103/108/103 106/111/106 91/118/91 +f 91/118/91 111/116/111 103/108/103 +f 112/119/112 113/120/113 114/121/114 +f 114/121/114 115/122/115 112/119/112 +f 116/123/116 117/124/117 31/31/31 +f 31/31/31 30/30/30 116/123/116 +f 118/125/118 116/123/116 30/30/30 +f 30/30/30 119/126/119 118/125/118 +f 120/127/120 31/31/31 117/124/117 +f 117/124/117 121/128/121 120/127/120 +f 91/96/91 92/97/92 111/129/111 +f 89/94/89 88/93/88 111/129/111 +f 89/94/89 111/129/111 92/97/92 +f 92/97/92 5/5/5 89/94/89 +f 21/21/21 119/126/119 30/30/30 +f 30/30/30 22/22/22 21/21/21 +f 116/123/116 118/125/118 122/130/122 +f 122/130/122 123/131/123 116/123/116 +f 115/122/115 124/132/124 125/133/125 +f 125/133/125 112/119/112 115/122/115 +f 126/134/126 127/135/127 128/136/128 +f 128/136/128 129/137/129 126/134/126 +f 120/127/120 121/128/121 129/137/129 +f 129/137/129 128/136/128 120/127/120 +f 116/123/116 123/131/123 130/138/130 +f 130/138/130 117/124/117 116/123/116 +f 117/124/117 130/138/130 131/139/131 +f 131/139/131 132/140/132 121/128/121 +f 121/128/121 117/124/117 131/139/131 +f 132/140/132 129/137/129 121/128/121 +f 132/140/132 133/141/133 126/134/126 +f 126/134/126 129/137/129 132/140/132 +f 134/142/125 125/133/125 124/132/124 +f 124/132/124 135/143/134 134/142/125 +f 136/144/135 137/145/136 138/146/137 +f 138/146/137 139/147/138 136/144/135 +f 140/148/139 137/145/136 136/144/135 +f 136/144/135 141/149/140 140/148/139 +f 142/150/141 143/151/142 144/152/143 +f 145/153/144 146/154/145 142/150/141 +f 142/150/141 144/152/143 145/153/144 +f 144/152/143 147/155/146 145/153/144 +f 148/156/147 149/157/148 150/158/149 +f 150/158/149 151/159/150 148/156/147 +f 152/160/151 153/161/152 154/162/153 +f 155/163/154 156/164/155 157/165/156 +f 157/165/156 158/166/157 155/163/154 +f 146/154/145 145/153/144 159/167/158 +f 159/167/158 160/168/159 146/154/145 +f 161/169/160 159/167/158 145/153/144 +f 145/153/144 162/170/161 161/169/160 +f 163/171/162 164/172/163 149/157/148 +f 149/157/148 148/156/147 163/171/162 +f 165/173/164 163/171/162 166/174/165 +f 166/174/165 167/175/166 165/173/164 +f 155/163/154 168/176/167 169/177/168 +f 169/177/168 156/164/155 155/163/154 +f 170/178/169 171/179/170 172/180/171 +f 172/181/172 171/182/173 173/183/174 +f 173/183/174 174/184/175 172/181/172 +f 173/183/174 175/185/176 174/184/175 +f 176/186/177 177/187/178 178/188/179 +f 179/189/180 180/190/181 181/191/182 +f 181/191/182 178/188/179 179/189/180 +f 178/188/179 177/187/178 179/189/180 +f 181/191/182 180/190/181 170/178/169 +f 170/178/169 172/180/171 181/191/182 +f 170/178/169 155/163/154 158/166/157 +f 158/166/157 182/192/183 171/179/170 +f 171/179/170 170/178/169 158/166/157 +f 173/183/174 171/182/173 160/168/159 +f 160/168/159 159/167/158 173/183/174 +f 159/167/158 183/193/184 175/185/176 +f 175/185/176 173/183/174 159/167/158 +f 165/173/164 167/175/166 177/187/178 +f 177/187/178 176/186/177 165/173/164 +f 176/186/177 184/194/185 165/173/164 +f 167/175/166 179/189/180 177/187/178 +f 170/178/169 180/190/181 168/176/167 +f 168/176/167 155/163/154 170/178/169 +f 143/151/142 142/150/141 146/154/145 +f 146/154/145 185/195/186 143/151/142 +f 160/168/159 182/196/187 185/195/186 +f 185/195/186 146/154/145 160/168/159 +f 160/168/159 171/182/173 182/196/187 +f 114/121/114 81/86/81 80/85/80 +f 80/85/80 186/197/188 114/121/114 +f 18/18/18 17/17/17 84/89/84 +f 84/89/84 187/198/189 18/18/18 +f 27/27/27 18/18/18 187/198/189 +f 187/198/189 188/199/190 27/27/27 +f 189/200/191 25/25/25 26/26/26 +f 26/26/26 190/201/192 189/200/191 +f 28/28/28 27/27/27 191/202/193 +f 191/202/193 90/95/90 28/28/28 +f 190/201/192 26/26/26 79/84/79 +f 79/84/79 192/203/194 190/201/192 +f 192/203/194 79/84/79 81/86/81 +f 81/86/81 193/204/195 192/203/194 +f 19/19/19 28/28/28 82/87/82 +f 82/87/82 194/205/196 19/19/19 +f 115/122/115 114/121/114 186/197/188 +f 186/197/188 127/135/127 115/122/115 +f 124/132/124 115/122/115 127/135/127 +f 127/135/127 126/134/126 124/132/124 +f 113/120/113 193/204/195 81/86/81 +f 81/86/81 114/121/114 113/120/113 +f 195/206/197 188/199/190 25/25/25 +f 25/25/25 189/200/191 195/206/197 +f 133/141/133 135/143/134 124/132/124 +f 124/132/124 126/134/126 133/141/133 +f 17/17/17 20/20/20 196/207/198 +f 196/207/198 8/8/8 197/208/199 +f 7/7/7 198/209/1 197/208/199 +f 197/208/199 8/8/8 7/7/7 +f 199/210/200 200/211/201 201/211/202 +f 201/211/202 202/212/203 199/210/200 +f 202/212/203 203/213/204 204/213/205 +f 204/213/205 199/210/200 202/212/203 +f 205/214/206 206/215/207 207/216/208 +f 207/216/208 208/217/209 205/214/206 +f 138/146/137 209/218/210 210/219/211 +f 210/219/211 139/147/138 138/146/137 +f 200/211/201 211/220/212 212/221/213 +f 212/221/213 201/211/202 200/211/201 +f 203/213/204 140/148/139 141/149/140 +f 141/149/140 204/213/205 203/213/204 +f 69/71/69 68/70/68 213/222/214 +f 213/222/214 77/82/77 69/71/69 +f 72/74/72 214/223/215 215/224/216 +f 215/224/216 71/73/71 72/74/72 +f 216/225/217 54/226/54 52/52/52 +f 52/52/52 51/51/51 216/225/217 +f 61/63/61 217/227/218 76/81/76 +f 76/81/76 62/64/62 61/63/61 +f 77/82/77 75/79/75 74/76/74 +f 74/76/74 69/71/69 77/82/77 +f 216/225/217 51/51/51 71/73/71 +f 71/73/71 215/224/216 216/225/217 +f 34/34/34 50/50/50 53/53/53 +f 53/53/53 35/35/35 34/34/34 +f 56/56/56 38/228/38 36/229/36 +f 36/229/36 35/230/35 56/56/56 +f 35/230/35 53/57/53 56/56/56 +f 56/56/56 60/231/60 38/228/38 +f 60/62/60 59/61/59 40/40/40 +f 40/40/40 38/38/38 60/62/60 +f 40/40/40 59/61/59 64/66/64 +f 64/66/64 42/42/42 40/40/40 +f 64/66/64 65/67/65 44/44/44 +f 44/44/44 42/42/42 64/66/64 +f 67/69/67 214/223/215 45/45/45 +f 45/45/45 48/48/48 67/69/67 +f 48/48/48 68/70/68 67/69/67 +f 34/34/34 49/49/49 72/74/72 +f 72/74/72 50/50/50 34/34/34 +f 44/44/44 65/67/65 213/222/214 +f 213/222/214 48/48/48 44/44/44 +f 213/222/214 68/70/68 48/48/48 +f 45/45/45 214/223/215 72/74/72 +f 72/74/72 49/49/49 45/45/45 +f 213/222/214 65/67/65 66/68/66 +f 66/68/66 77/82/77 213/222/214 +f 215/224/216 214/223/215 67/69/67 +f 67/69/67 70/72/70 215/224/216 +f 216/225/217 73/75/73 55/78/55 +f 55/78/55 54/226/54 216/225/217 +f 217/227/218 58/80/58 75/79/75 +f 75/79/75 76/81/76 217/227/218 +f 76/81/76 75/79/75 77/82/77 +f 215/224/216 70/72/70 73/75/73 +f 73/75/73 216/225/217 215/224/216 +f 217/232/218 60/231/60 56/56/56 +f 56/56/56 58/60/58 217/232/218 +f 217/232/218 61/233/61 60/231/60 +f 45/45/45 49/49/49 46/46/46 +f 47/47/47 43/43/43 44/44/44 +f 44/44/44 48/48/48 47/47/47 +f 147/155/146 218/234/219 219/235/220 +f 219/235/220 162/170/161 145/153/144 +f 145/153/144 147/155/146 219/235/220 +f 185/236/221 157/165/156 220/237/222 +f 220/237/222 143/238/223 185/236/221 +f 182/192/183 158/166/157 157/165/156 +f 157/165/156 185/236/221 182/192/183 +f 153/239/152 221/240/224 222/241/225 +f 222/241/225 154/239/153 153/239/152 +f 223/32/226 224/33/93 225/242/227 +f 225/242/227 226/243/228 223/32/226 +f 226/243/228 227/36/229 228/37/230 +f 228/37/230 223/32/226 226/243/228 +f 228/37/230 227/36/229 229/38/231 +f 229/38/231 230/39/232 228/37/230 +f 231/40/233 232/41/234 230/39/232 +f 230/39/232 229/38/231 231/40/233 +f 232/41/234 231/40/233 233/244/235 +f 233/244/235 234/244/236 232/41/234 +f 235/245/237 236/47/238 234/244/236 +f 234/244/236 233/244/235 235/245/237 +f 237/47/239 238/246/240 236/47/238 +f 224/33/93 239/46/241 240/49/242 +f 240/49/242 225/242/227 224/33/93 +f 241/50/243 242/51/244 243/52/245 +f 243/52/245 244/53/246 241/50/243 +f 245/54/247 246/55/248 247/56/56 +f 247/56/56 244/57/246 245/54/247 +f 244/57/246 243/58/245 245/54/247 +f 247/56/56 246/55/248 248/59/57 +f 248/59/57 249/60/249 247/56/56 +f 250/64/250 251/61/251 252/62/252 +f 252/62/252 253/63/253 250/64/250 +f 254/65/254 255/66/255 251/61/251 +f 251/61/251 250/64/250 254/65/254 +f 254/65/254 256/68/256 257/67/257 +f 257/67/257 255/66/255 254/65/254 +f 258/70/258 259/71/259 260/72/260 +f 260/72/260 261/69/261 258/70/258 +f 262/73/262 242/51/244 241/50/243 +f 241/50/243 263/74/263 262/73/262 +f 264/75/264 265/76/265 248/77/57 +f 248/77/57 246/78/248 264/75/264 +f 266/79/266 249/80/249 248/77/57 +f 248/77/57 265/76/265 266/79/266 +f 267/81/267 268/82/268 256/68/256 +f 256/68/256 254/65/254 267/81/267 +f 254/65/254 250/64/250 267/81/267 +f 260/72/260 259/71/259 265/76/265 +f 265/76/265 264/75/264 260/72/260 +f 258/70/258 269/222/269 268/82/268 +f 268/82/268 259/71/259 258/70/258 +f 270/223/270 271/247/271 262/73/262 +f 262/73/262 263/74/263 270/223/270 +f 272/225/272 245/226/247 243/52/245 +f 243/52/245 242/51/244 272/225/272 +f 253/63/253 273/227/273 267/81/267 +f 267/81/267 250/64/250 253/63/253 +f 268/82/268 266/79/266 265/76/265 +f 265/76/265 259/71/259 268/82/268 +f 262/73/262 271/247/271 272/225/272 +f 272/225/272 242/51/244 262/73/262 +f 226/243/228 225/242/227 241/50/243 +f 241/50/243 244/53/246 226/243/228 +f 247/56/56 229/228/231 227/248/229 +f 227/248/229 226/249/228 247/56/56 +f 226/249/228 244/57/246 247/56/56 +f 247/56/56 252/250/252 229/228/231 +f 229/38/231 252/62/252 251/61/251 +f 251/61/251 231/40/233 229/38/231 +f 231/40/233 251/61/251 255/66/255 +f 255/66/255 233/244/235 231/40/233 +f 255/66/255 257/67/257 235/245/237 +f 235/245/237 233/244/235 255/66/255 +f 261/69/261 270/223/270 238/246/240 +f 238/246/240 237/47/239 261/69/261 +f 237/47/239 269/222/269 258/70/258 +f 258/70/258 261/69/261 237/47/239 +f 225/242/227 240/49/242 263/74/263 +f 263/74/263 241/50/243 225/242/227 +f 235/245/237 257/67/257 269/222/269 +f 269/222/269 237/47/239 235/245/237 +f 238/246/240 270/223/270 263/74/263 +f 263/74/263 240/49/242 238/246/240 +f 269/222/269 257/67/257 256/68/256 +f 256/68/256 268/82/268 269/222/269 +f 270/223/270 261/69/261 260/72/260 +f 260/72/260 271/247/271 270/223/270 +f 272/225/272 264/75/264 246/78/248 +f 246/78/248 245/226/247 272/225/272 +f 273/227/273 249/80/249 266/79/266 +f 266/79/266 267/81/267 273/227/273 +f 267/81/267 266/79/266 268/82/268 +f 271/247/271 260/72/260 264/75/264 +f 264/75/264 272/225/272 271/247/271 +f 273/232/273 252/250/252 247/56/56 +f 247/56/56 249/60/249 273/232/273 +f 273/232/273 253/233/253 252/250/252 +f 239/46/241 236/47/238 238/246/240 +f 238/246/240 240/49/242 239/46/241 +f 235/245/237 237/47/239 236/47/238 +f 159/167/158 161/169/160 183/193/184 +f 184/194/185 274/251/274 165/173/164 +f 274/251/274 164/172/163 163/171/162 +f 163/171/162 165/173/164 274/251/274 +f 178/252/179 181/181/182 172/181/171 +f 172/181/171 174/184/275 178/252/179 +f 149/253/148 219/235/276 218/234/277 +f 218/234/277 150/254/149 149/253/148 +f 164/255/163 162/170/278 219/235/276 +f 219/235/276 149/253/148 164/255/163 +f 178/252/179 174/184/275 175/185/279 +f 175/185/279 176/256/177 178/252/179 +f 184/193/185 183/193/280 161/169/281 +f 161/169/281 274/169/274 184/193/185 +f 176/256/177 175/185/279 183/193/280 +f 183/193/280 184/193/185 176/256/177 +f 274/169/274 161/169/281 162/170/278 +f 162/170/278 164/255/163 274/169/274 +f 275/257/282 276/258/283 277/259/284 +f 277/259/284 278/260/285 279/261/286 +f 279/261/286 280/262/287 277/259/284 +f 276/258/283 278/260/285 277/259/284 +f 277/259/284 281/263/288 282/263/289 +f 282/263/289 283/257/290 277/259/284 +f 283/257/290 275/257/282 277/259/284 +f 151/159/150 284/264/291 148/156/147 +f 163/171/162 148/156/147 284/264/291 +f 284/264/291 166/174/165 163/171/162 +f 169/177/168 166/174/165 284/264/291 +f 284/264/291 285/265/292 169/177/168 +f 167/175/166 166/174/165 169/177/168 +f 169/177/168 168/176/167 167/175/166 +f 168/176/167 180/190/181 179/189/180 +f 179/189/180 167/175/166 168/176/167 +f 286/266/293 287/267/294 288/268/295 +f 288/268/295 289/269/296 286/266/293 +f 287/267/294 290/270/297 196/271/198 +f 196/271/198 20/272/20 287/267/294 +f 291/273/298 286/266/293 292/274/299 +f 292/274/299 293/275/300 291/273/298 +f 294/276/301 295/277/302 293/275/300 +f 293/275/300 292/274/299 294/276/301 +f 296/278/303 297/279/304 298/280/305 +f 298/280/305 299/281/306 296/278/303 +f 292/274/299 300/282/307 301/283/308 +f 301/283/308 294/276/301 292/274/299 +f 293/275/300 302/284/309 303/285/310 +f 303/285/310 291/273/298 293/275/300 +f 303/285/310 302/284/309 5/286/5 +f 5/286/5 8/287/8 303/285/310 +f 286/266/293 289/269/296 300/282/307 +f 300/282/307 292/274/299 286/266/293 +f 304/288/311 305/289/312 306/290/313 +f 306/290/313 299/281/306 304/288/311 +f 307/291/314 308/292/315 299/281/306 +f 299/281/306 306/290/313 307/291/314 +f 309/293/316 306/290/313 305/289/312 +f 305/289/312 310/294/317 309/293/316 +f 309/293/316 311/295/318 307/291/314 +f 307/291/314 306/290/313 309/293/316 +f 196/271/198 290/270/297 303/285/310 +f 303/285/310 8/287/8 196/271/198 +f 304/288/311 299/281/306 298/280/305 +f 298/280/305 312/296/319 304/288/311 +f 313/297/320 314/298/321 315/299/322 +f 315/299/322 316/300/323 313/297/320 +f 307/291/314 315/299/322 314/298/321 +f 314/298/321 308/292/315 307/291/314 +f 317/301/324 318/302/325 319/303/326 +f 319/303/326 316/304/323 317/301/324 +f 316/300/323 315/299/322 320/305/327 +f 320/305/327 317/306/324 316/300/323 +f 320/305/327 315/299/322 307/291/314 +f 307/291/314 311/295/318 320/305/327 +f 319/303/326 321/307/328 313/308/320 +f 313/308/320 316/304/323 319/303/326 +f 321/307/328 322/309/329 323/310/330 +f 323/310/330 313/308/320 321/307/328 +f 293/275/300 295/277/302 302/284/309 +f 324/311/331 325/312/332 314/298/321 +f 314/298/321 313/297/320 324/311/331 +f 313/308/320 323/310/330 324/313/331 +f 19/314/19 323/310/330 322/309/329 +f 322/309/329 288/268/295 19/314/19 +f 288/268/295 322/309/329 312/296/319 +f 312/296/319 289/269/296 288/268/295 +f 312/296/319 298/280/305 300/282/307 +f 300/282/307 289/269/296 312/296/319 +f 298/280/305 297/279/304 301/283/308 +f 301/283/308 300/282/307 298/280/305 +f 89/315/89 295/277/302 294/276/301 +f 294/276/301 10/316/10 89/315/89 +f 5/286/5 302/284/309 295/277/302 +f 295/277/302 89/315/89 5/286/5 +f 299/281/306 308/292/315 296/278/303 +f 296/278/303 308/292/315 314/298/321 +f 314/298/321 325/312/332 297/279/304 +f 297/279/304 296/278/303 314/298/321 +f 325/312/332 11/317/11 301/283/308 +f 301/283/308 297/279/304 325/312/332 +f 301/283/308 11/317/11 10/316/10 +f 10/316/10 294/276/301 301/283/308 +f 239/318/241 224/319/93 310/294/317 +f 224/319/93 223/320/226 309/293/316 +f 309/293/316 310/294/317 224/319/93 +f 311/295/318 309/293/316 223/320/226 +f 223/320/226 228/321/230 311/295/318 +f 317/301/324 232/322/234 234/323/236 +f 234/323/236 318/302/325 317/301/324 +f 234/323/236 236/324/238 318/302/325 +f 320/305/327 232/325/234 317/306/324 +f 230/326/232 320/305/327 311/295/318 +f 311/295/318 228/321/230 230/326/232 +f 288/268/295 287/267/294 20/272/20 +f 20/272/20 19/314/19 288/268/295 +f 326/327/333 327/328/334 328/329/335 +f 328/329/335 329/330/336 326/327/333 +f 327/328/334 330/331/337 331/332/338 +f 331/332/338 328/329/335 327/328/334 +f 332/333/339 331/332/338 330/331/337 +f 333/334/340 334/335/341 335/336/342 +f 336/337/343 335/336/342 334/335/341 +f 334/335/341 337/338/344 336/337/343 +f 328/329/335 338/339/345 339/340/346 +f 339/340/346 329/330/336 328/329/335 +f 331/332/338 23/341/23 338/339/345 +f 338/339/345 328/329/335 331/332/338 +f 78/342/78 23/341/23 331/332/338 +f 331/332/338 332/333/339 78/342/78 +f 340/343/347 78/344/78 332/345/339 +f 332/345/339 333/334/340 340/343/347 +f 341/346/348 340/343/347 333/334/340 +f 333/334/340 335/336/342 341/346/348 +f 342/347/349 341/346/348 335/336/342 +f 335/336/342 336/337/343 342/347/349 +f 343/348/350 344/349/351 342/347/349 +f 342/347/349 336/337/343 343/348/350 +f 345/350/352 346/351/353 16/352/16 +f 16/352/16 14/353/14 345/350/352 +f 347/354/354 31/355/31 120/356/120 +f 347/354/354 348/357/355 29/358/29 +f 29/358/29 31/355/31 347/354/354 +f 349/359/356 343/348/350 336/337/343 +f 336/337/343 337/338/344 349/359/356 +f 326/327/333 350/360/357 351/360/358 +f 351/360/358 352/361/359 327/328/334 +f 327/328/334 326/327/333 351/360/358 +f 37/362/37 39/363/39 353/364/360 +f 353/364/360 354/365/361 37/362/37 +f 353/364/360 39/363/39 41/366/41 +f 41/366/41 355/367/362 353/364/360 +f 355/368/362 41/369/41 43/370/43 +f 43/370/43 356/371/363 355/368/362 +f 349/359/356 350/360/357 326/327/333 +f 326/327/333 343/348/350 349/359/356 +f 326/327/333 329/330/336 343/348/350 +f 346/351/353 357/372/364 344/349/351 +f 344/349/351 339/340/346 346/351/353 +f 14/353/14 29/358/29 348/357/355 +f 348/357/355 345/350/352 14/353/14 +f 128/373/128 358/374/365 120/356/120 +f 358/374/365 128/373/128 127/375/127 +f 127/375/127 186/376/188 358/374/365 +f 120/356/120 358/374/365 359/377/366 +f 359/377/366 347/354/354 120/356/120 +f 357/372/364 348/357/355 347/354/354 +f 347/354/354 359/377/366 357/372/364 +f 357/372/364 346/351/353 345/350/352 +f 345/350/352 348/357/355 357/372/364 +f 339/340/346 338/339/345 16/352/16 +f 16/352/16 346/351/353 339/340/346 +f 23/341/23 16/352/16 338/339/345 +f 340/343/347 80/378/80 78/344/78 +f 186/376/188 340/343/347 341/346/348 +f 341/346/348 358/374/365 186/376/188 +f 358/374/365 341/346/348 342/347/349 +f 342/347/349 359/377/366 358/374/365 +f 359/377/366 342/347/349 344/349/351 +f 344/349/351 357/372/364 359/377/366 +f 329/330/336 339/340/346 344/349/351 +f 344/349/351 343/348/350 329/330/336 +f 340/343/347 186/376/188 80/378/80 +f 360/379/367 361/380/368 362/381/369 +f 362/381/369 363/382/370 360/379/367 +f 364/383/371 365/384/372 361/380/368 +f 361/380/368 360/379/367 364/383/371 +f 366/385/373 365/384/372 364/383/371 +f 364/383/371 367/386/374 366/385/373 +f 368/387/375 369/388/376 370/389/377 +f 370/389/377 371/390/378 368/387/375 +f 367/386/374 372/391/379 370/389/377 +f 370/389/377 369/388/376 367/386/374 +f 369/388/376 366/385/373 367/386/374 +f 352/361/359 373/392/380 330/331/337 +f 330/331/337 327/328/334 352/361/359 +f 332/333/339 330/331/337 373/392/380 +f 332/345/339 374/393/381 362/381/369 +f 362/381/369 333/334/340 332/345/339 +f 354/365/361 353/364/360 375/394/382 +f 375/394/382 376/395/383 354/365/361 +f 375/394/382 353/364/360 355/367/362 +f 355/367/362 377/396/384 375/394/382 +f 377/397/384 355/368/362 356/371/363 +f 356/371/363 378/398/385 377/397/384 +f 47/399/47 379/400/386 356/371/363 +f 356/371/363 43/370/43 47/399/47 +f 380/401/387 379/400/386 47/399/47 +f 47/399/47 46/402/46 380/401/387 +f 381/403/388 380/401/387 46/402/46 +f 46/402/46 33/404/33 381/403/388 +f 354/365/361 382/405/389 32/406/32 +f 32/406/32 37/362/37 354/365/361 +f 382/405/389 381/403/388 33/404/33 +f 33/404/33 32/406/32 382/405/389 +f 383/407/390 384/408/391 385/409/392 +f 385/409/392 386/410/393 383/407/390 +f 386/410/393 133/411/133 387/412/394 +f 387/412/394 383/407/390 386/410/393 +f 387/412/394 388/413/395 383/407/390 +f 388/413/395 387/412/394 389/414/396 +f 390/415/397 391/416/398 388/413/395 +f 388/413/395 389/414/396 390/415/397 +f 123/417/123 122/418/122 392/419/399 +f 392/419/399 393/420/400 123/417/123 +f 134/421/125 135/422/134 386/410/393 +f 386/410/393 385/409/392 134/421/125 +f 131/423/131 130/424/130 394/425/401 +f 394/425/401 395/426/402 131/423/131 +f 133/411/133 132/427/132 389/414/396 +f 389/414/396 387/412/394 133/411/133 +f 394/425/401 130/424/130 123/417/123 +f 123/417/123 393/420/400 394/425/401 +f 132/427/132 131/423/131 395/426/402 +f 395/426/402 389/414/396 132/427/132 +f 396/428/403 394/425/401 393/420/400 +f 393/420/400 397/429/404 396/428/403 +f 392/419/399 398/430/405 397/429/404 +f 397/429/404 393/420/400 392/419/399 +f 399/431/406 400/432/407 401/433/408 +f 401/433/408 402/434/409 399/431/406 +f 403/435/410 404/436/411 405/437/412 +f 405/437/412 406/438/413 403/435/410 +f 405/437/412 407/437/414 406/438/413 +f 408/439/415 409/440/416 410/441/175 +f 410/441/175 411/442/417 408/439/415 +f 411/442/417 410/441/175 412/443/418 +f 412/443/418 413/444/419 411/442/417 +f 403/435/410 406/438/413 414/445/420 +f 414/445/420 402/434/409 403/435/410 +f 415/446/421 416/447/422 417/448/423 +f 417/448/423 276/449/424 415/446/421 +f 221/240/224 153/239/152 418/450/425 +f 418/450/425 419/451/426 221/240/224 +f 391/416/398 420/452/427 388/413/395 +f 421/453/428 422/454/429 423/455/430 +f 423/455/430 424/456/293 421/453/428 +f 425/457/431 426/458/432 427/459/433 +f 427/459/433 428/460/434 425/457/431 +f 429/461/435 430/462/436 282/461/437 +f 282/461/437 281/463/438 429/461/435 +f 416/447/422 431/464/439 432/465/440 +f 432/465/440 417/448/423 416/447/422 +f 433/466/441 428/460/434 427/459/433 +f 427/459/433 434/467/442 433/466/441 +f 435/468/443 221/240/224 419/451/426 +f 419/451/426 436/469/444 435/468/443 +f 437/470/445 438/471/446 439/472/447 +f 439/472/447 440/473/448 437/470/445 +f 411/442/417 413/444/419 276/449/424 +f 276/449/424 417/448/423 411/442/417 +f 432/465/440 408/439/415 411/442/417 +f 411/442/417 417/448/423 432/465/440 +f 413/444/419 412/443/418 279/474/449 +f 279/474/449 278/475/450 413/444/419 +f 285/476/292 441/477/451 442/478/452 +f 442/478/452 443/479/453 285/476/292 +f 444/480/454 445/481/455 446/482/456 +f 446/482/456 447/483/457 444/480/454 +f 448/484/458 449/485/459 450/486/460 +f 450/486/460 420/452/427 448/484/458 +f 388/413/395 420/452/427 451/487/461 +f 451/487/461 383/407/390 388/413/395 +f 447/483/457 446/482/456 415/446/421 +f 415/446/421 276/449/424 447/483/457 +f 450/486/460 452/488/462 451/487/461 +f 451/487/461 420/452/427 450/486/460 +f 453/489/463 403/435/410 402/434/409 +f 402/434/409 401/433/408 453/489/463 +f 440/473/448 439/472/447 454/490/464 +f 454/490/464 455/491/465 440/473/448 +f 455/491/465 456/492/466 440/473/448 +f 457/493/467 455/491/465 454/490/464 +f 454/490/464 458/494/468 457/493/467 +f 459/495/469 460/496/470 456/492/466 +f 456/492/466 455/491/465 459/495/469 +f 454/490/464 461/497/471 462/498/472 +f 462/498/472 458/494/468 454/490/464 +f 463/499/473 464/500/474 465/501/475 +f 465/501/475 466/502/476 463/499/473 +f 467/503/477 468/504/478 469/505/479 +f 469/505/479 444/480/454 467/503/477 +f 445/481/455 444/480/454 469/505/479 +f 469/505/479 470/506/480 445/481/455 +f 445/481/455 470/506/480 471/507/481 +f 471/507/481 452/488/462 445/481/455 +f 383/407/390 451/487/461 472/508/482 +f 472/508/482 384/408/391 383/407/390 +f 473/509/483 449/485/459 448/484/458 +f 448/484/458 422/454/429 473/509/483 +f 443/479/453 418/510/425 153/511/152 +f 153/511/152 152/512/151 443/479/453 +f 221/240/224 435/468/443 457/493/467 +f 457/493/467 474/513/484 221/240/224 +f 144/514/485 463/499/473 466/502/476 +f 466/502/476 147/515/486 144/514/485 +f 435/468/443 459/495/469 455/491/465 +f 455/491/465 457/493/467 435/468/443 +f 436/469/444 475/516/487 459/495/469 +f 459/495/469 435/468/443 436/469/444 +f 476/517/488 399/431/406 402/434/409 +f 402/434/409 414/445/420 476/517/488 +f 477/518/489 461/497/471 478/519/490 +f 478/519/490 479/519/491 477/518/489 +f 459/495/469 475/516/487 480/520/435 +f 480/520/435 460/496/470 459/495/469 +f 481/521/492 482/522/493 406/438/413 +f 406/438/413 483/523/494 481/521/492 +f 482/522/493 140/524/495 476/517/488 +f 476/517/488 414/445/420 482/522/493 +f 440/473/448 456/492/466 484/525/496 +f 484/525/496 437/470/445 440/473/448 +f 460/496/470 428/460/434 433/466/441 +f 433/466/441 456/492/466 460/496/470 +f 433/466/441 484/525/496 456/492/466 +f 206/519/497 479/519/491 478/519/490 +f 478/519/490 485/519/498 206/519/497 +f 437/470/445 484/525/496 201/526/499 +f 201/526/499 212/527/500 437/470/445 +f 486/528/501 138/529/502 137/530/503 +f 137/530/503 481/521/492 486/528/501 +f 422/454/429 448/484/458 391/416/398 +f 391/416/398 390/415/397 423/455/430 +f 423/455/430 422/454/429 391/416/398 +f 487/531/504 397/429/404 398/430/405 +f 398/430/405 488/532/505 487/531/504 +f 489/533/506 396/428/403 151/534/150 +f 151/534/150 150/535/149 489/533/506 +f 396/428/403 397/429/404 487/531/504 +f 487/531/504 151/534/150 396/428/403 +f 386/410/393 135/422/134 133/411/133 +f 490/536/507 491/537/508 447/483/457 +f 447/483/457 276/449/424 490/536/507 +f 453/489/463 404/436/411 403/435/410 +f 409/440/416 406/438/413 407/437/414 +f 409/440/416 407/437/414 492/538/509 +f 492/538/509 410/441/175 409/440/416 +f 410/441/175 492/538/509 493/539/510 +f 493/539/510 412/443/418 410/441/175 +f 280/540/511 279/474/449 412/443/418 +f 412/443/418 493/539/510 280/540/511 +f 407/437/414 405/437/412 494/437/512 +f 495/539/513 492/538/509 407/437/414 +f 407/437/414 494/437/512 495/539/513 +f 493/539/510 492/538/509 495/539/513 +f 495/539/513 496/539/514 493/539/510 +f 282/461/437 430/462/436 497/541/515 +f 497/541/515 283/475/516 282/461/437 +f 434/467/442 203/542/517 202/543/518 +f 202/543/518 433/466/441 434/467/442 +f 209/544/519 138/529/502 486/528/501 +f 486/528/501 498/545/520 209/544/519 +f 140/524/495 203/542/517 434/467/442 +f 434/467/442 476/517/488 140/524/495 +f 399/431/406 476/517/488 434/467/442 +f 434/467/442 427/459/433 399/431/406 +f 400/432/407 399/431/406 427/459/433 +f 427/459/433 426/458/432 400/432/407 +f 432/465/440 431/464/439 486/528/501 +f 486/528/501 481/521/492 432/465/440 +f 408/439/415 432/465/440 481/521/492 +f 481/521/492 483/523/494 408/439/415 +f 422/454/429 421/453/428 499/546/521 +f 499/546/521 473/509/483 422/454/429 +f 205/547/522 498/545/520 479/519/491 +f 479/519/491 206/519/497 205/547/522 +f 421/453/428 477/518/489 479/519/491 +f 479/519/491 498/545/520 421/453/428 +f 500/548/523 489/533/506 150/535/149 +f 150/535/149 501/549/524 500/548/523 +f 218/550/277 147/515/486 466/502/476 +f 466/502/476 502/551/525 218/550/277 +f 466/502/476 465/501/475 502/551/525 +f 395/426/402 500/548/523 390/415/397 +f 390/415/397 389/414/396 395/426/402 +f 489/533/506 500/548/523 395/426/402 +f 395/426/402 394/425/401 489/533/506 +f 202/543/518 201/526/499 484/525/496 +f 484/525/496 433/466/441 202/543/518 +f 480/520/435 425/457/431 428/460/434 +f 428/460/434 460/496/470 480/520/435 +f 477/518/489 421/453/428 424/456/293 +f 424/456/293 503/552/526 477/518/489 +f 477/518/489 503/552/526 462/498/472 +f 462/498/472 461/497/471 477/518/489 +f 431/464/439 499/546/521 498/545/520 +f 498/545/520 486/528/501 431/464/439 +f 431/464/439 416/447/422 473/509/483 +f 473/509/483 499/546/521 431/464/439 +f 415/446/421 449/485/459 473/509/483 +f 473/509/483 416/447/422 415/446/421 +f 446/482/456 450/486/460 449/485/459 +f 449/485/459 415/446/421 446/482/456 +f 452/488/462 471/507/481 472/508/482 +f 472/508/482 451/487/461 452/488/462 +f 445/481/455 452/488/462 450/486/460 +f 450/486/460 446/482/456 445/481/455 +f 458/494/468 464/500/474 474/513/484 +f 474/513/484 457/493/467 458/494/468 +f 462/498/472 465/501/475 464/500/474 +f 464/500/474 458/494/468 462/498/472 +f 465/501/475 462/498/472 503/552/526 +f 503/552/526 502/551/525 465/501/475 +f 424/456/293 501/549/524 502/551/525 +f 502/551/525 503/552/526 424/456/293 +f 501/549/524 150/535/149 218/550/277 +f 218/550/277 502/551/525 501/549/524 +f 430/462/436 429/461/435 504/553/527 +f 505/554/528 497/541/515 430/462/436 +f 430/462/436 504/553/527 505/554/528 +f 467/503/477 505/554/528 504/553/527 +f 504/553/527 468/504/478 467/503/477 +f 497/541/515 490/536/507 275/536/529 +f 275/536/529 283/475/516 497/541/515 +f 491/537/508 490/536/507 497/541/515 +f 497/541/515 505/554/528 491/537/508 +f 491/537/508 505/554/528 467/503/477 +f 444/480/454 447/483/457 491/537/508 +f 491/537/508 467/503/477 444/480/454 +f 488/532/505 442/478/452 441/477/451 +f 441/477/451 487/531/504 488/532/505 +f 489/533/506 394/425/401 396/428/403 +f 275/536/529 490/536/507 276/449/424 +f 278/475/450 276/449/424 413/444/419 +f 474/513/484 464/500/474 463/499/473 +f 463/499/473 143/555/223 474/513/484 +f 409/440/416 483/523/494 406/438/413 +f 140/524/495 482/522/493 481/521/492 +f 481/521/492 137/530/503 140/524/495 +f 205/547/522 209/544/519 498/545/520 +f 391/416/398 448/484/458 420/452/427 +f 493/539/510 496/539/514 280/540/511 +f 482/522/493 414/445/420 406/438/413 +f 408/439/415 483/523/494 409/440/416 +f 474/513/484 143/555/223 220/556/222 +f 220/556/222 222/241/225 221/240/224 +f 221/240/224 474/513/484 220/556/222 +f 143/555/223 463/499/473 144/514/485 +f 498/545/520 499/546/521 421/453/428 +f 501/549/524 424/456/293 423/455/430 +f 423/455/430 500/548/523 501/549/524 +f 284/557/291 487/531/504 441/477/451 +f 285/476/292 284/557/291 441/477/451 +f 151/534/150 487/531/504 284/557/291 +f 423/455/430 390/415/397 500/548/523 +f 437/470/445 212/527/500 438/471/446 +f 478/519/490 439/472/447 438/471/446 +f 438/471/446 485/519/498 478/519/490 +f 454/490/464 439/472/447 478/519/490 +f 478/519/490 461/497/471 454/490/464 +f 304/288/311 321/307/328 319/303/326 +f 319/303/326 305/289/312 304/288/311 +f 310/294/317 305/289/312 319/303/326 +f 319/303/326 318/302/325 310/294/317 +f 318/302/325 236/324/238 239/318/241 +f 239/318/241 310/294/317 318/302/325 +f 211/220/212 506/558/530 438/559/531 +f 438/559/531 212/221/213 211/220/212 +f 209/218/210 205/214/206 208/217/209 +f 208/217/209 210/219/211 209/218/210 +f 207/216/208 206/215/207 485/560/532 +f 485/560/532 507/561/533 207/216/208 +f 438/559/531 506/559/530 507/561/533 +f 507/561/533 485/560/532 438/559/531 +f 508/562/534 509/563/535 199/564/536 +f 199/564/536 204/565/537 508/562/534 +f 141/566/538 510/567/539 508/562/534 +f 508/562/534 204/565/537 141/566/538 +f 511/568/540 510/567/539 141/566/538 +f 141/566/538 136/569/541 511/568/540 +f 512/570/542 511/568/540 136/569/541 +f 136/569/541 139/571/543 512/570/542 +f 513/572/544 512/570/542 139/571/543 +f 139/571/543 210/573/545 513/572/544 +f 210/573/545 208/574/546 514/575/547 +f 514/575/547 513/572/544 210/573/545 +f 207/576/548 507/577/549 506/578/550 +f 515/579/551 516/580/552 207/576/548 +f 207/576/548 506/578/550 515/579/551 +f 517/581/553 515/579/551 506/578/550 +f 506/578/550 211/581/554 517/581/553 +f 518/582/555 517/581/553 211/581/554 +f 211/581/554 200/583/556 518/582/555 +f 208/574/546 207/576/548 516/580/552 +f 516/580/552 514/575/547 208/574/546 +f 200/583/556 199/564/536 509/563/535 +f 509/563/535 518/582/555 200/583/556 +f 519/584/264 518/582/555 509/563/535 +f 509/563/535 508/562/534 519/584/264 +f 518/582/555 519/584/264 517/581/553 +f 519/584/264 516/580/552 515/579/551 +f 515/579/551 517/581/553 519/584/264 +f 516/580/552 519/584/264 514/575/547 +f 514/575/547 519/584/264 513/572/544 +f 513/572/544 519/584/264 512/570/542 +f 512/570/542 519/584/264 511/568/540 +f 519/584/264 508/562/534 510/567/539 +f 510/567/539 511/568/540 519/584/264 +f 11/11/11 194/205/196 82/87/82 +f 85/90/85 84/89/84 17/17/17 +f 17/17/17 196/207/198 85/90/85 +f 86/91/86 85/90/85 196/207/198 +f 196/207/198 197/208/199 86/91/86 +f 87/92/87 86/91/86 197/208/199 +f 197/208/199 198/209/1 87/92/87 +f 187/198/189 84/89/84 15/15/15 +f 15/15/15 24/24/24 187/198/189 +f 188/199/190 187/198/189 24/24/24 +f 24/24/24 25/25/25 188/199/190 +f 27/27/27 188/199/190 195/206/197 +f 195/206/197 191/202/193 27/27/27 +f 323/310/330 19/314/19 194/585/196 +f 194/585/196 324/313/331 323/310/330 +f 11/317/11 325/312/332 324/311/331 +f 324/311/331 194/586/196 11/317/11 +f 320/305/327 230/326/232 232/325/234 +f 290/270/297 287/267/294 286/266/293 +f 286/266/293 291/273/298 290/270/297 +f 290/270/297 291/273/298 303/285/310 +f 379/400/386 520/587/557 378/398/385 +f 378/398/385 356/371/363 379/400/386 +f 380/401/387 521/588/558 520/587/557 +f 520/587/557 379/400/386 380/401/387 +f 381/403/388 372/391/379 521/588/558 +f 521/588/558 380/401/387 381/403/388 +f 376/395/383 522/589/559 382/405/389 +f 382/405/389 354/365/361 376/395/383 +f 522/589/559 372/391/379 381/403/388 +f 381/403/388 382/405/389 522/589/559 +f 376/395/383 375/394/382 523/590/560 +f 523/590/560 371/390/378 376/395/383 +f 523/590/560 375/394/382 377/396/384 +f 377/396/384 524/591/561 523/590/560 +f 524/592/561 377/397/384 378/398/385 +f 378/398/385 363/382/370 524/592/561 +f 520/587/557 360/379/367 363/382/370 +f 363/382/370 378/398/385 520/587/557 +f 521/588/558 364/383/371 360/379/367 +f 360/379/367 520/587/557 521/588/558 +f 367/386/374 364/383/371 521/588/558 +f 521/588/558 372/391/379 367/386/374 +f 371/390/378 370/389/377 522/589/559 +f 522/589/559 376/395/383 371/390/378 +f 372/391/379 522/589/559 370/389/377 +f 371/390/378 523/590/560 525/593/562 +f 525/593/562 368/387/375 371/390/378 +f 525/593/562 523/590/560 524/591/561 +f 524/591/561 374/594/381 525/593/562 +f 374/393/381 524/592/561 363/382/370 +f 363/382/370 362/381/369 374/393/381 +f 361/380/368 334/335/341 333/334/340 +f 333/334/340 362/381/369 361/380/368 +f 337/338/344 334/335/341 361/380/368 +f 361/380/368 365/384/372 337/338/344 +f 349/359/356 337/338/344 365/384/372 +f 365/384/372 366/385/373 349/359/356 +f 350/360/357 349/359/356 366/385/373 +f 366/385/373 369/388/376 350/360/357 +f 368/387/375 351/360/358 350/360/357 +f 350/360/357 369/388/376 368/387/375 +f 351/360/358 368/387/375 352/361/359 +f 373/392/380 352/361/359 368/387/375 +f 368/387/375 525/593/562 373/392/380 +f 525/593/562 374/594/381 332/333/339 +f 332/333/339 373/392/380 525/593/562 +f 304/288/311 312/296/319 322/309/329 +f 322/309/329 321/307/328 304/288/311 +f 154/162/153 222/595/225 156/164/155 +f 169/177/168 285/265/292 152/160/151 +f 156/164/155 169/177/168 152/160/151 +f 154/162/153 156/164/155 152/160/151 +f 157/165/156 156/164/155 222/595/225 +f 222/595/225 220/237/222 157/165/156 +f 152/512/151 285/476/292 443/479/453 +f 108/113/108 110/115/110 526/596/91 +f 526/596/91 109/114/109 108/113/108 +f 1/1/1 527/4/563 528/3/564 +f 528/3/564 2/2/2 1/1/1 +f 529/5/565 530/8/566 7/7/7 +f 7/7/7 6/6/6 529/5/565 +f 9/9/9 12/12/12 531/11/567 +f 531/11/567 532/10/568 9/9/9 +f 533/13/569 534/14/570 528/3/564 +f 528/3/564 527/4/563 533/13/569 +f 535/15/571 536/16/572 534/14/570 +f 534/14/570 533/13/569 535/15/571 +f 537/17/573 538/20/574 539/19/575 +f 539/19/575 540/18/576 537/17/573 +f 2/2/2 528/3/564 541/22/577 +f 541/22/577 21/21/21 2/2/2 +f 542/23/578 536/16/572 535/15/571 +f 535/15/571 543/24/579 542/23/578 +f 544/25/580 545/26/581 542/23/578 +f 542/23/578 543/24/579 544/25/580 +f 546/27/582 540/18/576 539/19/575 +f 539/19/575 547/28/583 546/27/582 +f 548/29/584 549/31/585 550/30/586 +f 550/30/586 541/22/577 548/29/584 +f 551/32/587 552/35/588 553/34/589 +f 553/34/589 554/33/590 551/32/587 +f 552/35/588 551/32/587 555/37/591 +f 555/37/591 556/36/592 552/35/588 +f 556/36/592 555/37/591 557/39/593 +f 557/39/593 558/38/594 556/36/592 +f 559/40/595 558/38/594 557/39/593 +f 557/39/593 560/41/596 559/40/595 +f 561/42/597 559/40/595 560/41/596 +f 560/41/596 562/43/598 561/42/597 +f 561/42/597 562/43/598 563/44/599 +f 564/47/600 565/46/601 566/45/602 +f 566/45/602 567/48/603 564/47/600 +f 554/33/590 553/34/589 568/49/604 +f 568/49/604 565/46/601 554/33/590 +f 569/50/605 570/53/606 571/52/607 +f 571/52/607 572/51/608 569/50/605 +f 573/54/609 571/58/607 570/57/606 +f 574/56/610 575/55/611 573/54/609 +f 573/54/609 570/57/606 574/56/610 +f 576/59/612 575/55/611 574/56/610 +f 574/56/610 577/60/613 576/59/612 +f 578/61/614 579/64/615 580/63/616 +f 580/63/616 581/62/617 578/61/614 +f 582/65/618 579/64/615 578/61/614 +f 578/61/614 583/66/619 582/65/618 +f 584/67/620 585/68/621 582/65/618 +f 582/65/618 583/66/619 584/67/620 +f 586/69/622 587/72/623 588/71/624 +f 588/71/624 589/70/625 586/69/622 +f 590/73/626 591/74/627 569/50/605 +f 569/50/605 572/51/608 590/73/626 +f 592/75/628 575/78/611 576/77/612 +f 576/77/612 593/76/629 592/75/628 +f 594/79/630 593/76/629 576/77/612 +f 576/77/612 577/80/613 594/79/630 +f 595/81/631 579/64/615 582/65/618 +f 585/68/621 596/82/632 595/81/631 +f 595/81/631 582/65/618 585/68/621 +f 587/72/623 592/75/628 593/76/629 +f 593/76/629 588/71/624 587/72/623 +f 597/83/633 542/23/578 545/26/581 +f 545/26/581 598/84/634 597/83/633 +f 599/85/635 597/83/633 598/84/634 +f 598/84/634 600/86/636 599/85/635 +f 601/87/637 531/11/567 12/12/12 +f 12/12/12 83/88/83 601/87/637 +f 541/22/577 528/3/564 534/14/570 +f 534/14/570 548/29/584 541/22/577 +f 602/89/638 535/15/571 533/13/569 +f 533/13/569 603/90/639 602/89/638 +f 603/90/639 533/13/569 527/4/563 +f 527/4/563 604/91/640 603/90/639 +f 604/91/640 527/4/563 1/1/1 +f 1/1/1 87/92/87 604/91/640 +f 88/93/88 9/9/9 532/10/568 +f 532/10/568 605/94/641 88/93/88 +f 601/87/637 83/88/83 90/95/90 +f 90/95/90 547/28/583 601/87/637 +f 529/5/565 6/6/6 91/96/91 +f 91/96/91 606/97/642 529/5/565 +f 607/98/643 96/101/96 95/100/95 +f 95/100/95 608/99/644 607/98/643 +f 609/102/645 99/104/99 98/103/98 +f 98/103/98 608/99/644 609/102/645 +f 98/103/98 100/105/100 607/98/643 +f 607/98/643 608/99/644 98/103/98 +f 101/106/101 104/109/104 610/108/643 +f 610/108/643 611/107/646 101/106/101 +f 610/108/643 106/111/106 105/110/105 +f 105/110/105 611/107/646 610/108/643 +f 607/98/643 611/107/646 105/110/105 +f 105/110/105 96/101/96 607/98/643 +f 608/99/644 95/100/95 107/112/107 +f 107/112/107 609/102/645 608/99/644 +f 107/112/107 109/114/109 612/113/647 +f 612/113/647 609/102/645 107/112/107 +f 99/104/99 609/102/645 612/113/647 +f 612/113/647 110/115/110 99/104/99 +f 101/106/101 611/107/646 607/98/643 +f 607/98/643 100/105/100 101/106/101 +f 104/109/104 88/117/88 613/116/648 +f 613/116/648 610/108/643 104/109/104 +f 610/108/643 613/116/648 91/118/91 +f 91/118/91 106/111/106 610/108/643 +f 112/119/112 614/122/649 615/121/650 +f 615/121/650 113/120/113 112/119/112 +f 616/123/651 550/30/586 549/31/585 +f 549/31/585 617/124/652 616/123/651 +f 118/125/118 119/126/119 550/30/586 +f 550/30/586 616/123/651 118/125/118 +f 618/127/653 619/128/654 617/124/652 +f 617/124/652 549/31/585 618/127/653 +f 91/96/91 613/129/648 606/97/642 +f 605/94/641 613/129/648 88/93/88 +f 606/97/642 613/129/648 605/94/641 +f 605/94/641 529/5/565 606/97/642 +f 21/21/21 541/22/577 550/30/586 +f 550/30/586 119/126/119 21/21/21 +f 616/123/651 620/131/655 122/130/122 +f 122/130/122 118/125/118 616/123/651 +f 614/122/649 112/119/112 125/133/125 +f 125/133/125 621/132/656 614/122/649 +f 622/134/657 623/137/658 624/136/659 +f 624/136/659 625/135/660 622/134/657 +f 618/127/653 624/136/659 623/137/658 +f 623/137/658 619/128/654 618/127/653 +f 616/123/651 617/124/652 626/138/661 +f 626/138/661 620/131/655 616/123/651 +f 619/128/654 627/140/662 628/139/663 +f 628/139/663 617/124/652 619/128/654 +f 628/139/663 626/138/661 617/124/652 +f 619/128/654 623/137/658 627/140/662 +f 627/140/662 623/137/658 622/134/657 +f 622/134/657 629/141/664 627/140/662 +f 134/142/125 630/143/665 621/132/656 +f 621/132/656 125/133/125 134/142/125 +f 631/144/666 632/147/667 633/146/668 +f 633/146/668 634/145/669 631/144/666 +f 635/148/670 636/149/363 631/144/666 +f 631/144/666 634/145/669 635/148/670 +f 637/150/671 638/152/672 639/151/673 +f 640/153/674 638/152/672 637/150/671 +f 637/150/671 641/154/675 640/153/674 +f 638/152/672 640/153/674 642/155/676 +f 643/156/677 644/159/678 645/158/679 +f 645/158/679 646/157/680 643/156/677 +f 647/160/681 648/162/682 649/161/683 +f 650/163/684 651/166/685 652/165/686 +f 652/165/686 653/164/516 650/163/684 +f 641/154/675 654/168/687 655/167/688 +f 655/167/688 640/153/674 641/154/675 +f 656/169/689 657/170/690 640/153/674 +f 640/153/674 655/167/688 656/169/689 +f 658/171/691 643/156/677 646/157/680 +f 646/157/680 659/172/692 658/171/691 +f 660/173/693 661/175/694 662/174/695 +f 662/174/695 658/171/691 660/173/693 +f 650/163/684 653/164/516 663/177/696 +f 663/177/696 664/176/697 650/163/684 +f 665/178/271 666/180/698 667/179/699 +f 668/183/700 667/182/701 666/181/702 +f 666/181/702 669/184/703 668/183/700 +f 668/183/700 669/184/703 670/185/704 +f 671/186/705 672/188/706 673/187/707 +f 674/189/708 673/187/707 672/188/706 +f 675/191/709 676/190/710 674/189/708 +f 674/189/708 672/188/706 675/191/709 +f 675/191/709 666/180/698 665/178/271 +f 665/178/271 676/190/710 675/191/709 +f 667/179/699 677/192/711 651/166/685 +f 651/166/685 665/178/271 667/179/699 +f 651/166/685 650/163/684 665/178/271 +f 668/183/700 655/167/688 654/168/687 +f 654/168/687 667/182/701 668/183/700 +f 655/167/688 668/183/700 670/185/704 +f 670/185/704 678/193/712 655/167/688 +f 660/173/693 679/194/713 671/186/705 +f 673/187/707 661/175/694 660/173/693 +f 660/173/693 671/186/705 673/187/707 +f 673/187/707 674/189/708 661/175/694 +f 665/178/271 650/163/684 664/176/697 +f 664/176/697 676/190/710 665/178/271 +f 639/151/673 680/195/714 641/154/675 +f 641/154/675 637/150/671 639/151/673 +f 654/168/687 641/154/675 680/195/714 +f 680/195/714 677/196/715 654/168/687 +f 654/168/687 677/196/715 667/182/701 +f 615/121/650 681/197/716 599/85/635 +f 599/85/635 600/86/636 615/121/650 +f 540/18/576 682/198/717 602/89/638 +f 602/89/638 537/17/573 540/18/576 +f 546/27/582 683/199/718 682/198/717 +f 682/198/717 540/18/576 546/27/582 +f 189/200/191 190/201/192 545/26/581 +f 545/26/581 544/25/580 189/200/191 +f 547/28/583 90/95/90 191/202/193 +f 191/202/193 546/27/582 547/28/583 +f 190/201/192 192/203/194 598/84/634 +f 598/84/634 545/26/581 190/201/192 +f 192/203/194 193/204/195 600/86/636 +f 600/86/636 598/84/634 192/203/194 +f 539/19/575 684/205/719 601/87/637 +f 601/87/637 547/28/583 539/19/575 +f 614/122/649 625/135/660 681/197/716 +f 681/197/716 615/121/650 614/122/649 +f 621/132/656 622/134/657 625/135/660 +f 625/135/660 614/122/649 621/132/656 +f 113/120/113 615/121/650 600/86/636 +f 600/86/636 193/204/195 113/120/113 +f 195/206/197 189/200/191 544/25/580 +f 544/25/580 683/199/718 195/206/197 +f 629/141/664 622/134/657 621/132/656 +f 621/132/656 630/143/665 629/141/664 +f 537/17/573 685/207/720 538/20/574 +f 685/207/720 686/208/721 530/8/566 +f 7/7/7 530/8/566 686/208/721 +f 686/208/721 198/209/1 7/7/7 +f 687/210/722 688/212/723 689/211/724 +f 689/211/724 690/211/725 687/210/722 +f 688/212/723 687/210/722 691/213/726 +f 691/213/726 692/213/727 688/212/723 +f 693/214/728 694/217/729 695/216/730 +f 695/216/730 696/215/731 693/214/728 +f 633/146/668 632/147/667 697/219/732 +f 697/219/732 698/218/733 633/146/668 +f 690/211/725 689/211/724 699/221/734 +f 699/221/734 700/220/735 690/211/725 +f 692/213/727 691/213/726 636/149/363 +f 636/149/363 635/148/670 692/213/727 +f 588/71/624 596/82/632 701/222/736 +f 701/222/736 589/70/625 588/71/624 +f 591/74/627 590/73/626 702/224/737 +f 702/224/737 703/223/738 591/74/627 +f 704/225/739 572/51/608 571/52/607 +f 571/52/607 573/226/609 704/225/739 +f 580/63/616 579/64/615 595/81/631 +f 595/81/631 705/227/740 580/63/616 +f 596/82/632 588/71/624 593/76/629 +f 593/76/629 594/79/630 596/82/632 +f 704/225/739 702/224/737 590/73/626 +f 590/73/626 572/51/608 704/225/739 +f 553/34/589 552/35/588 570/53/606 +f 570/53/606 569/50/605 553/34/589 +f 574/56/610 570/57/606 552/230/588 +f 556/229/592 558/228/594 574/56/610 +f 574/56/610 552/230/588 556/229/592 +f 558/228/594 581/231/617 574/56/610 +f 581/62/617 558/38/594 559/40/595 +f 559/40/595 578/61/614 581/62/617 +f 559/40/595 561/42/597 583/66/619 +f 583/66/619 578/61/614 559/40/595 +f 583/66/619 561/42/597 563/44/599 +f 563/44/599 584/67/620 583/66/619 +f 586/69/622 589/70/625 567/48/603 +f 566/45/602 703/223/738 586/69/622 +f 586/69/622 567/48/603 566/45/602 +f 553/34/589 569/50/605 591/74/627 +f 591/74/627 568/49/604 553/34/589 +f 567/48/603 589/70/625 701/222/736 +f 701/222/736 584/67/620 563/44/599 +f 563/44/599 567/48/603 701/222/736 +f 566/45/602 568/49/604 591/74/627 +f 591/74/627 703/223/738 566/45/602 +f 701/222/736 596/82/632 585/68/621 +f 585/68/621 584/67/620 701/222/736 +f 702/224/737 587/72/623 586/69/622 +f 586/69/622 703/223/738 702/224/737 +f 704/225/739 573/226/609 575/78/611 +f 575/78/611 592/75/628 704/225/739 +f 705/227/740 595/81/631 594/79/630 +f 594/79/630 577/80/613 705/227/740 +f 596/82/632 594/79/630 595/81/631 +f 702/224/737 704/225/739 592/75/628 +f 592/75/628 587/72/623 702/224/737 +f 574/56/610 581/231/617 705/232/740 +f 705/232/740 577/60/613 574/56/610 +f 581/231/617 580/233/616 705/232/740 +f 566/45/602 565/46/601 568/49/604 +f 563/44/599 562/43/598 564/47/600 +f 564/47/600 567/48/603 563/44/599 +f 640/153/674 657/170/690 706/235/741 +f 706/235/741 642/155/676 640/153/674 +f 706/235/741 707/234/742 642/155/676 +f 680/236/743 639/238/744 708/237/745 +f 708/237/745 652/165/686 680/236/743 +f 677/192/711 680/236/743 652/165/686 +f 652/165/686 651/166/685 677/192/711 +f 649/239/683 648/239/682 709/241/746 +f 709/241/746 710/240/747 649/239/683 +f 711/32/748 712/243/749 713/242/750 +f 713/242/750 714/33/751 711/32/748 +f 712/243/749 711/32/748 715/37/752 +f 715/37/752 716/36/753 712/243/749 +f 715/37/752 717/39/754 718/38/755 +f 718/38/755 716/36/753 715/37/752 +f 719/40/756 718/38/755 717/39/754 +f 717/39/754 720/41/757 719/40/756 +f 720/41/757 721/244/758 722/244/759 +f 722/244/759 719/40/756 720/41/757 +f 721/244/758 723/47/760 724/245/761 +f 724/245/761 722/244/759 721/244/758 +f 725/47/762 723/47/760 726/246/763 +f 714/33/751 713/242/750 727/49/764 +f 727/49/764 728/46/765 714/33/751 +f 729/50/766 730/53/767 731/52/768 +f 731/52/768 732/51/769 729/50/766 +f 733/54/770 731/58/768 730/57/767 +f 734/56/610 735/55/771 733/54/770 +f 733/54/770 730/57/767 734/56/610 +f 736/59/612 735/55/771 734/56/610 +f 734/56/610 737/60/772 736/59/612 +f 738/64/773 739/63/774 740/62/775 +f 740/62/775 741/61/776 738/64/773 +f 742/65/777 738/64/773 741/61/776 +f 741/61/776 743/66/778 742/65/777 +f 742/65/777 743/66/778 744/67/779 +f 744/67/779 745/68/780 742/65/777 +f 746/70/781 747/69/782 748/72/783 +f 748/72/783 749/71/784 746/70/781 +f 750/73/785 751/74/786 729/50/766 +f 729/50/766 732/51/769 750/73/785 +f 752/75/787 735/78/771 736/77/612 +f 736/77/612 753/76/788 752/75/787 +f 754/79/789 753/76/788 736/77/612 +f 736/77/612 737/80/772 754/79/789 +f 755/81/790 738/64/773 742/65/777 +f 745/68/780 756/82/791 755/81/790 +f 755/81/790 742/65/777 745/68/780 +f 748/72/783 752/75/787 753/76/788 +f 753/76/788 749/71/784 748/72/783 +f 746/70/781 749/71/784 756/82/791 +f 756/82/791 757/222/792 746/70/781 +f 758/223/793 751/74/786 750/73/785 +f 750/73/785 759/247/169 758/223/793 +f 760/225/794 732/51/769 731/52/768 +f 731/52/768 733/226/770 760/225/794 +f 739/63/774 738/64/773 755/81/790 +f 755/81/790 761/227/795 739/63/774 +f 756/82/791 749/71/784 753/76/788 +f 753/76/788 754/79/789 756/82/791 +f 750/73/785 732/51/769 760/225/794 +f 760/225/794 759/247/169 750/73/785 +f 712/243/749 730/53/767 729/50/766 +f 729/50/766 713/242/750 712/243/749 +f 734/56/610 730/57/767 712/249/749 +f 716/248/753 718/228/755 734/56/610 +f 734/56/610 712/249/749 716/248/753 +f 718/228/755 740/250/775 734/56/610 +f 718/38/755 719/40/756 741/61/776 +f 741/61/776 740/62/775 718/38/755 +f 719/40/756 722/244/759 743/66/778 +f 743/66/778 741/61/776 719/40/756 +f 743/66/778 722/244/759 724/245/761 +f 724/245/761 744/67/779 743/66/778 +f 746/70/781 757/222/792 725/47/762 +f 725/47/762 747/69/782 746/70/781 +f 726/246/763 758/223/793 747/69/782 +f 747/69/782 725/47/762 726/246/763 +f 713/242/750 729/50/766 751/74/786 +f 751/74/786 727/49/764 713/242/750 +f 757/222/792 744/67/779 724/245/761 +f 724/245/761 725/47/762 757/222/792 +f 726/246/763 727/49/764 751/74/786 +f 751/74/786 758/223/793 726/246/763 +f 757/222/792 756/82/791 745/68/780 +f 745/68/780 744/67/779 757/222/792 +f 758/223/793 759/247/169 748/72/783 +f 748/72/783 747/69/782 758/223/793 +f 760/225/794 733/226/770 735/78/771 +f 735/78/771 752/75/787 760/225/794 +f 761/227/795 755/81/790 754/79/789 +f 754/79/789 737/80/772 761/227/795 +f 756/82/791 754/79/789 755/81/790 +f 759/247/169 760/225/794 752/75/787 +f 752/75/787 748/72/783 759/247/169 +f 734/56/610 740/250/775 761/232/795 +f 761/232/795 737/60/772 734/56/610 +f 740/250/775 739/233/774 761/232/795 +f 726/246/763 723/47/760 728/46/765 +f 728/46/765 727/49/764 726/246/763 +f 724/245/761 723/47/760 725/47/762 +f 655/167/688 678/193/712 656/169/689 +f 679/194/713 660/173/693 762/251/796 +f 762/251/796 660/173/693 658/171/691 +f 658/171/691 659/172/692 762/251/796 +f 672/252/706 669/184/797 666/181/698 +f 666/181/698 675/181/709 672/252/706 +f 646/253/680 645/254/679 707/234/798 +f 707/234/798 706/235/799 646/253/680 +f 659/255/692 646/253/680 706/235/799 +f 706/235/799 657/170/800 659/255/692 +f 672/252/706 671/256/705 670/185/801 +f 670/185/801 669/184/797 672/252/706 +f 679/193/713 762/169/796 656/169/802 +f 656/169/802 678/193/803 679/193/713 +f 671/256/705 679/193/713 678/193/803 +f 678/193/803 670/185/801 671/256/705 +f 762/169/796 659/255/692 657/170/800 +f 657/170/800 656/169/802 762/169/796 +f 763/257/804 277/259/284 764/258/805 +f 765/261/806 766/260/807 277/259/284 +f 277/259/284 280/262/287 765/261/806 +f 764/258/805 277/259/284 766/260/807 +f 767/263/808 281/263/288 277/259/284 +f 277/259/284 768/257/809 767/263/808 +f 768/257/809 277/259/284 763/257/804 +f 644/159/678 643/156/677 769/264/810 +f 658/171/691 662/174/695 769/264/810 +f 769/264/810 643/156/677 658/171/691 +f 663/177/696 770/265/811 769/264/810 +f 769/264/810 662/174/695 663/177/696 +f 661/175/694 664/176/697 663/177/696 +f 663/177/696 662/174/695 661/175/694 +f 664/176/697 661/175/694 674/189/708 +f 674/189/708 676/190/710 664/176/697 +f 771/266/812 772/269/813 773/268/814 +f 773/268/814 774/267/815 771/266/812 +f 774/267/815 538/272/574 685/271/720 +f 685/271/720 775/270/816 774/267/815 +f 776/273/817 777/275/818 778/274/819 +f 778/274/819 771/266/812 776/273/817 +f 779/276/820 778/274/819 777/275/818 +f 777/275/818 780/277/821 779/276/820 +f 781/278/822 782/281/823 783/280/824 +f 783/280/824 784/279/825 781/278/822 +f 778/274/819 779/276/820 785/283/826 +f 785/283/826 786/282/827 778/274/819 +f 777/275/818 776/273/817 787/285/828 +f 787/285/828 788/284/829 777/275/818 +f 787/285/828 530/287/566 529/286/565 +f 529/286/565 788/284/829 787/285/828 +f 771/266/812 778/274/819 786/282/827 +f 786/282/827 772/269/813 771/266/812 +f 789/288/830 782/281/823 790/290/831 +f 790/290/831 791/289/832 789/288/830 +f 782/281/823 792/292/833 793/291/834 +f 793/291/834 790/290/831 782/281/823 +f 794/293/835 795/294/836 791/289/832 +f 791/289/832 790/290/831 794/293/835 +f 794/293/835 790/290/831 793/291/834 +f 793/291/834 796/295/837 794/293/835 +f 685/271/720 530/287/566 787/285/828 +f 787/285/828 775/270/816 685/271/720 +f 789/288/830 797/296/838 783/280/824 +f 783/280/824 782/281/823 789/288/830 +f 798/297/839 799/300/840 800/299/841 +f 800/299/841 801/298/842 798/297/839 +f 801/298/842 800/299/841 793/291/834 +f 793/291/834 792/292/833 801/298/842 +f 802/301/843 799/304/840 803/303/844 +f 803/303/844 804/302/845 802/301/843 +f 799/300/840 802/306/843 805/305/846 +f 805/305/846 800/299/841 799/300/840 +f 805/305/846 796/295/837 793/291/834 +f 793/291/834 800/299/841 805/305/846 +f 803/303/844 799/304/840 798/308/839 +f 798/308/839 806/307/847 803/303/844 +f 806/307/847 798/308/839 807/310/848 +f 807/310/848 808/309/849 806/307/847 +f 777/275/818 788/284/829 780/277/821 +f 809/311/850 798/297/839 801/298/842 +f 801/298/842 810/312/851 809/311/850 +f 798/308/839 809/313/850 807/310/848 +f 539/314/575 773/268/814 808/309/849 +f 808/309/849 807/310/848 539/314/575 +f 773/268/814 772/269/813 797/296/838 +f 797/296/838 808/309/849 773/268/814 +f 797/296/838 772/269/813 786/282/827 +f 786/282/827 783/280/824 797/296/838 +f 783/280/824 786/282/827 785/283/826 +f 785/283/826 784/279/825 783/280/824 +f 605/315/641 532/316/568 779/276/820 +f 779/276/820 780/277/821 605/315/641 +f 529/286/565 605/315/641 780/277/821 +f 780/277/821 788/284/829 529/286/565 +f 782/281/823 781/278/822 792/292/833 +f 781/278/822 801/298/842 792/292/833 +f 801/298/842 781/278/822 784/279/825 +f 784/279/825 810/312/851 801/298/842 +f 810/312/851 784/279/825 785/283/826 +f 785/283/826 531/317/567 810/312/851 +f 532/316/568 531/317/567 785/283/826 +f 785/283/826 779/276/820 532/316/568 +f 728/318/765 795/294/836 714/319/751 +f 794/293/835 711/320/748 714/319/751 +f 714/319/751 795/294/836 794/293/835 +f 796/295/837 715/321/752 711/320/748 +f 711/320/748 794/293/835 796/295/837 +f 804/302/845 723/324/760 721/323/758 +f 721/323/758 720/322/757 802/301/843 +f 802/301/843 804/302/845 721/323/758 +f 805/305/846 802/306/843 720/325/757 +f 717/326/754 715/321/752 796/295/837 +f 796/295/837 805/305/846 717/326/754 +f 773/268/814 539/314/575 538/272/574 +f 538/272/574 774/267/815 773/268/814 +f 811/327/852 812/330/853 813/329/854 +f 813/329/854 814/328/855 811/327/852 +f 814/328/855 813/329/854 815/332/856 +f 815/332/856 816/331/857 814/328/855 +f 817/333/858 816/331/857 815/332/856 +f 818/334/859 819/336/860 820/335/861 +f 821/337/862 822/338/863 820/335/861 +f 820/335/861 819/336/860 821/337/862 +f 813/329/854 812/330/853 823/340/864 +f 823/340/864 824/339/865 813/329/854 +f 815/332/856 813/329/854 824/339/865 +f 824/339/865 542/341/578 815/332/856 +f 597/342/633 817/333/858 815/332/856 +f 815/332/856 542/341/578 597/342/633 +f 825/343/866 818/334/859 817/345/858 +f 817/345/858 597/344/633 825/343/866 +f 826/346/867 819/336/860 818/334/859 +f 818/334/859 825/343/866 826/346/867 +f 827/347/868 821/337/862 819/336/860 +f 819/336/860 826/346/867 827/347/868 +f 828/348/869 821/337/862 827/347/868 +f 827/347/868 829/349/870 828/348/869 +f 536/352/572 830/351/871 831/350/872 +f 831/350/872 534/353/570 536/352/572 +f 832/354/873 618/356/653 549/355/585 +f 832/354/873 549/355/585 548/358/584 +f 548/358/584 833/357/874 832/354/873 +f 834/359/875 822/338/863 821/337/862 +f 821/337/862 828/348/869 834/359/875 +f 835/360/876 811/327/852 814/328/855 +f 814/328/855 836/361/877 835/360/876 +f 835/360/876 837/360/878 811/327/852 +f 555/362/591 838/365/879 839/364/880 +f 839/364/880 557/363/593 555/362/591 +f 839/364/880 840/367/102 560/366/596 +f 560/366/596 557/363/593 839/364/880 +f 840/368/102 841/371/881 562/370/598 +f 562/370/598 560/369/596 840/368/102 +f 834/359/875 828/348/869 811/327/852 +f 811/327/852 837/360/878 834/359/875 +f 811/327/852 828/348/869 812/330/853 +f 830/351/871 823/340/864 829/349/870 +f 829/349/870 842/372/882 830/351/871 +f 534/353/570 831/350/872 833/357/874 +f 833/357/874 548/358/584 534/353/570 +f 624/373/659 618/356/653 843/374/883 +f 843/374/883 681/376/716 625/375/660 +f 625/375/660 624/373/659 843/374/883 +f 618/356/653 832/354/873 844/377/884 +f 844/377/884 843/374/883 618/356/653 +f 842/372/882 844/377/884 832/354/873 +f 832/354/873 833/357/874 842/372/882 +f 842/372/882 833/357/874 831/350/872 +f 831/350/872 830/351/871 842/372/882 +f 823/340/864 830/351/871 536/352/572 +f 536/352/572 824/339/865 823/340/864 +f 542/341/578 824/339/865 536/352/572 +f 825/343/866 597/344/633 599/378/635 +f 681/376/716 843/374/883 826/346/867 +f 826/346/867 825/343/866 681/376/716 +f 843/374/883 844/377/884 827/347/868 +f 827/347/868 826/346/867 843/374/883 +f 844/377/884 842/372/882 829/349/870 +f 829/349/870 827/347/868 844/377/884 +f 812/330/853 828/348/869 829/349/870 +f 829/349/870 823/340/864 812/330/853 +f 825/343/866 599/378/635 681/376/716 +f 845/379/220 846/382/885 847/381/886 +f 847/381/886 848/380/887 845/379/220 +f 849/383/888 845/379/220 848/380/887 +f 848/380/887 850/384/889 849/383/888 +f 851/385/890 852/386/891 849/383/888 +f 849/383/888 850/384/889 851/385/890 +f 853/387/892 854/390/893 855/389/894 +f 855/389/894 856/388/895 853/387/892 +f 852/386/891 851/385/890 856/388/895 +f 855/389/894 857/391/896 852/386/891 +f 852/386/891 856/388/895 855/389/894 +f 836/361/877 814/328/855 816/331/857 +f 816/331/857 858/392/897 836/361/877 +f 817/333/858 858/392/897 816/331/857 +f 817/345/858 818/334/859 847/381/886 +f 847/381/886 859/393/898 817/345/858 +f 838/365/879 860/395/899 861/394/900 +f 861/394/900 839/364/880 838/365/879 +f 861/394/900 862/396/901 840/367/102 +f 840/367/102 839/364/880 861/394/900 +f 862/397/901 863/398/902 841/371/881 +f 841/371/881 840/368/102 862/397/901 +f 564/399/600 562/370/598 841/371/881 +f 841/371/881 864/400/903 564/399/600 +f 865/401/904 565/402/601 564/399/600 +f 564/399/600 864/400/903 865/401/904 +f 866/403/905 554/404/590 565/402/601 +f 565/402/601 865/401/904 866/403/905 +f 838/365/879 555/362/591 551/406/587 +f 551/406/587 867/405/906 838/365/879 +f 867/405/906 551/406/587 554/404/590 +f 554/404/590 866/403/905 867/405/906 +f 868/407/907 869/410/908 385/409/392 +f 385/409/392 384/408/391 868/407/907 +f 868/407/907 870/413/909 871/412/910 +f 871/412/910 629/411/664 869/410/908 +f 869/410/908 868/407/907 871/412/910 +f 870/413/909 872/416/911 873/415/912 +f 873/415/912 874/414/913 870/413/909 +f 874/414/913 871/412/910 870/413/909 +f 620/417/655 875/420/914 392/419/399 +f 392/419/399 122/418/122 620/417/655 +f 134/421/125 385/409/392 869/410/908 +f 869/410/908 630/422/665 134/421/125 +f 628/423/663 876/426/915 877/425/916 +f 877/425/916 626/424/661 628/423/663 +f 629/411/664 871/412/910 874/414/913 +f 874/414/913 627/427/662 629/411/664 +f 877/425/916 875/420/914 620/417/655 +f 620/417/655 626/424/661 877/425/916 +f 627/427/662 874/414/913 876/426/915 +f 876/426/915 628/423/663 627/427/662 +f 878/428/917 879/429/914 875/420/914 +f 875/420/914 877/425/916 878/428/917 +f 392/419/399 875/420/914 879/429/914 +f 879/429/914 398/430/405 392/419/399 +f 880/431/918 881/434/919 401/433/408 +f 401/433/408 400/432/407 880/431/918 +f 882/438/920 883/437/921 405/437/412 +f 405/437/412 404/436/411 884/435/922 +f 884/435/922 882/438/920 405/437/412 +f 885/439/923 886/442/924 887/441/703 +f 887/441/703 888/440/925 885/439/923 +f 886/442/924 889/444/926 890/443/927 +f 890/443/927 887/441/703 886/442/924 +f 884/435/922 881/434/919 891/445/928 +f 891/445/928 882/438/920 884/435/922 +f 892/446/929 764/449/930 893/448/931 +f 893/448/931 894/447/932 892/446/929 +f 710/240/747 419/451/426 418/450/425 +f 418/450/425 649/239/683 710/240/747 +f 870/413/909 895/452/933 872/416/911 +f 896/453/934 897/456/812 898/455/935 +f 898/455/935 899/454/936 896/453/934 +f 425/457/431 900/460/937 901/459/938 +f 901/459/938 426/458/432 425/457/431 +f 429/461/435 281/463/438 767/461/939 +f 767/461/939 902/462/940 429/461/435 +f 894/447/932 893/448/931 903/465/941 +f 903/465/941 904/464/942 894/447/932 +f 905/466/943 906/467/944 901/459/938 +f 901/459/938 900/460/937 905/466/943 +f 907/468/945 436/469/444 419/451/426 +f 419/451/426 710/240/747 907/468/945 +f 908/472/946 909/471/947 910/470/948 +f 910/470/948 911/473/949 908/472/946 +f 886/442/924 893/448/931 764/449/930 +f 764/449/930 889/444/926 886/442/924 +f 903/465/941 893/448/931 886/442/924 +f 886/442/924 885/439/923 903/465/941 +f 889/444/926 766/475/950 765/474/951 +f 765/474/951 890/443/927 889/444/926 +f 770/476/811 443/479/453 442/478/452 +f 442/478/452 912/477/952 770/476/811 +f 913/480/953 914/483/954 915/482/955 +f 915/482/955 916/481/956 913/480/953 +f 917/484/957 895/452/933 918/486/958 +f 918/486/958 919/485/959 917/484/957 +f 870/413/909 868/407/907 920/487/960 +f 920/487/960 895/452/933 870/413/909 +f 914/483/954 764/449/930 892/446/929 +f 892/446/929 915/482/955 914/483/954 +f 918/486/958 895/452/933 920/487/960 +f 920/487/960 921/488/961 918/486/958 +f 453/489/463 401/433/408 881/434/919 +f 881/434/919 884/435/922 453/489/463 +f 911/473/949 922/492/962 923/491/963 +f 923/491/963 924/490/964 911/473/949 +f 925/493/965 926/494/966 924/490/964 +f 924/490/964 923/491/963 925/493/965 +f 927/495/967 923/491/963 922/492/962 +f 922/492/962 928/496/968 927/495/967 +f 924/490/964 926/494/966 929/498/969 +f 929/498/969 930/497/970 924/490/964 +f 931/499/971 932/502/972 933/501/973 +f 933/501/973 934/500/974 931/499/971 +f 935/503/975 913/480/953 469/505/479 +f 469/505/479 468/504/478 935/503/975 +f 916/481/956 470/506/480 469/505/479 +f 469/505/479 913/480/953 916/481/956 +f 916/481/956 921/488/961 471/507/481 +f 471/507/481 470/506/480 916/481/956 +f 868/407/907 384/408/391 472/508/482 +f 472/508/482 920/487/960 868/407/907 +f 936/509/976 899/454/936 917/484/957 +f 917/484/957 919/485/959 936/509/976 +f 443/479/453 647/512/681 649/511/683 +f 649/511/683 418/510/425 443/479/453 +f 710/240/747 937/513/977 925/493/965 +f 925/493/965 907/468/945 710/240/747 +f 638/514/978 642/515/979 932/502/972 +f 932/502/972 931/499/971 638/514/978 +f 907/468/945 925/493/965 923/491/963 +f 923/491/963 927/495/967 907/468/945 +f 436/469/444 907/468/945 927/495/967 +f 927/495/967 475/516/487 436/469/444 +f 938/517/980 891/445/928 881/434/919 +f 881/434/919 880/431/918 938/517/980 +f 924/490/964 908/472/946 911/473/949 +f 939/518/981 940/519/982 941/519/983 +f 941/519/983 930/497/970 939/518/981 +f 927/495/967 928/496/968 480/520/435 +f 480/520/435 475/516/487 927/495/967 +f 942/521/984 943/523/985 882/438/920 +f 882/438/920 944/522/986 942/521/984 +f 944/522/986 891/445/928 938/517/980 +f 938/517/980 635/524/987 944/522/986 +f 911/473/949 910/470/948 945/525/988 +f 945/525/988 922/492/962 911/473/949 +f 922/492/962 945/525/988 905/466/943 +f 905/466/943 900/460/937 928/496/968 +f 928/496/968 922/492/962 905/466/943 +f 696/519/989 946/519/990 941/519/983 +f 941/519/983 940/519/982 696/519/989 +f 910/470/948 699/527/991 689/526/992 +f 689/526/992 945/525/988 910/470/948 +f 947/528/993 942/521/984 634/530/994 +f 634/530/994 633/529/995 947/528/993 +f 898/455/935 873/415/912 872/416/911 +f 872/416/911 899/454/936 898/455/935 +f 872/416/911 917/484/957 899/454/936 +f 948/531/996 488/532/505 398/430/405 +f 398/430/405 879/429/914 948/531/996 +f 949/533/997 645/535/679 644/534/678 +f 644/534/678 878/428/917 949/533/997 +f 878/428/917 644/534/678 948/531/996 +f 948/531/996 879/429/914 878/428/917 +f 629/411/664 630/422/665 869/410/908 +f 950/536/998 764/449/930 914/483/954 +f 914/483/954 951/537/999 950/536/998 +f 453/489/463 884/435/922 404/436/411 +f 888/440/925 952/538/1000 883/437/1001 +f 883/437/1001 882/438/920 888/440/925 +f 888/440/925 887/441/703 952/538/1000 +f 887/441/703 890/443/927 953/539/1002 +f 953/539/1002 952/538/1000 887/441/703 +f 280/540/1003 953/539/1002 890/443/927 +f 890/443/927 765/474/951 280/540/1003 +f 883/437/921 494/437/512 405/437/412 +f 495/539/1004 494/437/1005 883/437/1001 +f 883/437/1001 952/538/1000 495/539/1004 +f 953/539/1002 496/539/1006 495/539/1004 +f 495/539/1004 952/538/1000 953/539/1002 +f 767/461/939 768/475/155 954/541/1007 +f 954/541/1007 902/462/940 767/461/939 +f 906/467/944 905/466/943 688/543/1008 +f 688/543/1008 692/542/1009 906/467/944 +f 698/544/1010 955/545/1011 947/528/993 +f 947/528/993 633/529/995 698/544/1010 +f 635/524/987 938/517/980 906/467/944 +f 906/467/944 692/542/1009 635/524/987 +f 880/431/918 901/459/938 906/467/944 +f 906/467/944 938/517/980 880/431/918 +f 400/432/407 426/458/432 901/459/938 +f 901/459/938 880/431/918 400/432/407 +f 903/465/941 942/521/984 947/528/993 +f 947/528/993 904/464/942 903/465/941 +f 885/439/923 943/523/985 942/521/984 +f 942/521/984 903/465/941 885/439/923 +f 899/454/936 936/509/976 956/546/1012 +f 956/546/1012 896/453/934 899/454/936 +f 693/547/1013 696/519/989 940/519/982 +f 940/519/982 955/545/1011 693/547/1013 +f 896/453/934 955/545/1011 940/519/982 +f 940/519/982 939/518/981 896/453/934 +f 957/548/1014 958/549/1015 645/535/679 +f 645/535/679 949/533/997 957/548/1014 +f 959/551/1016 933/501/973 932/502/972 +f 932/502/972 642/515/979 707/550/798 +f 707/550/798 959/551/1016 932/502/972 +f 876/426/915 874/414/913 873/415/912 +f 873/415/912 957/548/1014 876/426/915 +f 949/533/997 877/425/916 876/426/915 +f 876/426/915 957/548/1014 949/533/997 +f 688/543/1008 905/466/943 945/525/988 +f 945/525/988 689/526/992 688/543/1008 +f 480/520/435 928/496/968 900/460/937 +f 900/460/937 425/457/431 480/520/435 +f 939/518/981 960/552/1017 897/456/812 +f 897/456/812 896/453/934 939/518/981 +f 939/518/981 930/497/970 929/498/969 +f 929/498/969 960/552/1017 939/518/981 +f 904/464/942 947/528/993 955/545/1011 +f 955/545/1011 956/546/1012 904/464/942 +f 904/464/942 956/546/1012 936/509/976 +f 936/509/976 894/447/932 904/464/942 +f 892/446/929 894/447/932 936/509/976 +f 936/509/976 919/485/959 892/446/929 +f 915/482/955 892/446/929 919/485/959 +f 919/485/959 918/486/958 915/482/955 +f 921/488/961 920/487/960 472/508/482 +f 472/508/482 471/507/481 921/488/961 +f 916/481/956 915/482/955 918/486/958 +f 918/486/958 921/488/961 916/481/956 +f 926/494/966 925/493/965 937/513/977 +f 937/513/977 934/500/974 926/494/966 +f 929/498/969 926/494/966 934/500/974 +f 934/500/974 933/501/973 929/498/969 +f 933/501/973 959/551/1016 960/552/1017 +f 960/552/1017 929/498/969 933/501/973 +f 897/456/812 960/552/1017 959/551/1016 +f 959/551/1016 958/549/1015 897/456/812 +f 958/549/1015 959/551/1016 707/550/798 +f 707/550/798 645/535/679 958/549/1015 +f 902/462/940 954/541/1007 961/554/1018 +f 961/554/1018 504/553/527 902/462/940 +f 504/553/527 429/461/435 902/462/940 +f 935/503/975 468/504/478 504/553/527 +f 504/553/527 961/554/1018 935/503/975 +f 954/541/1007 768/475/155 763/536/1019 +f 763/536/1019 950/536/998 954/541/1007 +f 951/537/999 961/554/1018 954/541/1007 +f 954/541/1007 950/536/998 951/537/999 +f 951/537/999 914/483/954 913/480/953 +f 913/480/953 935/503/975 951/537/999 +f 935/503/975 961/554/1018 951/537/999 +f 488/532/505 948/531/996 912/477/952 +f 912/477/952 442/478/452 488/532/505 +f 949/533/997 878/428/917 877/425/916 +f 763/536/1019 764/449/930 950/536/998 +f 766/475/950 889/444/926 764/449/930 +f 931/499/971 934/500/974 937/513/977 +f 937/513/977 639/555/744 931/499/971 +f 888/440/925 882/438/920 943/523/985 +f 635/524/987 634/530/994 942/521/984 +f 942/521/984 944/522/986 635/524/987 +f 693/547/1013 955/545/1011 698/544/1010 +f 872/416/911 895/452/933 917/484/957 +f 953/539/1002 280/540/1003 496/539/1006 +f 944/522/986 882/438/920 891/445/928 +f 885/439/923 888/440/925 943/523/985 +f 710/240/747 709/241/746 708/556/745 +f 708/556/745 937/513/977 710/240/747 +f 708/556/745 639/555/744 937/513/977 +f 639/555/744 638/514/978 931/499/971 +f 955/545/1011 896/453/934 956/546/1012 +f 898/455/935 897/456/812 958/549/1015 +f 958/549/1015 957/548/1014 898/455/935 +f 769/557/810 912/477/952 948/531/996 +f 770/476/811 912/477/952 769/557/810 +f 644/534/678 769/557/810 948/531/996 +f 898/455/935 957/548/1014 873/415/912 +f 909/471/947 699/527/991 910/470/948 +f 941/519/983 946/519/990 909/471/947 +f 909/471/947 908/472/946 941/519/983 +f 924/490/964 930/497/970 941/519/983 +f 941/519/983 908/472/946 924/490/964 +f 789/288/830 791/289/832 803/303/844 +f 803/303/844 806/307/847 789/288/830 +f 795/294/836 804/302/845 803/303/844 +f 803/303/844 791/289/832 795/294/836 +f 804/302/845 795/294/836 728/318/765 +f 728/318/765 723/324/760 804/302/845 +f 700/220/735 699/221/734 909/559/1020 +f 909/559/1020 962/558/1021 700/220/735 +f 698/218/733 697/219/732 694/217/729 +f 694/217/729 693/214/728 698/218/733 +f 695/216/730 963/561/1022 946/560/1023 +f 946/560/1023 696/215/731 695/216/730 +f 909/559/1020 946/560/1023 963/561/1022 +f 963/561/1022 962/559/1021 909/559/1020 +f 964/562/1024 691/565/1025 687/564/1026 +f 687/564/1026 965/563/1027 964/562/1024 +f 636/566/1028 691/565/1025 964/562/1024 +f 964/562/1024 966/567/1029 636/566/1028 +f 967/568/1030 631/569/1031 636/566/1028 +f 636/566/1028 966/567/1029 967/568/1030 +f 968/571/1032 632/571/1033 631/569/1031 +f 631/569/1031 967/568/1030 968/571/1032 +f 969/572/1034 697/573/1035 632/571/1033 +f 632/571/1033 968/571/1032 969/572/1034 +f 697/573/1035 969/572/1034 970/575/1036 +f 970/575/1036 694/574/1037 697/573/1035 +f 962/578/1038 963/577/1039 695/576/1040 +f 695/576/1040 971/580/1041 972/579/1042 +f 972/579/1042 962/578/1038 695/576/1040 +f 973/581/1043 700/581/1044 962/578/1038 +f 962/578/1038 972/579/1042 973/581/1043 +f 974/582/1045 690/583/1046 700/581/1044 +f 700/581/1044 973/581/1043 974/582/1045 +f 694/574/1037 970/575/1036 971/580/1041 +f 971/580/1041 695/576/1040 694/574/1037 +f 690/583/1046 974/582/1045 965/563/1027 +f 965/563/1027 687/564/1026 690/583/1046 +f 965/563/1027 974/582/1045 975/584/787 +f 975/584/787 964/562/1024 965/563/1027 +f 974/582/1045 973/581/1043 975/584/787 +f 972/579/1042 971/580/1041 975/584/787 +f 975/584/787 973/581/1043 972/579/1042 +f 971/580/1041 970/575/1036 975/584/787 +f 970/575/1036 969/572/1034 975/584/787 +f 969/572/1034 968/571/1032 975/584/787 +f 968/571/1032 967/568/1030 975/584/787 +f 966/567/1029 964/562/1024 975/584/787 +f 975/584/787 967/568/1030 966/567/1029 +f 531/11/567 601/87/637 684/205/719 +f 603/90/639 685/207/720 537/17/573 +f 537/17/573 602/89/638 603/90/639 +f 604/91/640 686/208/721 685/207/720 +f 685/207/720 603/90/639 604/91/640 +f 87/92/87 198/209/1 686/208/721 +f 686/208/721 604/91/640 87/92/87 +f 682/198/717 543/24/579 535/15/571 +f 535/15/571 602/89/638 682/198/717 +f 683/199/718 544/25/580 543/24/579 +f 543/24/579 682/198/717 683/199/718 +f 546/27/582 191/202/193 195/206/197 +f 195/206/197 683/199/718 546/27/582 +f 807/310/848 809/313/850 684/585/719 +f 684/585/719 539/314/575 807/310/848 +f 531/317/567 684/586/719 809/311/850 +f 809/311/850 810/312/851 531/317/567 +f 805/305/846 720/325/757 717/326/754 +f 775/270/816 776/273/817 771/266/812 +f 771/266/812 774/267/815 775/270/816 +f 775/270/816 787/285/828 776/273/817 +f 864/400/903 841/371/881 863/398/902 +f 863/398/902 976/587/1047 864/400/903 +f 865/401/904 864/400/903 976/587/1047 +f 976/587/1047 977/588/1048 865/401/904 +f 866/403/905 865/401/904 977/588/1048 +f 977/588/1048 857/391/896 866/403/905 +f 860/395/899 838/365/879 867/405/906 +f 867/405/906 978/589/1049 860/395/899 +f 978/589/1049 867/405/906 866/403/905 +f 866/403/905 857/391/896 978/589/1049 +f 860/395/899 854/390/893 979/590/1050 +f 979/590/1050 861/394/900 860/395/899 +f 979/590/1050 980/591/1051 862/396/901 +f 862/396/901 861/394/900 979/590/1050 +f 980/592/1051 846/382/885 863/398/902 +f 863/398/902 862/397/901 980/592/1051 +f 976/587/1047 863/398/902 846/382/885 +f 846/382/885 845/379/220 976/587/1047 +f 977/588/1048 976/587/1047 845/379/220 +f 845/379/220 849/383/888 977/588/1048 +f 852/386/891 857/391/896 977/588/1048 +f 977/588/1048 849/383/888 852/386/891 +f 854/390/893 860/395/899 978/589/1049 +f 978/589/1049 855/389/894 854/390/893 +f 855/389/894 978/589/1049 857/391/896 +f 854/390/893 853/387/892 981/593/1052 +f 981/593/1052 979/590/1050 854/390/893 +f 981/593/1052 859/594/898 980/591/1051 +f 980/591/1051 979/590/1050 981/593/1052 +f 859/393/898 847/381/886 846/382/885 +f 846/382/885 980/592/1051 859/393/898 +f 848/380/887 847/381/886 818/334/859 +f 818/334/859 820/335/861 848/380/887 +f 822/338/863 850/384/889 848/380/887 +f 848/380/887 820/335/861 822/338/863 +f 834/359/875 851/385/890 850/384/889 +f 850/384/889 822/338/863 834/359/875 +f 837/360/878 856/388/895 851/385/890 +f 851/385/890 834/359/875 837/360/878 +f 835/360/876 836/361/877 853/387/892 +f 837/360/878 835/360/876 853/387/892 +f 853/387/892 856/388/895 837/360/878 +f 858/392/897 981/593/1052 853/387/892 +f 853/387/892 836/361/877 858/392/897 +f 981/593/1052 858/392/897 817/333/858 +f 817/333/858 859/594/898 981/593/1052 +f 789/288/830 806/307/847 808/309/849 +f 808/309/849 797/296/838 789/288/830 +f 648/162/682 653/164/516 709/595/746 +f 647/160/681 770/265/811 663/177/696 +f 647/160/681 663/177/696 653/164/516 +f 648/162/682 647/160/681 653/164/516 +f 652/165/686 708/237/745 709/595/746 +f 709/595/746 653/164/516 652/165/686 +f 647/512/681 443/479/453 770/476/811 +f 526/596/91 110/115/110 612/113/647 +f 612/113/647 109/114/109 526/596/91 +f 982/597/1053 983/598/1054 984/599/1055 +f 984/599/1055 466/600/1056 982/597/1053 +f 984/599/1055 985/601/1057 463/602/1058 +f 463/602/1058 466/600/1056 984/599/1055 +f 463/602/1058 985/601/1057 986/603/1059 +f 986/603/1059 987/604/1060 143/605/1061 +f 143/605/1061 463/602/1058 986/603/1059 +f 984/599/1055 983/598/1054 988/606/1062 +f 985/601/1057 984/599/1055 988/606/1062 +f 988/606/1062 989/607/1063 985/601/1057 +f 990/608/1064 991/609/1065 985/601/1057 +f 985/601/1057 989/607/1063 990/608/1064 +f 985/601/1057 991/609/1065 986/603/1059 +f 992/610/1066 987/604/1060 986/603/1059 +f 986/603/1059 991/609/1065 992/610/1066 +f 987/604/1060 993/611/1067 994/612/1068 +f 994/612/1068 143/605/1061 987/604/1060 +f 995/613/1069 993/611/1067 987/604/1060 +f 987/604/1060 992/610/1066 995/613/1069 +f 982/597/1053 996/614/1070 983/598/1054 +f 466/600/1056 997/615/1071 982/597/1053 +f 931/602/1072 998/601/1073 999/599/1074 +f 999/599/1074 932/600/1075 931/602/1072 +f 999/599/1074 1000/598/1076 1001/597/1077 +f 1001/597/1077 932/600/1075 999/599/1074 +f 639/605/1078 1002/604/1079 1003/603/1080 +f 1003/603/1080 931/602/1072 639/605/1078 +f 1003/603/1080 998/601/1073 931/602/1072 +f 1004/606/1081 999/599/1074 998/601/1073 +f 998/601/1073 1005/607/1082 1004/606/1081 +f 999/599/1074 1004/606/1081 1000/598/1076 +f 998/601/1073 1003/603/1080 1006/609/1083 +f 1007/608/1084 1005/607/1082 998/601/1073 +f 998/601/1073 1006/609/1083 1007/608/1084 +f 1008/610/1085 1006/609/1083 1003/603/1080 +f 1003/603/1080 1002/604/1079 1008/610/1085 +f 1009/612/1086 1010/611/1087 1002/604/1079 +f 1002/604/1079 639/605/1078 1009/612/1086 +f 1011/613/1088 1008/610/1085 1002/604/1079 +f 1002/604/1079 1010/611/1087 1011/613/1088 +f 1000/598/1076 1012/614/1089 1001/597/1077 +f 932/600/1075 1001/597/1077 1013/615/1090 +# 2000 faces + diff --git a/games/raylib_demo/resources/catsham.png b/games/raylib_demo/resources/catsham.png new file mode 100644 index 00000000..8d7978e0 Binary files /dev/null and b/games/raylib_demo/resources/catsham.png differ diff --git a/games/raylib_demo/resources/catwhite.png b/games/raylib_demo/resources/catwhite.png new file mode 100644 index 00000000..b849c4c0 Binary files /dev/null and b/games/raylib_demo/resources/catwhite.png differ diff --git a/games/raylib_demo/resources/fonts/alagard.rbmf b/games/raylib_demo/resources/fonts/alagard.rbmf new file mode 100644 index 00000000..8c9b68d3 Binary files /dev/null and b/games/raylib_demo/resources/fonts/alagard.rbmf differ diff --git a/games/raylib_demo/resources/fonts/alpha_beta.rbmf b/games/raylib_demo/resources/fonts/alpha_beta.rbmf new file mode 100644 index 00000000..bdb2e752 Binary files /dev/null and b/games/raylib_demo/resources/fonts/alpha_beta.rbmf differ diff --git a/games/raylib_demo/resources/fonts/custom_alagard.png b/games/raylib_demo/resources/fonts/custom_alagard.png new file mode 100644 index 00000000..c3eb63b7 Binary files /dev/null and b/games/raylib_demo/resources/fonts/custom_alagard.png differ diff --git a/games/raylib_demo/resources/fonts/custom_jupiter_crash.png b/games/raylib_demo/resources/fonts/custom_jupiter_crash.png new file mode 100644 index 00000000..451b591f Binary files /dev/null and b/games/raylib_demo/resources/fonts/custom_jupiter_crash.png differ diff --git a/games/raylib_demo/resources/fonts/custom_mecha.png b/games/raylib_demo/resources/fonts/custom_mecha.png new file mode 100644 index 00000000..59caab2c Binary files /dev/null and b/games/raylib_demo/resources/fonts/custom_mecha.png differ diff --git a/games/raylib_demo/resources/fonts/jupiter_crash.rbmf b/games/raylib_demo/resources/fonts/jupiter_crash.rbmf new file mode 100644 index 00000000..d797e0d6 Binary files /dev/null and b/games/raylib_demo/resources/fonts/jupiter_crash.rbmf differ diff --git a/games/raylib_demo/resources/fonts/mecha.rbmf b/games/raylib_demo/resources/fonts/mecha.rbmf new file mode 100644 index 00000000..0266a065 Binary files /dev/null and b/games/raylib_demo/resources/fonts/mecha.rbmf differ diff --git a/games/raylib_demo/resources/fonts/pixantiqua.rbmf b/games/raylib_demo/resources/fonts/pixantiqua.rbmf new file mode 100644 index 00000000..04ef0e25 Binary files /dev/null and b/games/raylib_demo/resources/fonts/pixantiqua.rbmf differ diff --git a/games/raylib_demo/resources/fonts/pixelplay.rbmf b/games/raylib_demo/resources/fonts/pixelplay.rbmf new file mode 100644 index 00000000..31d14038 Binary files /dev/null and b/games/raylib_demo/resources/fonts/pixelplay.rbmf differ diff --git a/games/raylib_demo/resources/fonts/romulus.rbmf b/games/raylib_demo/resources/fonts/romulus.rbmf new file mode 100644 index 00000000..be9da01a Binary files /dev/null and b/games/raylib_demo/resources/fonts/romulus.rbmf differ diff --git a/games/raylib_demo/resources/fonts/setback.rbmf b/games/raylib_demo/resources/fonts/setback.rbmf new file mode 100644 index 00000000..09572215 Binary files /dev/null and b/games/raylib_demo/resources/fonts/setback.rbmf differ diff --git a/games/raylib_demo/resources/lena.png b/games/raylib_demo/resources/lena.png new file mode 100644 index 00000000..59ef68aa Binary files /dev/null and b/games/raylib_demo/resources/lena.png differ diff --git a/games/raylib_demo/resources/mandrill.png b/games/raylib_demo/resources/mandrill.png new file mode 100644 index 00000000..a1267573 Binary files /dev/null and b/games/raylib_demo/resources/mandrill.png differ diff --git a/games/raylib_demo/resources/platforms.png b/games/raylib_demo/resources/platforms.png new file mode 100644 index 00000000..ff69a614 Binary files /dev/null and b/games/raylib_demo/resources/platforms.png differ diff --git a/games/raylib_demo/resources/raylib_logo.png b/games/raylib_demo/resources/raylib_logo.png new file mode 100644 index 00000000..66545627 Binary files /dev/null and b/games/raylib_demo/resources/raylib_logo.png differ diff --git a/games/raylib_demo/resources/raylib_logo128x128.png b/games/raylib_demo/resources/raylib_logo128x128.png new file mode 100644 index 00000000..99ba5437 Binary files /dev/null and b/games/raylib_demo/resources/raylib_logo128x128.png differ diff --git a/games/raylib_demo/resources/raylib_window.png b/games/raylib_demo/resources/raylib_window.png new file mode 100644 index 00000000..e5e08bd4 Binary files /dev/null and b/games/raylib_demo/resources/raylib_window.png differ diff --git a/games/raylib_demo/resources/raylib_window_01.png b/games/raylib_demo/resources/raylib_window_01.png new file mode 100644 index 00000000..26607b01 Binary files /dev/null and b/games/raylib_demo/resources/raylib_window_01.png differ diff --git a/games/raylib_demo/resources/raylib_window_02.png b/games/raylib_demo/resources/raylib_window_02.png new file mode 100644 index 00000000..4a636e69 Binary files /dev/null and b/games/raylib_demo/resources/raylib_window_02.png differ diff --git a/games/raylib_demo/resources/raylib_window_03.png b/games/raylib_demo/resources/raylib_window_03.png new file mode 100644 index 00000000..176b2672 Binary files /dev/null and b/games/raylib_demo/resources/raylib_window_03.png differ diff --git a/release/html5/libraylib.bc b/release/html5/libraylib.bc new file mode 100644 index 00000000..c73d2480 Binary files /dev/null and b/release/html5/libraylib.bc differ diff --git a/release/html5/raylib.h b/release/html5/raylib.h new file mode 100644 index 00000000..69966069 --- /dev/null +++ b/release/html5/raylib.h @@ -0,0 +1,506 @@ +/********************************************************************************************** +* +* raylib 1.2 (www.raylib.com) +* +* A simple and easy-to-use library to learn videogames programming +* +* Features: +* Library written in plain C code (C99) +* Uses C# PascalCase/camelCase notation +* Hardware accelerated with OpenGL (1.1, 3.3+ or ES2) +* Unique OpenGL abstraction layer [rlgl] +* Powerful fonts module with SpriteFonts support +* Multiple textures support, including DDS and mipmaps generation +* Basic 3d support for Shapes, Models, Heightmaps and Billboards +* Powerful math module for Vector and Matrix operations [raymath] +* Audio loading and playing with streaming support (WAV and OGG) +* Multiplatform support, including Android devices, Raspberry Pi and HTML5 +* +* Used external libs: +* GLFW3 (www.glfw.org) for window/context management and input +* GLEW for OpenGL extensions loading (3.3+ and ES2) +* stb_image (Sean Barret) for images loading (JPEG, PNG, BMP, TGA, PSD, GIF, HDR, PIC) +* stb_image_write (Sean Barret) for image writting (PNG) +* stb_vorbis (Sean Barret) for ogg audio loading +* OpenAL Soft for audio device/context management +* tinfl for data decompression (DEFLATE algorithm) +* +* Some design decisions: +* 32bit Colors - All defined color are always RGBA +* 32bit Textures - All loaded images are converted automatically to RGBA textures +* SpriteFonts - All loaded sprite-font images are converted to RGBA and POT textures +* One custom default font is loaded automatically when InitWindow() +* If using OpenGL 3.3+ or ES2, one default shader is loaded automatically (internally defined) +* +* -- LICENSE (raylib v1.2, September 2014) -- +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013 Ramon Santamaria (Ray San - raysan@raysanweb.com) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYLIB_H +#define RAYLIB_H + +// Choose your platform here or just define it at compile time: -DPLATFORM_DESKTOP +//#define PLATFORM_DESKTOP // Windows, Linux or OSX +//#define PLATFORM_ANDROID // Android device +//#define PLATFORM_RPI // Raspberry Pi +//#define PLATFORM_WEB // HTML5 (emscripten, asm.js) + +// Security check in case no PLATFORM_* defined +#if !defined(PLATFORM_DESKTOP) && !defined(PLATFORM_ANDROID) && !defined(PLATFORM_RPI) && !defined(PLATFORM_WEB) + #define PLATFORM_DESKTOP +#endif + +#if defined(PLATFORM_ANDROID) + #include // Defines android_app struct +#endif + +//---------------------------------------------------------------------------------- +// Some basic Defines +//---------------------------------------------------------------------------------- +#ifndef PI +#define PI 3.14159265358979323846 +#endif + +#define DEG2RAD (PI / 180.0f) +#define RAD2DEG (180.0f / PI) + +// raylib Config Flags +#define FLAG_FULLSCREEN_MODE 1 +#define FLAG_SHOW_LOGO 2 +#define FLAG_SHOW_MOUSE_CURSOR 4 +#define FLAG_CENTERED_MODE 8 +#define FLAG_MSAA_4X_HINT 16 + +// Keyboard Function Keys +#define KEY_SPACE 32 +#define KEY_ESCAPE 256 +#define KEY_ENTER 257 +#define KEY_BACKSPACE 259 +#define KEY_RIGHT 262 +#define KEY_LEFT 263 +#define KEY_DOWN 264 +#define KEY_UP 265 +#define KEY_F1 290 +#define KEY_F2 291 +#define KEY_F3 292 +#define KEY_F4 293 +#define KEY_F5 294 +#define KEY_F6 295 +#define KEY_F7 296 +#define KEY_F8 297 +#define KEY_F9 298 +#define KEY_F10 299 +#define KEY_LEFT_SHIFT 340 +#define KEY_LEFT_CONTROL 341 +#define KEY_LEFT_ALT 342 +#define KEY_RIGHT_SHIFT 344 +#define KEY_RIGHT_CONTROL 345 +#define KEY_RIGHT_ALT 346 + +// Mouse Buttons +#define MOUSE_LEFT_BUTTON 0 +#define MOUSE_RIGHT_BUTTON 1 +#define MOUSE_MIDDLE_BUTTON 2 + +// Gamepad Number +#define GAMEPAD_PLAYER1 0 +#define GAMEPAD_PLAYER2 1 +#define GAMEPAD_PLAYER3 2 +#define GAMEPAD_PLAYER4 3 + +// Gamepad Buttons +// NOTE: Adjusted for a PS3 USB Controller +#define GAMEPAD_BUTTON_A 2 +#define GAMEPAD_BUTTON_B 1 +#define GAMEPAD_BUTTON_X 3 +#define GAMEPAD_BUTTON_Y 4 +#define GAMEPAD_BUTTON_R1 7 +#define GAMEPAD_BUTTON_R2 5 +#define GAMEPAD_BUTTON_L1 6 +#define GAMEPAD_BUTTON_L2 8 +#define GAMEPAD_BUTTON_SELECT 9 +#define GAMEPAD_BUTTON_START 10 + +// TODO: Review Xbox360 USB Controller Buttons + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY (Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY (Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY (Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW (Color){ 253, 249, 0, 255 } // Yellow +#define GOLD (Color){ 255, 203, 0, 255 } // Gold +#define ORANGE (Color){ 255, 161, 0, 255 } // Orange +#define PINK (Color){ 255, 109, 194, 255 } // Pink +#define RED (Color){ 230, 41, 55, 255 } // Red +#define MAROON (Color){ 190, 33, 55, 255 } // Maroon +#define GREEN (Color){ 0, 228, 48, 255 } // Green +#define LIME (Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN (Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE (Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE (Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE (Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE (Color){ 200, 122, 255, 255 } // Purple +#define VIOLET (Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE (Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE (Color){ 211, 176, 131, 255 } // Beige +#define BROWN (Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN (Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE (Color){ 255, 255, 255, 255 } // White +#define BLACK (Color){ 0, 0, 0, 255 } // Black +#define BLANK (Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA (Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE (Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- + +// Boolean type +typedef enum { false, true } bool; + +// byte type +typedef unsigned char byte; + +// Vector2 type +typedef struct Vector2 { + float x; + float y; +} Vector2; + +// Vector3 type +typedef struct Vector3 { + float x; + float y; + float z; +} Vector3; + +// Color type, RGBA (32bit) +typedef struct Color { + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char a; +} Color; + +// Rectangle type +typedef struct Rectangle { + int x; + int y; + int width; + int height; +} Rectangle; + +// Image type, bpp always RGBA (32bit) +// NOTE: Data stored in CPU memory (RAM) +typedef struct Image { + Color *pixels; + int width; + int height; +} Image; + +// Texture2D type, bpp always RGBA (32bit) +// NOTE: Data stored in GPU memory +typedef struct Texture2D { + unsigned int id; // OpenGL id + int width; + int height; +} Texture2D; + +// Character type (one font glyph) +typedef struct Character { + int value; //char value = ' '; (int)value = 32; + int x; + int y; + int w; + int h; +} Character; + +// SpriteFont type, includes texture and charSet array data +typedef struct SpriteFont { + Texture2D texture; + int numChars; + Character *charSet; +} SpriteFont; + +// Camera type, defines a camera position/orientation in 3d space +typedef struct Camera { + Vector3 position; + Vector3 target; + Vector3 up; +} Camera; + +// Vertex data definning a mesh +typedef struct VertexData { + int vertexCount; + float *vertices; // 3 components per vertex + float *texcoords; // 2 components per vertex + float *normals; // 3 components per vertex + unsigned char *colors; // 4 components per vertex +} VertexData; + +// 3d Model type +// NOTE: If using OpenGL 1.1, loaded in CPU (mesh); if OpenGL 3.3+ loaded in GPU (vaoId) +typedef struct Model { + VertexData mesh; + unsigned int vaoId; + unsigned int vboId[4]; + unsigned int textureId; + //Matrix transform; +} Model; + +// Sound source type +typedef struct Sound { + unsigned int source; + unsigned int buffer; +} Sound; + +// Wave type, defines audio wave data +typedef struct Wave { + void *data; // Buffer data pointer + unsigned int dataSize; // Data size in bytes + unsigned int sampleRate; + short bitsPerSample; + short channels; +} Wave; + +#ifdef __cplusplus +extern "C" { // Prevents name mangling of functions +#endif + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ +#if defined(PLATFORM_ANDROID) +void InitWindow(int width, int height, struct android_app *state); // Init Android activity +#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) +void InitWindow(int width, int height, const char *title); // Initialize Window and OpenGL Graphics +#endif + +void CloseWindow(void); // Close Window and Terminate Context +bool WindowShouldClose(void); // Detect if KEY_ESCAPE pressed or Close icon pressed +void ToggleFullscreen(void); // Fullscreen toggle (only PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +void SetCustomCursor(const char *cursorImage); // Set a custom cursor icon/image +void SetExitKey(int key); // Set a custom key to exit program (default is ESC) +#endif +int GetScreenWidth(void); // Get current screen width +int GetScreenHeight(void); // Get current screen height +int GetKeyPressed(void); // Get latest key pressed + +void ClearBackground(Color color); // Sets Background Color +void BeginDrawing(void); // Setup drawing canvas to start drawing +void EndDrawing(void); // End canvas drawing and Swap Buffers (Double Buffering) + +void Begin3dMode(Camera cam); // Initializes 3D mode for drawing (Camera setup) +void End3dMode(void); // Ends 3D mode and returns to default 2D orthographic mode + +void SetTargetFPS(int fps); // Set target FPS (maximum) +float GetFPS(void); // Returns current FPS +float GetFrameTime(void); // Returns time in seconds for one frame + +Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value +int GetHexValue(Color color); // Returns hexadecimal value for a Color + +int GetRandomValue(int min, int max); // Returns a random value between min and max (both included) +Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f + +void SetupFlags(char flags); // Enable some window configurations +void ShowLogo(void); // Activates raylib logo at startup (can be done with flags) + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) +bool IsKeyPressed(int key); // Detect if a key has been pressed once +bool IsKeyDown(int key); // Detect if a key is being pressed +bool IsKeyReleased(int key); // Detect if a key has been released once +bool IsKeyUp(int key); // Detect if a key is NOT being pressed + +bool IsMouseButtonPressed(int button); // Detect if a mouse button has been pressed once +bool IsMouseButtonDown(int button); // Detect if a mouse button is being pressed +bool IsMouseButtonReleased(int button); // Detect if a mouse button has been released once +bool IsMouseButtonUp(int button); // Detect if a mouse button is NOT being pressed +int GetMouseX(void); // Returns mouse position X +int GetMouseY(void); // Returns mouse position Y +Vector2 GetMousePosition(void); // Returns mouse position XY +void SetMousePosition(Vector2 position); // Set mouse position XY +int GetMouseWheelMove(void); // Returns mouse wheel movement Y +#endif + +#if defined(PLATFORM_DESKTOP) +bool IsGamepadAvailable(int gamepad); // Detect if a gamepad is available +Vector2 GetGamepadMovement(int gamepad); // Return axis movement vector for a gamepad +bool IsGamepadButtonPressed(int gamepad, int button); // Detect if a gamepad button has been pressed once +bool IsGamepadButtonDown(int gamepad, int button); // Detect if a gamepad button is being pressed +bool IsGamepadButtonReleased(int gamepad, int button); // Detect if a gamepad button has been released once +bool IsGamepadButtonUp(int gamepad, int button); // Detect if a gamepad button is NOT being pressed +#endif + +#if defined(PLATFORM_ANDROID) +bool IsScreenTouched(void); // Detect screen touch event +int GetTouchX(void); // Returns touch position X +int GetTouchY(void); // Returns touch position Y +Vector2 GetTouchPosition(void); // Returns touch position XY +#endif + +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ +void DrawPixel(int posX, int posY, Color color); // Draw a pixel +void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) +void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version) +void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a gradient-filled rectangle +void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle +void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline +void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +void DrawPolyEx(Vector2 *points, int numPoints, Color color); // Draw a closed polygon defined by points +void DrawPolyExLines(Vector2 *points, int numPoints, Color color); // Draw polygon lines + +bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision +bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle + +//------------------------------------------------------------------------------------ +// Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ +Image LoadImage(const char *fileName); // Load an image into CPU memory (RAM) +Image LoadImageFromRES(const char *rresName, int resId); // Load an image from rRES file (raylib Resource) +Texture2D LoadTexture(const char *fileName); // Load an image as texture into GPU memory +Texture2D LoadTextureFromRES(const char *rresName, int resId); // Load an image as texture from rRES file (raylib Resource) +Texture2D LoadTextureFromImage(Image image, bool genMipmaps); // Load a texture from image data (and generate mipmaps) +Texture2D CreateTexture(Image image, bool genMipmaps); // [DEPRECATED] Same as LoadTextureFromImage() +void UnloadImage(Image image); // Unload image from CPU memory (RAM) +void UnloadTexture(Texture2D texture); // Unload texture from GPU memory +void ConvertToPOT(Image *image, Color fillColor); // Convert image to POT (power-of-two) + +void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, // Draw a part of a texture defined by a rectangle with 'pro' parameters + float rotation, Color tint); + +//------------------------------------------------------------------------------------ +// Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ +SpriteFont GetDefaultFont(void); // Get the default SpriteFont +SpriteFont LoadSpriteFont(const char *fileName); // Load a SpriteFont image into GPU memory +void UnloadSpriteFont(SpriteFont spriteFont); // Unload SpriteFont from GPU memory + +void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +void DrawTextEx(SpriteFont spriteFont, const char* text, Vector2 position, // Draw text using SpriteFont and additional parameters + int fontSize, int spacing, Color tint); +int MeasureText(const char *text, int fontSize); // Measure string width for default font +Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, int fontSize, int spacing); // Measure string size for SpriteFont +int GetFontBaseSize(SpriteFont spriteFont); // Returns the base size for a SpriteFont (chars height) +void DrawFPS(int posX, int posY); // Shows current FPS on top-left corner +const char *FormatText(const char *text, ...); // Formatting of text with variables to 'embed' + +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ +void DrawCube(Vector3 position, float width, float height, float lenght, Color color); // Draw cube +void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +void DrawCubeWires(Vector3 position, float width, float height, float lenght, Color color); // Draw cube wires +void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float lenght, Color color); // Draw cube textured +void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +void DrawQuad(Vector3 vertices[4], Vector2 textcoords[4], Vector3 normals[4], Color colors[4]); // Draw a quad +void DrawPlane(Vector3 centerPos, Vector2 size, Vector3 rotation, Color color); // Draw a plane +void DrawPlaneEx(Vector3 centerPos, Vector2 size, Vector3 rotation, int slicesX, int slicesZ, Color color); // Draw a plane with divisions +void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) +void DrawGizmo(Vector3 position); // Draw simple gizmo +void DrawGizmoEx(Vector3 position, Vector3 rotation, float scale); // Draw gizmo with extended parameters +//DrawTorus(), DrawTeapot() are useless... + +//------------------------------------------------------------------------------------ +// Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ +Model LoadModel(const char *fileName); // Load a 3d model (.OBJ) +//Model LoadModelFromRES(const char *rresName, int resId); // TODO: Load a 3d model from rRES file (raylib Resource) +Model LoadHeightmap(Image heightmap, float maxHeight); // Load a heightmap image as a 3d model +Model LoadCubicmap(Image cubicmap); // Load a map image as a 3d model (cubes based) +void UnloadModel(Model model); // Unload 3d model from memory +void SetModelTexture(Model *model, Texture2D texture); // Link a texture to a model + +void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +void DrawModelEx(Model model, Vector3 position, Vector3 rotation, Vector3 scale, Color tint); // Draw a model with extended parameters +void DrawModelWires(Model model, Vector3 position, float scale, Color color); // Draw a model wires (with texture if set) + +void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint); // Draw a billboard texture +void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +void InitAudioDevice(void); // Initialize audio device and context +void CloseAudioDevice(void); // Close the audio device and context (and music stream) + +Sound LoadSound(char *fileName); // Load sound to memory +Sound LoadSoundFromWave(Wave wave); // Load sound to memory from wave data +Sound LoadSoundFromRES(const char *rresName, int resId); // Load sound to memory from rRES file (raylib Resource) +void UnloadSound(Sound sound); // Unload sound +void PlaySound(Sound sound); // Play a sound +void PauseSound(Sound sound); // Pause a sound +void StopSound(Sound sound); // Stop playing a sound +bool SoundIsPlaying(Sound sound); // Check if a sound is currently playing +void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) + +void PlayMusicStream(char *fileName); // Start music playing (open stream) +void StopMusicStream(void); // Stop music playing (close stream) +void PauseMusicStream(void); // Pause music playing +void ResumeMusicStream(void); // Resume playing paused music +bool MusicIsPlaying(void); // Check if music is playing +void SetMusicVolume(float volume); // Set volume for music (1.0 is max level) +float GetMusicTimeLength(void); // Get current music time length (in seconds) +float GetMusicTimePlayed(void); // Get current music time played (in seconds) + +#ifdef __cplusplus +} +#endif + +#endif // RAYLIB_H diff --git a/release/win32-mingw/include/raylib.h b/release/win32-mingw/include/raylib.h index 5257de58..69966069 100644 --- a/release/win32-mingw/include/raylib.h +++ b/release/win32-mingw/include/raylib.h @@ -14,7 +14,7 @@ * Basic 3d support for Shapes, Models, Heightmaps and Billboards * Powerful math module for Vector and Matrix operations [raymath] * Audio loading and playing with streaming support (WAV and OGG) -* Multiplatform support, including Android devices and Raspberry Pi +* Multiplatform support, including Android devices, Raspberry Pi and HTML5 * * Used external libs: * GLFW3 (www.glfw.org) for window/context management and input @@ -63,9 +63,10 @@ //#define PLATFORM_DESKTOP // Windows, Linux or OSX //#define PLATFORM_ANDROID // Android device //#define PLATFORM_RPI // Raspberry Pi +//#define PLATFORM_WEB // HTML5 (emscripten, asm.js) // Security check in case no PLATFORM_* defined -#if !defined(PLATFORM_DESKTOP) && !defined(PLATFORM_ANDROID) && !defined(PLATFORM_RPI) +#if !defined(PLATFORM_DESKTOP) && !defined(PLATFORM_ANDROID) && !defined(PLATFORM_RPI) && !defined(PLATFORM_WEB) #define PLATFORM_DESKTOP #endif @@ -179,6 +180,9 @@ // Boolean type typedef enum { false, true } bool; +// byte type +typedef unsigned char byte; + // Vector2 type typedef struct Vector2 { float x; @@ -225,8 +229,13 @@ typedef struct Texture2D { } Texture2D; // Character type (one font glyph) -// NOTE: Defined in module: text -typedef struct Character Character; +typedef struct Character { + int value; //char value = ' '; (int)value = 32; + int x; + int y; + int w; + int h; +} Character; // SpriteFont type, includes texture and charSet array data typedef struct SpriteFont { @@ -267,6 +276,15 @@ typedef struct Sound { unsigned int buffer; } Sound; +// Wave type, defines audio wave data +typedef struct Wave { + void *data; // Buffer data pointer + unsigned int dataSize; // Data size in bytes + unsigned int sampleRate; + short bitsPerSample; + short channels; +} Wave; + #ifdef __cplusplus extern "C" { // Prevents name mangling of functions #endif @@ -281,7 +299,7 @@ extern "C" { // Prevents name mangling of functions //------------------------------------------------------------------------------------ #if defined(PLATFORM_ANDROID) void InitWindow(int width, int height, struct android_app *state); // Init Android activity -#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) void InitWindow(int width, int height, const char *title); // Initialize Window and OpenGL Graphics #endif @@ -294,6 +312,7 @@ void SetExitKey(int key); // Set a custom key #endif int GetScreenWidth(void); // Get current screen width int GetScreenHeight(void); // Get current screen height +int GetKeyPressed(void); // Get latest key pressed void ClearBackground(Color color); // Sets Background Color void BeginDrawing(void); // Setup drawing canvas to start drawing @@ -313,13 +332,12 @@ int GetRandomValue(int min, int max); // Returns a random Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f void SetupFlags(char flags); // Enable some window configurations - -void ShowLogo(void); // Activates raylib logo at startup +void ShowLogo(void); // Activates raylib logo at startup (can be done with flags) //------------------------------------------------------------------------------------ // Input Handling Functions (Module: core) //------------------------------------------------------------------------------------ -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) bool IsKeyPressed(int key); // Detect if a key has been pressed once bool IsKeyDown(int key); // Detect if a key is being pressed bool IsKeyReleased(int key); // Detect if a key has been released once @@ -332,8 +350,11 @@ bool IsMouseButtonUp(int button); // Detect if a mouse but int GetMouseX(void); // Returns mouse position X int GetMouseY(void); // Returns mouse position Y Vector2 GetMousePosition(void); // Returns mouse position XY +void SetMousePosition(Vector2 position); // Set mouse position XY int GetMouseWheelMove(void); // Returns mouse wheel movement Y +#endif +#if defined(PLATFORM_DESKTOP) bool IsGamepadAvailable(int gamepad); // Detect if a gamepad is available Vector2 GetGamepadMovement(int gamepad); // Return axis movement vector for a gamepad bool IsGamepadButtonPressed(int gamepad, int button); // Detect if a gamepad button has been pressed once @@ -386,9 +407,11 @@ Image LoadImage(const char *fileName); Image LoadImageFromRES(const char *rresName, int resId); // Load an image from rRES file (raylib Resource) Texture2D LoadTexture(const char *fileName); // Load an image as texture into GPU memory Texture2D LoadTextureFromRES(const char *rresName, int resId); // Load an image as texture from rRES file (raylib Resource) -Texture2D CreateTexture(Image image, bool genMipmaps); // Create a Texture2D from Image data (and generate mipmaps) +Texture2D LoadTextureFromImage(Image image, bool genMipmaps); // Load a texture from image data (and generate mipmaps) +Texture2D CreateTexture(Image image, bool genMipmaps); // [DEPRECATED] Same as LoadTextureFromImage() void UnloadImage(Image image); // Unload image from CPU memory (RAM) void UnloadTexture(Texture2D texture); // Unload texture from GPU memory +void ConvertToPOT(Image *image, Color fillColor); // Convert image to POT (power-of-two) void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 @@ -425,6 +448,7 @@ void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +void DrawQuad(Vector3 vertices[4], Vector2 textcoords[4], Vector3 normals[4], Color colors[4]); // Draw a quad void DrawPlane(Vector3 centerPos, Vector2 size, Vector3 rotation, Color color); // Draw a plane void DrawPlaneEx(Vector3 centerPos, Vector2 size, Vector3 rotation, int slicesX, int slicesZ, Color color); // Draw a plane with divisions void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) @@ -438,7 +462,7 @@ void DrawGizmoEx(Vector3 position, Vector3 rotation, float scale); Model LoadModel(const char *fileName); // Load a 3d model (.OBJ) //Model LoadModelFromRES(const char *rresName, int resId); // TODO: Load a 3d model from rRES file (raylib Resource) Model LoadHeightmap(Image heightmap, float maxHeight); // Load a heightmap image as a 3d model -Model LoadCubesmap(Image cubesmap); // Load a map image as a 3d model (cubes based) +Model LoadCubicmap(Image cubicmap); // Load a map image as a 3d model (cubes based) void UnloadModel(Model model); // Unload 3d model from memory void SetModelTexture(Model *model, Texture2D texture); // Link a texture to a model @@ -456,6 +480,7 @@ void InitAudioDevice(void); // Initialize au void CloseAudioDevice(void); // Close the audio device and context (and music stream) Sound LoadSound(char *fileName); // Load sound to memory +Sound LoadSoundFromWave(Wave wave); // Load sound to memory from wave data Sound LoadSoundFromRES(const char *rresName, int resId); // Load sound to memory from rRES file (raylib Resource) void UnloadSound(Sound sound); // Unload sound void PlaySound(Sound sound); // Play a sound diff --git a/release/win32-mingw/lib/libraylib.a b/release/win32-mingw/lib/libraylib.a index 7c561f93..d9321248 100644 Binary files a/release/win32-mingw/lib/libraylib.a and b/release/win32-mingw/lib/libraylib.a differ diff --git a/src/audio.c b/src/audio.c index fd482534..40c24895 100644 --- a/src/audio.c +++ b/src/audio.c @@ -45,9 +45,14 @@ // Defines and Macros //---------------------------------------------------------------------------------- #define MUSIC_STREAM_BUFFERS 2 -#define MUSIC_BUFFER_SIZE 4096*2 // PCM data buffer (short) - 16Kb - // NOTE: Reduced to avoid frame-stalls on RPI -//#define MUSIC_BUFFER_SIZE 4096*8 // PCM data buffer (short) - 64Kb + +#if defined(PLATFORM_RPI) + // NOTE: On RPI should be lower to avoid frame-stalls + #define MUSIC_BUFFER_SIZE 4096*2 // PCM data buffer (short) - 16Kb (RPI) +#else + // NOTE: On HTML5 (emscripten) this is allocated on heap, by default it's only 16MB!...just take care... + #define MUSIC_BUFFER_SIZE 4096*8 // PCM data buffer (short) - 64Kb +#endif //---------------------------------------------------------------------------------- // Types and Structures Definition @@ -69,15 +74,6 @@ typedef struct Music { } Music; -// Wave file data -typedef struct Wave { - void *data; // Buffer data pointer - unsigned int dataSize; // Data size in bytes - unsigned int sampleRate; - short bitsPerSample; - short channels; -} Wave; - //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- @@ -106,7 +102,7 @@ void InitAudioDevice(void) // Open and initialize a device with default settings ALCdevice *device = alcOpenDevice(NULL); - if(!device) TraceLog(ERROR, "Could not open audio device"); + if(!device) TraceLog(ERROR, "Audio device could not be opened"); ALCcontext *context = alcCreateContext(device, NULL); @@ -205,12 +201,64 @@ Sound LoadSound(char *fileName) // Attach sound buffer to source alSourcei(source, AL_BUFFER, buffer); + + TraceLog(INFO, "[%s] Sound file loaded successfully (SampleRate: %i, BitRate: %i, Channels: %i)", fileName, wave.sampleRate, wave.bitsPerSample, wave.channels); // Unallocate WAV data UnloadWave(wave); - TraceLog(INFO, "[%s] Sound file loaded successfully", fileName); - TraceLog(INFO, "[%s] Sample rate: %i - Channels: %i", fileName, wave.sampleRate, wave.channels); + sound.source = source; + sound.buffer = buffer; + } + + return sound; +} + +// Load sound from wave data +Sound LoadSoundFromWave(Wave wave) +{ + Sound sound; + + if (wave.data != NULL) + { + ALenum format = 0; + // The OpenAL format is worked out by looking at the number of channels and the bits per sample + if (wave.channels == 1) + { + if (wave.bitsPerSample == 8 ) format = AL_FORMAT_MONO8; + else if (wave.bitsPerSample == 16) format = AL_FORMAT_MONO16; + } + else if (wave.channels == 2) + { + if (wave.bitsPerSample == 8 ) format = AL_FORMAT_STEREO8; + else if (wave.bitsPerSample == 16) format = AL_FORMAT_STEREO16; + } + + // Create an audio source + ALuint source; + alGenSources(1, &source); // Generate pointer to audio source + + alSourcef(source, AL_PITCH, 1); + alSourcef(source, AL_GAIN, 1); + alSource3f(source, AL_POSITION, 0, 0, 0); + alSource3f(source, AL_VELOCITY, 0, 0, 0); + alSourcei(source, AL_LOOPING, AL_FALSE); + + // Convert loaded data to OpenAL buffer + //---------------------------------------- + ALuint buffer; + alGenBuffers(1, &buffer); // Generate pointer to buffer + + // Upload sound data to buffer + alBufferData(buffer, format, wave.data, wave.dataSize, wave.sampleRate); + + // Attach sound buffer to source + alSourcei(source, AL_BUFFER, buffer); + + // Unallocate WAV data + UnloadWave(wave); + + TraceLog(INFO, "[Wave] Sound file loaded successfully (SampleRate: %i, BitRate: %i, Channels: %i)", wave.sampleRate, wave.bitsPerSample, wave.channels); sound.source = source; sound.buffer = buffer; @@ -235,7 +283,10 @@ Sound LoadSoundFromRES(const char *rresName, int resId) FILE *rresFile = fopen(rresName, "rb"); - if (!rresFile) TraceLog(WARNING, "[%s] Could not open raylib resource file", rresName); + if (rresFile == NULL) + { + TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName); + } else { // Read rres file (basic file check - id) @@ -327,12 +378,12 @@ Sound LoadSoundFromRES(const char *rresName, int resId) // Attach sound buffer to source alSourcei(source, AL_BUFFER, buffer); + + TraceLog(INFO, "[%s] Sound loaded successfully from resource (SampleRate: %i, BitRate: %i, Channels: %i)", rresName, wave.sampleRate, wave.bitsPerSample, wave.channels); // Unallocate WAV data UnloadWave(wave); - TraceLog(INFO, "[%s] Sound loaded successfully from resource, sample rate: %i", rresName, (int)sampleRate); - sound.source = source; sound.buffer = buffer; } @@ -447,7 +498,10 @@ void PlayMusicStream(char *fileName) // Open audio stream currentMusic.stream = stb_vorbis_open_filename(fileName, NULL, NULL); - if (currentMusic.stream == NULL) TraceLog(WARNING, "[%s] Could not open ogg audio file", fileName); + if (currentMusic.stream == NULL) + { + TraceLog(WARNING, "[%s] OGG audio file could not be opened", fileName); + } else { // Get file info @@ -537,11 +591,13 @@ void ResumeMusicStream(void) // Check if music is playing bool MusicIsPlaying(void) { - ALenum state; + bool playing = false; + ALint state; alGetSourcei(currentMusic.source, AL_SOURCE_STATE, &state); + if (state == AL_PLAYING) playing = true; - return (state == AL_PLAYING); + return playing; } // Set volume for music @@ -712,9 +768,9 @@ static Wave LoadWAV(const char *fileName) wavFile = fopen(fileName, "rb"); - if (!wavFile) + if (wavFile == NULL) { - TraceLog(WARNING, "[%s] Could not open WAV file", fileName); + TraceLog(WARNING, "[%s] WAV file could not be opened", fileName); } else { @@ -766,7 +822,7 @@ static Wave LoadWAV(const char *fileName) wave.channels = waveFormat.numChannels; wave.bitsPerSample = waveFormat.bitsPerSample; - TraceLog(INFO, "[%s] Wave file loaded successfully", fileName); + TraceLog(INFO, "[%s] WAV file loaded successfully (SampleRate: %i, BitRate: %i, Channels: %i)", fileName, wave.sampleRate, wave.bitsPerSample, wave.channels); } } } @@ -815,6 +871,8 @@ static Wave LoadOGG(char *fileName) int samplesObtained = stb_vorbis_get_samples_short_interleaved(oggFile, info.channels, wave.data, totalSamplesLength); TraceLog(DEBUG, "[%s] Samples obtained: %i", fileName, samplesObtained); + + TraceLog(INFO, "[%s] OGG file loaded successfully (SampleRate: %i, BitRate: %i, Channels: %i)", fileName, wave.sampleRate, wave.bitsPerSample, wave.channels); stb_vorbis_close(oggFile); diff --git a/src/core.c b/src/core.c index dec08eeb..5ff44f89 100644 --- a/src/core.c +++ b/src/core.c @@ -8,6 +8,7 @@ * PLATFORM_DESKTOP - Windows, Linux, Mac (OSX) * PLATFORM_ANDROID - Only OpenGL ES 2.0 devices * PLATFORM_RPI - Rapsberry Pi (tested on Raspbian) +* PLATFORM_WEB - Emscripten, HTML5 * * On PLATFORM_DESKTOP, the external lib GLFW3 (www.glfw.com) is used to manage graphic * device, OpenGL context and input on multiple operating systems (Windows, Linux, OSX). @@ -49,7 +50,7 @@ #include // String function definitions, memset() #include // Macros for reporting and retrieving error conditions through error codes -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) #include // GLFW3 library: Windows, OpenGL context and Input management //#include // OpenGL functions (GLFW3 already includes gl.h) //#define GLFW_DLL // Using GLFW DLL on Windows -> No, we use static version! @@ -91,7 +92,7 @@ //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- -// ... +#define MAX_TOUCH_POINTS 256 //---------------------------------------------------------------------------------- // Types and Structures Definition @@ -101,7 +102,7 @@ //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) static GLFWwindow *window; // Native window (graphic device) #elif defined(PLATFORM_ANDROID) static struct android_app *app; // Android activity @@ -111,7 +112,14 @@ static bool windowReady = false; // Used to detect display initia // Gestures detection variables static float tapTouchX, tapTouchY; +static int64_t lastTapTime = 0; +static float lastTapX = 0, lastTapY = 0; static bool touchTap = false; +static bool doubleTap = false; +static bool drag = false; +static int stdVector[MAX_TOUCH_POINTS]; +static int indexPosition = 0; +const AInputEvent* eventDrag; static int32_t touchId; const int32_t DOUBLE_TAP_TIMEOUT = 300*1000000; const int32_t DOUBLE_TAP_SLOP = 100; @@ -160,12 +168,12 @@ static int renderOffsetY = 0; // Offset Y from render area (must b static bool fullscreen = false; // Fullscreen mode (useful only for PLATFORM_DESKTOP) static Matrix downscaleView; // Matrix to downscale view (in case screen size bigger than display size) -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) static const char *windowTitle; // Window text title... static char configFlags = 0; static bool customCursor = false; // Tracks if custom cursor has been set -static bool cursorOnScreen = true; // Tracks if cursor is inside client area +static bool cursorOnScreen = false; // Tracks if cursor is inside client area static Texture2D cursor; // Cursor texture static Vector2 mousePosition; @@ -183,6 +191,7 @@ static int previousMouseWheelY = 0; // Required to track mouse wheel var static int currentMouseWheelY = 0; // Required to track mouse wheel variation static int exitKey = KEY_ESCAPE; // Default exit key (ESC) +static int lastKeyPressed = -1; #endif #if defined(PLATFORM_ANDROID) @@ -226,12 +235,17 @@ static void RestoreKeyboard(void); // Restore keyboard syst static void InitGamepad(void); // Init raw gamepad input #endif -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) static void ErrorCallback(int error, const char *description); // GLFW3 Error Callback, runs on GLFW3 error static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods); // GLFW3 Keyboard Callback, runs on key pressed +static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods); // GLFW3 Mouse Button Callback, runs on mouse button pressed +static void CharCallback(GLFWwindow *window, unsigned int key); // GLFW3 Char Key Callback, runs on key pressed (get char value) static void ScrollCallback(GLFWwindow *window, double xoffset, double yoffset); // GLFW3 Srolling Callback, runs on mouse wheel static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area static void WindowSizeCallback(GLFWwindow *window, int width, int height); // GLFW3 WindowSize Callback, runs when window is resized +#endif + +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) static void TakeScreenshot(void); // Takes a screenshot and saves it in the same folder as executable #endif @@ -243,7 +257,7 @@ static void CommandCallback(struct android_app *app, int32_t cmd); // //---------------------------------------------------------------------------------- // Module Functions Definition - Window and OpenGL Context Functions //---------------------------------------------------------------------------------- -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) // Initialize Window and Graphics Context (OpenGL) void InitWindow(int width, int height, const char *title) { @@ -348,7 +362,7 @@ void CloseWindow(void) rlglClose(); // De-init rlgl -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) glfwDestroyWindow(window); glfwTerminate(); #elif defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI) @@ -380,7 +394,7 @@ void CloseWindow(void) // Detect if KEY_ESCAPE pressed or Close icon pressed bool WindowShouldClose(void) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) return (glfwWindowShouldClose(window)); #elif defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI) return windowShouldClose; @@ -402,7 +416,7 @@ void ToggleFullscreen(void) #endif } -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) // Set a custom cursor icon/image void SetCustomCursor(const char *cursorImage) { @@ -411,6 +425,7 @@ void SetCustomCursor(const char *cursorImage) cursor = LoadTexture(cursorImage); #if defined(PLATFORM_DESKTOP) + // NOTE: emscripten not implemented glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); #endif customCursor = true; @@ -436,6 +451,12 @@ int GetScreenHeight(void) return screenHeight; } +// Get the last key pressed +int GetKeyPressed(void) +{ + return lastKeyPressed; +} + // Sets Background Color void ClearBackground(Color color) { @@ -612,19 +633,13 @@ void ShowLogo(void) //---------------------------------------------------------------------------------- // Module Functions Definition - Input (Keyboard, Mouse, Gamepad) Functions //---------------------------------------------------------------------------------- -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) // Detect if a key has been pressed once bool IsKeyPressed(int key) { bool pressed = false; - currentKeyState[key] = IsKeyDown(key); - - if (currentKeyState[key] != previousKeyState[key]) - { - if (currentKeyState[key]) pressed = true; - previousKeyState[key] = currentKeyState[key]; - } + if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 1)) pressed = true; else pressed = false; return pressed; @@ -642,13 +657,7 @@ bool IsKeyReleased(int key) { bool released = false; - currentKeyState[key] = IsKeyUp(key); - - if (currentKeyState[key] != previousKeyState[key]) - { - if (currentKeyState[key]) released = true; - previousKeyState[key] = currentKeyState[key]; - } + if ((currentKeyState[key] != previousKeyState[key]) && (currentKeyState[key] == 0)) released = true; else released = false; return released; @@ -666,13 +675,7 @@ bool IsMouseButtonPressed(int button) { bool pressed = false; - currentMouseState[button] = IsMouseButtonDown(button); - - if (currentMouseState[button] != previousMouseState[button]) - { - if (currentMouseState[button]) pressed = true; - previousMouseState[button] = currentMouseState[button]; - } + if ((currentMouseState[button] != previousMouseState[button]) && (currentMouseState[button] == 1)) pressed = true; else pressed = false; return pressed; @@ -690,13 +693,7 @@ bool IsMouseButtonReleased(int button) { bool released = false; - currentMouseState[button] = IsMouseButtonUp(button); - - if (currentMouseState[button] != previousMouseState[button]) - { - if (currentMouseState[button]) released = true; - previousMouseState[button] = currentMouseState[button]; - } + if ((currentMouseState[button] != previousMouseState[button]) && (currentMouseState[button] == 0)) released = true; else released = false; return released; @@ -727,6 +724,16 @@ Vector2 GetMousePosition(void) return mousePosition; } +// Set mouse position XY +void SetMousePosition(Vector2 position) +{ + mousePosition = position; +#if defined(PLATFORM_DESKTOP) + // NOTE: emscripten not implemented + glfwSetCursorPos(window, position.x, position.y); +#endif +} + // Returns mouse wheel movement Y int GetMouseWheelMove(void) { @@ -738,7 +745,8 @@ int GetMouseWheelMove(void) } #endif -// TODO: Enable gamepad usage on Rapsberr Pi +// TODO: Enable gamepad usage on Rapsberry Pi +// NOTE: emscripten not implemented #if defined(PLATFORM_DESKTOP) // Detect if a gamepad is available bool IsGamepadAvailable(int gamepad) @@ -842,6 +850,18 @@ bool IsScreenTouched(void) return touchTap; } +bool IsDoubleTap(void) +{ + if (doubleTap) TraceLog(INFO, "DOUBLE TAP gesture detected"); + + return doubleTap; +} + +bool IsDragGesture(void) +{ + return drag; +} + // Returns touch position X int GetTouchX(void) { @@ -861,6 +881,27 @@ Vector2 GetTouchPosition(void) return position; } + +/*bool GetPointer(Vector2 *dragPositions) +{ + //static int stdVector[MAX_TOUCH_POINTS]; + //static int indexPosition = 0; + //if (indexPosition == 0) return false; + Vector2 vec_pointers_[]; + + //eventDrag + int32_t iIndex = FindIndex( eventDrag, vec_pointers_[0] ); + + if (iIndex == -1) return false; + + float x = AMotionEvent_getX(eventDrag, iIndex); + float y = AMotionEvent_getY(eventDrag, iIndex); + + *dragPositions = Vector2( x, y ); + + + return true; +}*/ #endif //---------------------------------------------------------------------------------- @@ -881,11 +922,13 @@ static void InitDisplay(int width, int height) // Downscale matrix is required in case desired screen area is bigger than display area downscaleView = MatrixIdentity(); -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) glfwSetErrorCallback(ErrorCallback); if (!glfwInit()) TraceLog(ERROR, "Failed to initialize GLFW"); + // NOTE: Getting video modes is not implemented in emscripten GLFW3 version +#if defined(PLATFORM_DESKTOP) // Find monitor resolution const GLFWvidmode *mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); @@ -895,7 +938,11 @@ static void InitDisplay(int width, int height) // Screen size security check if (screenWidth <= 0) screenWidth = displayWidth; if (screenHeight <= 0) screenHeight = displayHeight; - +#elif defined(PLATFORM_WEB) + displayWidth = screenWidth; + displayHeight = screenHeight; +#endif + glfwDefaultWindowHints(); // Set default windows hints glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Avoid window being resizable @@ -944,7 +991,9 @@ static void InitDisplay(int width, int height) else { TraceLog(INFO, "Display device initialized successfully"); +#if defined(PLATFORM_DESKTOP) TraceLog(INFO, "Display size: %i x %i", displayWidth, displayHeight); +#endif TraceLog(INFO, "Render size: %i x %i", renderWidth, renderHeight); TraceLog(INFO, "Screen size: %i x %i", screenWidth, screenHeight); TraceLog(INFO, "Viewport offsets: %i, %i", renderOffsetX, renderOffsetY); @@ -953,6 +1002,8 @@ static void InitDisplay(int width, int height) glfwSetWindowSizeCallback(window, WindowSizeCallback); glfwSetCursorEnterCallback(window, CursorEnterCallback); glfwSetKeyCallback(window, KeyCallback); + glfwSetMouseButtonCallback(window, MouseButtonCallback); + glfwSetCharCallback(window, CharCallback); glfwSetScrollCallback(window, ScrollCallback); glfwMakeContextCurrent(window); @@ -1116,7 +1167,7 @@ void InitGraphics(void) #endif } -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) // GLFW3 Error Callback, runs on GLFW3 error static void ErrorCallback(int error, const char *description) { @@ -1138,10 +1189,31 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i // NOTE: Before closing window, while loop must be left! } +#if defined(PLATFORM_DESKTOP) else if (key == GLFW_KEY_F12 && action == GLFW_PRESS) { TakeScreenshot(); } +#endif + else currentKeyState[key] = action; + + // HACK for GuiTextBox, to deteck back key + // TODO: Review... + if ((key == 259) && (action == GLFW_PRESS)) lastKeyPressed = 3; +} + +// GLFW3 Mouse Button Callback, runs on mouse button pressed +static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods) +{ + currentMouseState[button] = action; +} + +// GLFW3 Char Key Callback, runs on key pressed (get char value) +static void CharCallback(GLFWwindow *window, unsigned int key) +{ + lastKeyPressed = key; + + //TraceLog(INFO, "Char Callback Key pressed: %i\n", key); } // GLFW3 CursorEnter Callback, when cursor enters the window @@ -1177,6 +1249,7 @@ static int32_t InputCallback(struct android_app *app, AInputEvent *event) if (type == AINPUT_EVENT_TYPE_MOTION) { + // Detect TOUCH position if ((screenWidth > displayWidth) || (screenHeight > displayHeight)) { // TODO: Seems to work ok but... review! @@ -1240,7 +1313,124 @@ static int32_t InputCallback(struct android_app *app, AInputEvent *event) //size_t pointerCount = AMotionEvent_getPointerCount(event); //float AMotionEvent_getPressure(const AInputEvent *motion_event, size_t pointer_index); // 0 to 1 //float AMotionEvent_getSize(const AInputEvent *motion_event, size_t pointer_index); // Pressed area + + // Detect DOUBLE TAP event + bool tapDetected = touchTap; + switch (flags) + { + case AMOTION_EVENT_ACTION_DOWN: + { + int64_t eventTime = AMotionEvent_getEventTime(event); + + if (eventTime - lastTapTime <= DOUBLE_TAP_TIMEOUT) + { + float x = AMotionEvent_getX(event, 0) - lastTapX; + float y = AMotionEvent_getY(event, 0) - lastTapY; + + float densityFactor = 1.0f; + + if ((x*x + y*y) < (DOUBLE_TAP_SLOP*DOUBLE_TAP_SLOP*densityFactor)) + { + // Doubletap detected + doubleTap = true; + + } + } + } break; + case AMOTION_EVENT_ACTION_UP: + { + if (tapDetected) + { + lastTapTime = AMotionEvent_getEventTime(event); + lastTapX = AMotionEvent_getX(event, 0); + lastTapY = AMotionEvent_getY(event, 0); + + } + } break; + } + + + // Detect DRAG event + //int32_t action = AMotionEvent_getAction(event); + + int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; + //uint32_t flags = action & AMOTION_EVENT_ACTION_MASK; + //event_ = event; + + int32_t count = AMotionEvent_getPointerCount(event); + + switch (flags) + { + case AMOTION_EVENT_ACTION_DOWN: + { + stdVector[indexPosition] = AMotionEvent_getPointerId(event, 0); + indexPosition++; + TraceLog(INFO, "ACTION_DOWN"); + + //ret = GESTURE_STATE_START; + } break; + case AMOTION_EVENT_ACTION_POINTER_DOWN: + { + stdVector[indexPosition] = AMotionEvent_getPointerId(event, index); + indexPosition++; + TraceLog(INFO, "ACTION_POINTER_DOWN"); + + } break; + case AMOTION_EVENT_ACTION_UP: + { + //int value = stdVector[indexPosition]; + indexPosition--; + //ret = GESTURE_STATE_END; + TraceLog(INFO, "ACTION_UP"); + + } break; + case AMOTION_EVENT_ACTION_POINTER_UP: + { + int32_t releasedPointerId = AMotionEvent_getPointerId(event, index); + + int i = 0; + for (i = 0; i < MAX_TOUCH_POINTS; i++) + { + if (stdVector[i] == releasedPointerId) + { + for (int k = i; k < indexPosition - 1; k++) + { + stdVector[k] = stdVector[k + 1]; + } + + //indexPosition--; + indexPosition = 0; + break; + } + } + + if (i <= 1) + { + // Reset pinch or drag + //if (count == 2) //ret = GESTURE_STATE_START; + } + TraceLog(INFO, "ACTION_POINTER_UP"); + + } break; + case AMOTION_EVENT_ACTION_MOVE: + { + if (count == 1) + { + //TraceLog(INFO, "DRAG gesture detected"); + + drag = true; //ret = GESTURE_STATE_MOVE; + } + else break; + TraceLog(INFO, "ACTION_MOVE"); + + } break; + case AMOTION_EVENT_ACTION_CANCEL: break; + default: break; + } + + //-------------------------------------------------------------------- + return 1; } else if (type == AINPUT_EVENT_TYPE_KEY) @@ -1386,7 +1576,7 @@ static void InitTimer(void) // Get current time measure since InitTimer() static double GetTime(void) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) return glfwGetTime(); #elif defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI) struct timespec ts; @@ -1400,7 +1590,7 @@ static double GetTime(void) // Get one key state static bool GetKeyStatus(int key) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) return glfwGetKey(window, key); #elif defined(PLATFORM_ANDROID) // TODO: Check virtual keyboard (?) @@ -1415,7 +1605,7 @@ static bool GetKeyStatus(int key) // Get one mouse button state static bool GetMouseButtonStatus(int button) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) return glfwGetMouseButton(window, button); #elif defined(PLATFORM_ANDROID) // TODO: Check virtual keyboard (?) @@ -1429,7 +1619,7 @@ static bool GetMouseButtonStatus(int button) // Poll (store) all input events static void PollInputEvents(void) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) // Mouse input polling double mouseX; double mouseY; @@ -1441,14 +1631,23 @@ static void PollInputEvents(void) // Keyboard polling // Automatically managed by GLFW3 through callback - + lastKeyPressed = -1; + + // Register previous keys states + for (int i = 0; i < 512; i++) previousKeyState[i] = currentKeyState[i]; + + // Register previous mouse states + for (int i = 0; i < 3; i++) previousMouseState[i] = currentMouseState[i]; + glfwPollEvents(); // Register keyboard/mouse events #elif defined(PLATFORM_ANDROID) // TODO: Check virtual keyboard (?) - // Reset touchTap event + // Reset touch events touchTap = false; + doubleTap = false; + drag = false; // Poll Events (registered events) while ((ident = ALooper_pollAll(0, NULL, &events,(void**)&source)) >= 0) @@ -1597,14 +1796,17 @@ static void PollInputEvents(void) static void InitMouse(void) { // NOTE: We can use /dev/input/mice to read from all available mice - if ((mouseStream = open(DEFAULT_MOUSE_DEV, O_RDONLY|O_NONBLOCK)) < 0) TraceLog(WARNING, "Could not open mouse device, no mouse available"); + if ((mouseStream = open(DEFAULT_MOUSE_DEV, O_RDONLY|O_NONBLOCK)) < 0) + { + TraceLog(WARNING, "Mouse device could not be opened, no mouse available"); + } else { mouseReady = true; - int err = pthread_create(&mouseThreadId, NULL, &MouseThread, NULL); + int error = pthread_create(&mouseThreadId, NULL, &MouseThread, NULL); - if (err != 0) TraceLog(WARNING, "Error creating mouse input event thread"); + if (error != 0) TraceLog(WARNING, "Error creating mouse input event thread"); else TraceLog(INFO, "Mouse device initialized successfully"); } } @@ -1715,7 +1917,7 @@ static void RestoreKeyboard(void) static void InitGamepad(void) { // TODO: Gamepad support - if ((gamepadStream = open(DEFAULT_GAMEPAD_DEV, O_RDONLY|O_NONBLOCK)) < 0) TraceLog(WARNING, "Could not open gamepad device, no gamepad available"); + if ((gamepadStream = open(DEFAULT_GAMEPAD_DEV, O_RDONLY|O_NONBLOCK)) < 0) TraceLog(WARNING, "Gamepad device could not be opened, no gamepad available"); else TraceLog(INFO, "Gamepad device initialized successfully"); } #endif @@ -1723,7 +1925,7 @@ static void InitGamepad(void) // Copy back buffer to front buffers static void SwapBuffers(void) { -#if defined(PLATFORM_DESKTOP) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) glfwSwapBuffers(window); #elif defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI) eglSwapBuffers(display, surface); @@ -1737,7 +1939,7 @@ static void SetupFramebufferSize(int displayWidth, int displayHeight) // Calculate renderWidth and renderHeight, we have the display size (input params) and the desired screen size (global var) if ((screenWidth > displayWidth) || (screenHeight > displayHeight)) { - TraceLog(WARNING, "DOWNSCALING: Required screen size (%i x %i) is bigger than display size (%i x %i)", screenWidth, screenHeight, displayWidth, displayHeight); + TraceLog(WARNING, "DOWNSCALING: Required screen size (%ix%i) is bigger than display size (%ix%i)", screenWidth, screenHeight, displayWidth, displayHeight); // Downscaling to fit display with border-bars float widthRatio = (float)displayWidth/(float)screenWidth; @@ -1806,6 +2008,7 @@ static void SetupFramebufferSize(int displayWidth, int displayHeight) // Plays raylib logo appearing animation static void LogoAnimation(void) { +#ifndef PLATFORM_WEB int logoPositionX = screenWidth/2 - 128; int logoPositionY = screenHeight/2 - 128; @@ -1923,6 +2126,8 @@ static void LogoAnimation(void) EndDrawing(); //---------------------------------------------------------------------------------- } +#endif showLogo = false; // Prevent for repeating when reloading window (Android) } + diff --git a/src/makefile b/src/makefile index bb37748a..501bd0c9 100644 --- a/src/makefile +++ b/src/makefile @@ -1,8 +1,6 @@ #************************************************************************************************** # -# raylib for Raspberry Pi and Windows desktop -# -# makefile for library compilation (raylib.a) +# raylib makefile for desktop platforms, Raspberry Pi and HTML5 (emscripten) # # Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com) # @@ -23,9 +21,9 @@ # #************************************************************************************************** -# define raylib platform (by default, compile for RPI) -# Other possible platforms: PLATFORM_DESKTOP PLATFORM_DESKTOP_LINUX -PLATFORM ?= PLATFORM_RPI +# define raylib platform to compile for +# possible platforms: PLATFORM_DESKTOP PLATFORM_RPI PLATFORM_WEB +PLATFORM ?= PLATFORM_DESKTOP # define raylib graphics api depending on selected platform ifeq ($(PLATFORM),PLATFORM_RPI) @@ -37,20 +35,31 @@ else #GRAPHICS = GRAPHICS_API_OPENGL_33 # Uncomment to use OpenGL 3.3 endif +ifeq ($(PLATFORM),PLATFORM_WEB) + GRAPHICS = GRAPHICS_API_OPENGL_ES2 +endif + # NOTE: makefiles targets require tab indentation # define compiler: gcc for C program, define as g++ for C++ -CC = gcc +ifeq ($(PLATFORM),PLATFORM_WEB) + # define emscripten compiler + CC = emcc +else + # define default gcc compiler + CC = gcc +endif # define compiler flags: # -O2 defines optimization level # -Wall turns on most, but not all, compiler warnings # -std=c99 use standard C from 1999 revision ifeq ($(PLATFORM),PLATFORM_RPI) - CFLAGS = -O2 -Wall -std=gnu99 -fgnu89-inline + CFLAGS = -O1 -Wall -std=gnu99 -fgnu89-inline else - CFLAGS = -O2 -Wall -std=c99 -fgnu89-inline + CFLAGS = -O1 -Wall -std=c99 endif + #CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes # define any directories containing required header files @@ -69,15 +78,20 @@ default: raylib # compile raylib library raylib: $(OBJS) +ifeq ($(PLATFORM),PLATFORM_WEB) + emcc -O1 $(OBJS) -o libraylib.bc +else ar rcs libraylib.a $(OBJS) +endif # compile core module +# emcc core.c -o core.bc -DPLATFORM_DESKTOP core.o: core.c - $(CC) -c core.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) + $(CC) -c core.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile rlgl module rlgl.o: rlgl.c - $(CC) -c rlgl.c $(CFLAGS) $(INCLUDES) -D$(GRAPHICS) + $(CC) -c rlgl.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile raymath module raymath.o: raymath.c @@ -85,19 +99,19 @@ raymath.o: raymath.c # compile shapes module shapes.o: shapes.c - $(CC) -c shapes.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) + $(CC) -c shapes.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile textures module textures.o: textures.c - $(CC) -c textures.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) + $(CC) -c textures.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile text module text.o: text.c - $(CC) -c text.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) + $(CC) -c text.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile models module models.o: models.c - $(CC) -c models.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) + $(CC) -c models.c $(CFLAGS) $(INCLUDES) -D$(PLATFORM) -D$(GRAPHICS) # compile audio module audio.o: audio.c @@ -119,9 +133,13 @@ else ifeq ($(PLATFORM),PLATFORM_DESKTOP_LINUX) find . -type f -executable -delete rm -f *.o libraylib.a +else +ifeq ($(PLATFORM),PLATFORM_WEB) + del *.o libraylib.bc else del *.o libraylib.a endif +endif endif @echo Cleaning done diff --git a/src/models.c b/src/models.c index 2d2af038..e8e4f635 100644 --- a/src/models.c +++ b/src/models.c @@ -50,7 +50,7 @@ //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- -// It's lonely here... +extern unsigned int whiteTexture; //---------------------------------------------------------------------------------- // Module specific Functions Declaration @@ -66,14 +66,14 @@ static VertexData LoadOBJ(const char *fileName); // NOTE: Cube position is the center position void DrawCube(Vector3 position, float width, float height, float lenght, Color color) { - float x = position.x; - float y = position.y; - float z = position.z; + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; rlPushMatrix(); // NOTE: Be careful! Function order matters (rotate -> scale -> translate) - //rlTranslatef(0.0f, 0.0f, 0.0f); + rlTranslatef(position.x, position.y, position.z); //rlScalef(2.0f, 2.0f, 2.0f); //rlRotatef(45, 0, 1, 0); @@ -146,12 +146,13 @@ void DrawCubeV(Vector3 position, Vector3 size, Color color) // Draw cube wires void DrawCubeWires(Vector3 position, float width, float height, float lenght, Color color) { - float x = position.x; - float y = position.y; - float z = position.z; + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); //rlRotatef(45, 0, 1, 0); rlBegin(RL_LINES); @@ -445,11 +446,37 @@ void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, fl rlPopMatrix(); } +// Draw a quad +void DrawQuad(Vector3 vertices[4], Vector2 textcoords[4], Vector3 normals[4], Color colors[4]) +{ + rlBegin(RL_QUADS); + rlColor4ub(colors[0].r, colors[0].g, colors[0].b, colors[0].a); + rlNormal3f(normals[0].x, normals[0].y, normals[0].z); + rlTexCoord2f(textcoords[0].x, textcoords[0].y); + rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z); + + rlColor4ub(colors[1].r, colors[1].g, colors[1].b, colors[1].a); + rlNormal3f(normals[1].x, normals[1].y, normals[1].z); + rlTexCoord2f(textcoords[1].x, textcoords[1].y); + rlVertex3f(vertices[1].x, vertices[1].y, vertices[1].z); + + rlColor4ub(colors[2].r, colors[2].g, colors[2].b, colors[2].a); + rlNormal3f(normals[2].x, normals[2].y, normals[2].z); + rlTexCoord2f(textcoords[2].x, textcoords[2].y); + rlVertex3f(vertices[2].x, vertices[2].y, vertices[2].z); + + rlColor4ub(colors[3].r, colors[3].g, colors[3].b, colors[3].a); + rlNormal3f(normals[3].x, normals[3].y, normals[3].z); + rlTexCoord2f(textcoords[3].x, textcoords[3].y); + rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z); + rlEnd(); +} + // Draw a plane void DrawPlane(Vector3 centerPos, Vector2 size, Vector3 rotation, Color color) { // NOTE: QUADS usage require defining a texture on OpenGL 3.3+ - rlEnableTexture(1); // Default white texture + if (rlGetVersion() != OPENGL_11) rlEnableTexture(whiteTexture); // Default white texture // NOTE: Plane is always created on XZ ground and then rotated rlPushMatrix(); @@ -471,7 +498,7 @@ void DrawPlane(Vector3 centerPos, Vector2 size, Vector3 rotation, Color color) rlEnd(); rlPopMatrix(); - rlDisableTexture(); + if (rlGetVersion() != OPENGL_11) rlDisableTexture(); } // Draw a plane with divisions @@ -743,7 +770,7 @@ Model LoadHeightmap(Image heightmap, float maxHeight) vData.texcoords[tcCounter + 7] = vData.texcoords[tcCounter + 5]; vData.texcoords[tcCounter + 8] = vData.texcoords[tcCounter + 2]; - vData.texcoords[tcCounter + 9] = vData.texcoords[tcCounter + 1]; + vData.texcoords[tcCounter + 9] = vData.texcoords[tcCounter + 3]; vData.texcoords[tcCounter + 10] = (float)(x+1) / (mapX-1); vData.texcoords[tcCounter + 11] = (float)(z+1) / (mapZ-1); @@ -785,7 +812,7 @@ Model LoadHeightmap(Image heightmap, float maxHeight) } // Load a map image as a 3d model (cubes based) -Model LoadCubesmap(Image cubesmap) +Model LoadCubicmap(Image cubesmap) { VertexData vData; @@ -1041,8 +1068,6 @@ Model LoadCubesmap(Image cubesmap) // Move data from mapVertices temp arays to vertices float array vData.vertexCount = vCounter; - printf("Vertex count: %i\n", vCounter); - vData.vertices = (float *)malloc(vData.vertexCount * 3 * sizeof(float)); vData.normals = (float *)malloc(vData.vertexCount * 3 * sizeof(float)); vData.texcoords = (float *)malloc(vData.vertexCount * 2 * sizeof(float)); @@ -1263,6 +1288,12 @@ static VertexData LoadOBJ(const char *fileName) FILE *objFile; objFile = fopen(fileName, "rt"); + + if (objFile == NULL) + { + TraceLog(WARNING, "[%s] OBJ file could not be opened", fileName); + return vData; + } // First reading pass: Get numVertex, numNormals, numTexCoords, numTriangles // NOTE: vertex, texcoords and normals could be optimized (to be used indexed on faces definition) @@ -1490,4 +1521,36 @@ static VertexData LoadOBJ(const char *fileName) TraceLog(INFO, "[%s] Model loaded successfully in RAM (CPU)", fileName); return vData; -} \ No newline at end of file +} + +bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB) +{ + + return false; +} + +bool CheckCollisionBoxes(Vector3 minBBox1, Vector3 maxBBox1, Vector3 minBBox2, Vector3 maxBBox2) +{ + /* + // Get min and max vertex to construct bounds (AABB) + Vector3 minVertex = tempVertices[0]; + Vector3 maxVertex = tempVertices[0]; + + for (int i = 1; i < tempVertices.Count; i++) + { + minVertex = Vector3.Min(minVertex, tempVertices[i]); + maxVertex = Vector3.Max(maxVertex, tempVertices[i]); + } + + bounds = new BoundingBox(minVertex, maxVertex); + */ + return false; +} + +bool CheckCollisionBoxSphere(Vector3 minBBox, Vector3 maxBBox, Vector3 centerSphere, Vector3 radiusSphere) +{ + + return false; +} + +//BoundingBox GetCollisionArea(BoundingBox box1, BoundingBox box2) \ No newline at end of file diff --git a/src/raylib.h b/src/raylib.h index 9809d823..69966069 100644 --- a/src/raylib.h +++ b/src/raylib.h @@ -14,7 +14,7 @@ * Basic 3d support for Shapes, Models, Heightmaps and Billboards * Powerful math module for Vector and Matrix operations [raymath] * Audio loading and playing with streaming support (WAV and OGG) -* Multiplatform support, including Android devices and Raspberry Pi +* Multiplatform support, including Android devices, Raspberry Pi and HTML5 * * Used external libs: * GLFW3 (www.glfw.org) for window/context management and input @@ -63,9 +63,10 @@ //#define PLATFORM_DESKTOP // Windows, Linux or OSX //#define PLATFORM_ANDROID // Android device //#define PLATFORM_RPI // Raspberry Pi +//#define PLATFORM_WEB // HTML5 (emscripten, asm.js) // Security check in case no PLATFORM_* defined -#if !defined(PLATFORM_DESKTOP) && !defined(PLATFORM_ANDROID) && !defined(PLATFORM_RPI) +#if !defined(PLATFORM_DESKTOP) && !defined(PLATFORM_ANDROID) && !defined(PLATFORM_RPI) && !defined(PLATFORM_WEB) #define PLATFORM_DESKTOP #endif @@ -275,6 +276,15 @@ typedef struct Sound { unsigned int buffer; } Sound; +// Wave type, defines audio wave data +typedef struct Wave { + void *data; // Buffer data pointer + unsigned int dataSize; // Data size in bytes + unsigned int sampleRate; + short bitsPerSample; + short channels; +} Wave; + #ifdef __cplusplus extern "C" { // Prevents name mangling of functions #endif @@ -289,7 +299,7 @@ extern "C" { // Prevents name mangling of functions //------------------------------------------------------------------------------------ #if defined(PLATFORM_ANDROID) void InitWindow(int width, int height, struct android_app *state); // Init Android activity -#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) void InitWindow(int width, int height, const char *title); // Initialize Window and OpenGL Graphics #endif @@ -302,6 +312,7 @@ void SetExitKey(int key); // Set a custom key #endif int GetScreenWidth(void); // Get current screen width int GetScreenHeight(void); // Get current screen height +int GetKeyPressed(void); // Get latest key pressed void ClearBackground(Color color); // Sets Background Color void BeginDrawing(void); // Setup drawing canvas to start drawing @@ -321,13 +332,12 @@ int GetRandomValue(int min, int max); // Returns a random Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f void SetupFlags(char flags); // Enable some window configurations - -void ShowLogo(void); // Activates raylib logo at startup +void ShowLogo(void); // Activates raylib logo at startup (can be done with flags) //------------------------------------------------------------------------------------ // Input Handling Functions (Module: core) //------------------------------------------------------------------------------------ -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) bool IsKeyPressed(int key); // Detect if a key has been pressed once bool IsKeyDown(int key); // Detect if a key is being pressed bool IsKeyReleased(int key); // Detect if a key has been released once @@ -340,8 +350,11 @@ bool IsMouseButtonUp(int button); // Detect if a mouse but int GetMouseX(void); // Returns mouse position X int GetMouseY(void); // Returns mouse position Y Vector2 GetMousePosition(void); // Returns mouse position XY +void SetMousePosition(Vector2 position); // Set mouse position XY int GetMouseWheelMove(void); // Returns mouse wheel movement Y +#endif +#if defined(PLATFORM_DESKTOP) bool IsGamepadAvailable(int gamepad); // Detect if a gamepad is available Vector2 GetGamepadMovement(int gamepad); // Return axis movement vector for a gamepad bool IsGamepadButtonPressed(int gamepad, int button); // Detect if a gamepad button has been pressed once @@ -394,9 +407,11 @@ Image LoadImage(const char *fileName); Image LoadImageFromRES(const char *rresName, int resId); // Load an image from rRES file (raylib Resource) Texture2D LoadTexture(const char *fileName); // Load an image as texture into GPU memory Texture2D LoadTextureFromRES(const char *rresName, int resId); // Load an image as texture from rRES file (raylib Resource) -Texture2D CreateTexture(Image image, bool genMipmaps); // Create a Texture2D from Image data (and generate mipmaps) +Texture2D LoadTextureFromImage(Image image, bool genMipmaps); // Load a texture from image data (and generate mipmaps) +Texture2D CreateTexture(Image image, bool genMipmaps); // [DEPRECATED] Same as LoadTextureFromImage() void UnloadImage(Image image); // Unload image from CPU memory (RAM) void UnloadTexture(Texture2D texture); // Unload texture from GPU memory +void ConvertToPOT(Image *image, Color fillColor); // Convert image to POT (power-of-two) void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 @@ -433,6 +448,7 @@ void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +void DrawQuad(Vector3 vertices[4], Vector2 textcoords[4], Vector3 normals[4], Color colors[4]); // Draw a quad void DrawPlane(Vector3 centerPos, Vector2 size, Vector3 rotation, Color color); // Draw a plane void DrawPlaneEx(Vector3 centerPos, Vector2 size, Vector3 rotation, int slicesX, int slicesZ, Color color); // Draw a plane with divisions void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) @@ -446,7 +462,7 @@ void DrawGizmoEx(Vector3 position, Vector3 rotation, float scale); Model LoadModel(const char *fileName); // Load a 3d model (.OBJ) //Model LoadModelFromRES(const char *rresName, int resId); // TODO: Load a 3d model from rRES file (raylib Resource) Model LoadHeightmap(Image heightmap, float maxHeight); // Load a heightmap image as a 3d model -Model LoadCubesmap(Image cubesmap); // Load a map image as a 3d model (cubes based) +Model LoadCubicmap(Image cubicmap); // Load a map image as a 3d model (cubes based) void UnloadModel(Model model); // Unload 3d model from memory void SetModelTexture(Model *model, Texture2D texture); // Link a texture to a model @@ -464,6 +480,7 @@ void InitAudioDevice(void); // Initialize au void CloseAudioDevice(void); // Close the audio device and context (and music stream) Sound LoadSound(char *fileName); // Load sound to memory +Sound LoadSoundFromWave(Wave wave); // Load sound to memory from wave data Sound LoadSoundFromRES(const char *rresName, int resId); // Load sound to memory from rRES file (raylib Resource) void UnloadSound(Sound sound); // Unload sound void PlaySound(Sound sound); // Play a sound diff --git a/src/raymath.c b/src/raymath.c index e598b381..ed45ee92 100644 --- a/src/raymath.c +++ b/src/raymath.c @@ -329,8 +329,6 @@ void MatrixInvert(Matrix *mat) // Calculate the invert determinant (inlined to avoid double-caching) float invDet = 1/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); - printf("%f\n", invDet); - temp.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; temp.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; temp.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; @@ -492,6 +490,48 @@ Matrix MatrixRotate(float angleX, float angleY, float angleZ) return result; } +/* +Matrix MatrixRotate(float angle, float x, float y, float z) +{ + Matrix result = MatrixIdentity(); + + float c = cosf(angle*DEG2RAD); // cosine + float s = sinf(angle*DEG2RAD); // sine + float c1 = 1.0f - c; // 1 - c + + float m0 = result.m0, m4 = result.m4, m8 = result.m8, m12 = result.m12, + m1 = result.m1, m5 = result.m5, m9 = result.m9, m13 = result.m13, + m2 = result.m2, m6 = result.m6, m10 = result.m10, m14 = result.m14; + + // build rotation matrix + float r0 = x * x * c1 + c; + float r1 = x * y * c1 + z * s; + float r2 = x * z * c1 - y * s; + float r4 = x * y * c1 - z * s; + float r5 = y * y * c1 + c; + float r6 = y * z * c1 + x * s; + float r8 = x * z * c1 + y * s; + float r9 = y * z * c1 - x * s; + float r10= z * z * c1 + c; + + // multiply rotation matrix + result.m0 = r0*m0 + r4*m1 + r8*m2; + result.m1 = r1*m0 + r5*m1 + r9*m2; + result.m2 = r2*m0 + r6*m1 + r10*m2; + result.m4 = r0*m4 + r4*m5 + r8*m6; + result.m5 = r1*m4 + r5*m5 + r9*m6; + result.m6 = r2*m4 + r6*m5 + r10*m6; + result.m8 = r0*m8 + r4*m9 + r8*m10; + result.m9 = r1*m8 + r5*m9 + r9*m10; + result.m10 = r2*m8 + r6*m9 + r10*m10; + result.m12 = r0*m12+ r4*m13 + r8*m14; + result.m13 = r1*m12+ r5*m13 + r9*m14; + result.m14 = r2*m12+ r6*m13 + r10*m14; + + return result; +} +*/ + // Create rotation matrix from axis and angle // TODO: Test this function // NOTE: NO prototype defined! @@ -559,8 +599,8 @@ Matrix MatrixFromAxisAngle2(Vector3 axis, float angle) float axisX = axis.x, axisY = axis.y, axisZ = axis.y; // Calculate angles - float cosres = (float)cos(-angle); - float sinres = (float)sin(-angle); + float cosres = (float)cos(angle); + float sinres = (float)sin(angle); float t = 1.0f - cosres; // Do the conversion math once @@ -668,6 +708,7 @@ Matrix MatrixScale(float x, float y, float z) // Returns transformation matrix for a given translation, rotation and scale // NOTE: Transformation order is rotation -> scale -> translation +// NOTE: Rotation angles should come in radians Matrix MatrixTransform(Vector3 translation, Vector3 rotation, Vector3 scale) { Matrix result = MatrixIdentity(); diff --git a/src/raymath.h b/src/raymath.h index c396a347..c8c1a26c 100644 --- a/src/raymath.h +++ b/src/raymath.h @@ -55,7 +55,7 @@ } Vector3; #endif -// Matrix type (OpenGL style 4x4 - right handed) +// Matrix type (OpenGL style 4x4 - right handed, column major) typedef struct Matrix { float m0, m4, m8, m12; float m1, m5, m9, m13; @@ -107,9 +107,9 @@ Matrix MatrixIdentity(void); // Returns identity matr Matrix MatrixAdd(Matrix left, Matrix right); // Add two matrices Matrix MatrixSubstract(Matrix left, Matrix right); // Substract two matrices (left - right) Matrix MatrixTranslate(float x, float y, float z); // Returns translation matrix -Matrix MatrixRotate(float angleX, float angleY, float angleZ); // Returns rotation matrix -Matrix MatrixRotateAroundAxis(Vector3 axis, float angle); // Returns rotation matrix for an angle around an specified axis -Matrix MatrixRotateAroundAxis2(Vector3 axis, float angle); // Returns rotation matrix for an angle around an specified axis (test another implemntation) +Matrix MatrixRotate(float axisX, float axisY, float axisZ); // Returns rotation matrix +Matrix MatrixFromAxisAngle(Vector3 axis, float angle); // Returns rotation matrix for an angle around an specified axis +Matrix MatrixFromAxisAngle2(Vector3 axis, float angle); // Returns rotation matrix for an angle around an specified axis (test another implemntation) Matrix MatrixFromQuaternion(Quaternion q); // Returns rotation matrix for a given quaternion Matrix MatrixRotateX(float angle); // Returns x-rotation matrix (angle in radians) Matrix MatrixRotateY(float angle); // Returns y-rotation matrix (angle in radians) diff --git a/src/rlgl.c b/src/rlgl.c index 5e51b2e2..6f2027c7 100644 --- a/src/rlgl.c +++ b/src/rlgl.c @@ -168,21 +168,23 @@ static Vector3 *tempBuffer; static int tempBufferCount = 0; static bool useTempBuffer = false; -// White texture useful for plain color polys (required by shader) -static GLuint whiteTexture; - // Support for VAOs (OpenGL ES2 could not support VAO extensions) static bool vaoSupported = false; #endif #if defined(GRAPHICS_API_OPENGL_ES2) // NOTE: VAO functionality is exposed through extensions (OES) +// emscripten does not support VAOs static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays; static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray; static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays; static PFNGLISVERTEXARRAYOESPROC glIsVertexArray; #endif +// White texture useful for plain color polys (required by shader) +// NOTE: It's required in shapes and models modules! +unsigned int whiteTexture; + //---------------------------------------------------------------------------------- // Module specific Functions Declaration //---------------------------------------------------------------------------------- @@ -298,10 +300,21 @@ void rlRotatef(float angleDeg, float x, float y, float z) // TODO: Support rotation in multiple axes Matrix rot = MatrixIdentity(); + // OPTION 1: It works... if (x == 1) rot = MatrixRotateX(angleDeg*DEG2RAD); else if (y == 1) rot = MatrixRotateY(angleDeg*DEG2RAD); else if (z == 1) rot = MatrixRotateZ(angleDeg*DEG2RAD); - + + // OPTION 2: Requires review... + //Vector3 vec = (Vector3){ 0, 1, 0 }; + //VectorNormalize(&vec); + //rot = MatrixFromAxisAngle(vec, angleDeg*DEG2RAD); // Working? + + // OPTION 3: TODO: Review, it doesn't work! + //Vector3 vec = (Vector3){ x, y, z }; + //VectorNormalize(&vec); + //rot = MatrixRotate(angleDeg*vec.x, angleDeg*vec.x, angleDeg*vec.x); + MatrixTranspose(&rot); *currentMatrix = MatrixMultiply(*currentMatrix, rot); @@ -760,10 +773,13 @@ void rlglInit(void) #endif #if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... +#if !defined(PLATFORM_WEB) glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)eglGetProcAddress("glGenVertexArraysOES"); glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)eglGetProcAddress("glBindVertexArrayOES"); glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)eglGetProcAddress("glDeleteVertexArraysOES"); glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)eglGetProcAddress("glIsVertexArrayOES"); +#endif if (glGenVertexArrays == NULL) TraceLog(WARNING, "Could not initialize VAO extensions, VAOs not supported"); else @@ -848,8 +864,8 @@ void rlglInit(void) whiteTexture = rlglLoadTexture(pixels, 1, 1, false); - if (whiteTexture != 0) TraceLog(INFO, "[TEX ID %i] Base white texture created successfully", whiteTexture); - else TraceLog(WARNING, "Base white texture could not be created"); + if (whiteTexture != 0) TraceLog(INFO, "[TEX ID %i] Base white texture loaded successfully", whiteTexture); + else TraceLog(WARNING, "Base white texture could not be loaded"); // Init draw calls tracking system draws = (DrawCall *)malloc(sizeof(DrawCall)*MAX_DRAWS_BY_TEXTURE); @@ -1113,6 +1129,8 @@ void rlglDrawModel(Model model, Vector3 position, Vector3 rotation, Vector3 scal #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) glUseProgram(shaderProgram); // Use our shader + VectorScale(&rotation, DEG2RAD); + // Get transform matrix (rotation -> scale -> translation) Matrix transform = MatrixTransform(position, rotation, scale); Matrix modelviewworld = MatrixMultiply(transform, modelview); @@ -1305,7 +1323,8 @@ unsigned int rlglLoadTexture(unsigned char *data, int width, int height, bool ge #if defined(GRAPHICS_API_OPENGL_33) // NOTE: We define internal (GPU) format as GL_RGBA8 (probably BGRA8 in practice, driver takes care) - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); + //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); // OpenGL + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); // WebGL #elif defined(GRAPHICS_API_OPENGL_ES2) // NOTE: On embedded systems, we let the driver choose the best internal format glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); @@ -1324,7 +1343,7 @@ unsigned int rlglLoadTexture(unsigned char *data, int width, int height, bool ge // Unbind current texture glBindTexture(GL_TEXTURE_2D, 0); - TraceLog(INFO, "[TEX ID %i] Texture created successfully (%i x %i)", id, width, height); + TraceLog(INFO, "[TEX ID %i] Texture created successfully (%ix%i)", id, width, height); return id; } @@ -1347,7 +1366,7 @@ Model rlglLoadModel(VertexData mesh) #elif defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) model.textureId = 1; // Default whiteTexture - GLuint vaoModel; // Vertex Array Objects (VAO) + GLuint vaoModel = 0; // Vertex Array Objects (VAO) GLuint vertexBuffer[3]; // Vertex Buffer Objects (VBO) if (vaoSupported) @@ -1562,6 +1581,7 @@ static GLuint LoadDefaultShaders(void) char fShaderStr[] = " #version 110 \n" // NOTE: Equivalent to version 100 on ES2 #elif defined(GRAPHICS_API_OPENGL_ES2) char fShaderStr[] = " #version 100 \n" // NOTE: Must be defined this way! 110 doesn't work! + "precision mediump float; \n" // WebGL, required for emscripten #endif "uniform sampler2D texture0; \n" "varying vec2 fragTexCoord; \n" @@ -1673,33 +1693,35 @@ static GLuint LoadShaders(char *vertexFileName, char *fragmentFileName) } // Read shader text file -static char *TextFileRead(char *fn) +static char *TextFileRead(char *fileName) { - FILE *fp; + FILE *textFile; char *text = NULL; int count=0; - if (fn != NULL) + if (fileName != NULL) { - fp = fopen(fn,"rt"); + textFile = fopen(fileName,"rt"); - if (fp != NULL) + if (textFile != NULL) { - fseek(fp, 0, SEEK_END); - count = ftell(fp); - rewind(fp); + fseek(textFile, 0, SEEK_END); + count = ftell(textFile); + rewind(textFile); if (count > 0) { text = (char *)malloc(sizeof(char) * (count+1)); - count = fread(text, sizeof(char), count, fp); + count = fread(text, sizeof(char), count, textFile); text[count] = '\0'; } - fclose(fp); + fclose(textFile); } + else TraceLog(WARNING, "[%s] Text file could not be opened", fileName); } + return text; } @@ -1798,7 +1820,7 @@ static void InitializeBuffersGPU(void) glGenVertexArrays(1, &vaoTriangles); glBindVertexArray(vaoTriangles); } - + // Create buffers for our vertex data glGenBuffers(2, trianglesBuffer); @@ -1823,7 +1845,7 @@ static void InitializeBuffersGPU(void) glGenVertexArrays(1, &vaoQuads); glBindVertexArray(vaoQuads); } - + // Create buffers for our vertex data glGenBuffers(4, quadsBuffer); @@ -1859,6 +1881,8 @@ static void InitializeBuffersGPU(void) } // Update VBOs with vertex array data +// TODO: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) +// TODO: If no data changed on the CPU arrays --> No need to update GPU arrays every frame! static void UpdateBuffers(void) { // Activate Lines VAO @@ -1973,7 +1997,7 @@ static int GenerateMipmaps(unsigned char *data, int baseWidth, int baseHeight) j++; } - TraceLog(DEBUG, "Mipmap base (%i, %i)", width, height); + TraceLog(DEBUG, "Mipmap base (%ix%i)", width, height); for (int mip = 1; mip < mipmapCount; mip++) { @@ -2044,7 +2068,7 @@ static pixel *GenNextMipmap(pixel *srcData, int srcWidth, int srcHeight) } } - TraceLog(DEBUG, "Mipmap generated successfully (%i, %i)", width, height); + TraceLog(DEBUG, "Mipmap generated successfully (%ix%i)", width, height); return mipmap; } diff --git a/src/rlgl.h b/src/rlgl.h index 2e1d18f4..5fa9c486 100644 --- a/src/rlgl.h +++ b/src/rlgl.h @@ -45,7 +45,7 @@ // Choose opengl version here or just define it at compile time: -DGRAPHICS_API_OPENGL_33 //#define GRAPHICS_API_OPENGL_11 // Only available on PLATFORM_DESKTOP //#define GRAPHICS_API_OPENGL_33 // Only available on PLATFORM_DESKTOP -//#define GRAPHICS_API_OPENGL_ES2 // Only available on PLATFORM_ANDROID or PLATFORM_RPI +//#define GRAPHICS_API_OPENGL_ES2 // Only available on PLATFORM_ANDROID or PLATFORM_RPI or PLATFORM_WEB // Security check in case no GRAPHICS_API_OPENGL_* defined #if !defined(GRAPHICS_API_OPENGL_11) && !defined(GRAPHICS_API_OPENGL_33) && !defined(GRAPHICS_API_OPENGL_ES2) @@ -72,8 +72,9 @@ #define MAX_TRIANGLES_BATCH 4096 #define MAX_QUADS_BATCH 4096 #elif defined(GRAPHICS_API_OPENGL_ES2) - // NOTE: Reduce memory sizes for embedded systems (RPI) - #define MAX_LINES_BATCH 2048 // Critical for wire shapes (sphere) + // NOTE: Reduce memory sizes for embedded systems (RPI and HTML5) + // NOTE: On HTML5 (emscripten) this is allocated on heap, by default it's only 16MB!...just take care... + #define MAX_LINES_BATCH 1024 // Critical for wire shapes (sphere) #define MAX_TRIANGLES_BATCH 2048 // Critical for some shapes (sphere) #define MAX_QUADS_BATCH 1024 // Be careful with text, every letter maps a quad #endif diff --git a/src/shapes.c b/src/shapes.c index 6fa26bee..d872eacf 100644 --- a/src/shapes.c +++ b/src/shapes.c @@ -44,7 +44,7 @@ //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- -// It's lonely here... +extern unsigned int whiteTexture; //---------------------------------------------------------------------------------- // Module specific Functions Declaration @@ -197,7 +197,7 @@ void DrawRectangleV(Vector2 position, Vector2 size, Color color) else if ((rlGetVersion() == OPENGL_33) || (rlGetVersion() == OPENGL_ES_20)) { // NOTE: This shape uses QUADS to avoid drawing order issues (view rlglDraw) - rlEnableTexture(1); // Default white texture + rlEnableTexture(whiteTexture); // Default white texture rlBegin(RL_QUADS); rlColor4ub(color.r, color.g, color.b, color.a); diff --git a/src/stb_image.h b/src/stb_image.h index 461ef087..39cbb7ad 100644 --- a/src/stb_image.h +++ b/src/stb_image.h @@ -1,19 +1,27 @@ -/* stb_image - v1.46 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c - when you control the images you're loading +/* stb_image - v2.00b - public domain image loader - http://nothings.org/stb_image.h no warranty implied; use at your own risk Do this: #define STB_IMAGE_IMPLEMENTATION before you include this file in *one* C or C++ file to create the implementation. - #define STBI_ASSERT(x) to avoid using assert.h. + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + QUICK NOTES: Primarily of interest to game developers and other people who can avoid problematic images and only need the trivial interface - JPEG baseline (no JPEG progressive) - PNG 8-bit-per-channel only + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8-bit-per-channel (16 bpc not supported) TGA (not sure what subset, if a subset) BMP non-1bpp, non-RLE @@ -22,33 +30,138 @@ GIF (*comp always reports as 4-channel) HDR (radiance rgbE format) PIC (Softimage PIC) + PNM (PPM and PGM binary only) - decode from memory or through FILE (define STBI_NO_STDIO to remove code) - decode from arbitrary I/O callbacks - - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) - Latest revisions: - 1.46 (2014-08-26) fix broken tRNS chunk in non-paletted PNG - 1.45 (2014-08-16) workaround MSVC-ARM internal compiler error by wrapping malloc - 1.44 (2014-08-07) warnings - 1.43 (2014-07-15) fix MSVC-only bug in 1.42 - 1.42 (2014-07-09) no _CRT_SECURE_NO_WARNINGS; error-path fixes; STBI_ASSERT - 1.41 (2014-06-25) fix search&replace that messed up comments/error messages - 1.40 (2014-06-22) gcc warning - 1.39 (2014-06-15) TGA optimization bugfix, multiple BMP fixes - 1.38 (2014-06-06) suppress MSVC run-time warnings, fix accidental rename of 'skip' - 1.37 (2014-06-04) remove duplicate typedef - 1.36 (2014-06-03) converted to header file, allow reading incorrect iphoned-images without iphone flag - 1.35 (2014-05-27) warnings, bugfixes, TGA optimization, etc + Full documentation under "DOCUMENTATION" below. + + + Revision 2.00 release notes: + + - Progressive JPEG is now supported. + + - PPM and PGM binary formats are now supported, thanks to Ken Miller. + + - x86 platforms now make use of SSE2 SIMD instructions for + JPEG decoding, and ARM platforms can use NEON SIMD if requested. + This work was done by Fabian "ryg" Giesen. SSE2 is used by + default, but NEON must be enabled explicitly; see docs. + + With other JPEG optimizations included in this version, we see + 2x speedup on a JPEG on an x86 machine, and a 1.5x speedup + on a JPEG on an ARM machine, relative to previous versions of this + library. The same results will not obtain for all JPGs and for all + x86/ARM machines. (Note that progressive JPEGs are significantly + slower to decode than regular JPEGs.) This doesn't mean that this + is the fastest JPEG decoder in the land; rather, it brings it + closer to parity with standard libraries. If you want the fastest + decode, look elsewhere. (See "Philosophy" section of docs below.) + + See final bullet items below for more info on SIMD. + + - Added STBI_MALLOC, STBI_REALLOC, and STBI_FREE macros for replacing + the memory allocator. Unlike other STBI libraries, these macros don't + support a context parameter, so if you need to pass a context in to + the allocator, you'll have to store it in a global or a thread-local + variable. + + - Split existing STBI_NO_HDR flag into two flags, STBI_NO_HDR and + STBI_NO_LINEAR. + STBI_NO_HDR: suppress implementation of .hdr reader format + STBI_NO_LINEAR: suppress high-dynamic-range light-linear float API + + - You can suppress implementation of any of the decoders to reduce + your code footprint by #defining one or more of the following + symbols before creating the implementation. + + STBI_NO_JPEG + STBI_NO_PNG + STBI_NO_BMP + STBI_NO_PSD + STBI_NO_TGA + STBI_NO_GIF + STBI_NO_HDR + STBI_NO_PIC + STBI_NO_PNM (.ppm and .pgm) + + - You can request *only* certain decoders and suppress all other ones + (this will be more forward-compatible, as addition of new decoders + doesn't require you to disable them explicitly): + + STBI_ONLY_JPEG + STBI_ONLY_PNG + STBI_ONLY_BMP + STBI_ONLY_PSD + STBI_ONLY_TGA + STBI_ONLY_GIF + STBI_ONLY_HDR + STBI_ONLY_PIC + STBI_ONLY_PNM (.ppm and .pgm) + + Note that you can define multiples of these, and you will get all + of them ("only x" and "only y" is interpreted to mean "only x&y"). + + - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still + want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB + + - Compilation of all SIMD code can be suppressed with + #define STBI_NO_SIMD + It should not be necessary to disable SIMD unless you have issues + compiling (e.g. using an x86 compiler which doesn't support SSE + intrinsics or that doesn't support the method used to detect + SSE2 support at run-time), and even those can be reported as + bugs so I can refine the built-in compile-time checking to be + smarter. + + - The old STBI_SIMD system which allowed installing a user-defined + IDCT etc. has been removed. If you need this, don't upgrade. My + assumption is that almost nobody was doing this, and those who + were will find the built-in SIMD more satisfactory anyway. + + - RGB values computed for JPEG images are slightly different from + previous versions of stb_image. (This is due to using less + integer precision in SIMD.) The C code has been adjusted so + that the same RGB values will be computed regardless of whether + SIMD support is available, so your app should always produce + consistent results. But these results are slightly different from + previous versions. (Specifically, about 3% of available YCbCr values + will compute different RGB results from pre-1.49 versions by +-1; + most of the deviating values are one smaller in the G channel.) + + - If you must produce consistent results with previous versions of + stb_image, #define STBI_JPEG_OLD and you will get the same results + you used to; however, you will not get the SIMD speedups for + the YCbCr-to-RGB conversion step (although you should still see + significant JPEG speedup from the other changes). + + Please note that STBI_JPEG_OLD is a temporary feature; it will be + removed in future versions of the library. It is only intended for + near-term back-compatibility use. + + + Latest revision history: + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPEG, including x86 SSE2 & ARM NEON SIMD + progressive JPEG + PGM/PPM support + STBI_MALLOC,STBI_REALLOC,STBI_FREE + STBI_NO_*, STBI_ONLY_* + GIF bugfix + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support (both grayscale and paletted) + optimize PNG + fix bug in interlaced PNG with user-specified channel count + 1.46 (2014-08-26) fix broken tRNS chunk in non-paletted PNG + 1.45 (2014-08-16) workaround MSVC-ARM internal compiler error by wrapping malloc See end of file for full revision history. - TODO: - stbi_info support for BMP,PSD,HDR,PIC - ============================ Contributors ========================= - + Image formats Bug fixes & warning fixes Sean Barrett (jpeg, png, bmp) Marc LeBlanc Nicolas Schulz (hdr, psd) Christpher Lloyd @@ -56,42 +169,52 @@ Jean-Marc Lienher (gif) Won Chun Tom Seddon (pic) the Horde3D community Thatcher Ulrich (psd) Janez Zemva - Jonathan Blow + Ken Miller (pgm, ppm) Jonathan Blow Laurent Gomila - Extensions, features Aruelien Pocheville - Jetro Lauha (stbi_info) Ryamond Barbiero - James "moose2000" Brown (iPhone PNG) David Woo - Ben "Disch" Wenger (io callbacks) Roy Eltham - Martin "SpartanJ" Golini Luke Graham - Thomas Ruf + Aruelien Pocheville + Extensions, features Ryamond Barbiero + Jetro Lauha (stbi_info) David Woo + Martin "SpartanJ" Golini (stbi_info) Martin Golini + James "moose2000" Brown (iPhone PNG) Roy Eltham + Ben "Disch" Wenger (io callbacks) Luke Graham + Omar Cornut (1/2/4-bit PNG) Thomas Ruf John Bartholomew - Optimizations & bugfixes Ken Hamada - Fabian "ryg" Giesen Cort Stratton - Arseny Kapoulkine Blazej Dariusz Roszkowski - Thibault Reuille + Ken Hamada + Optimizations & bugfixes Cort Stratton + Fabian "ryg" Giesen Blazej Dariusz Roszkowski + Arseny Kapoulkine Thibault Reuille Paul Du Bois Guillaume George - Jerry Jansson - If your name should be here but Hayaki Saito - isn't, let Sean know. Johan Duparc + If your name should be here but Jerry Jansson + isn't, let Sean know. Hayaki Saito + Johan Duparc Ronny Chevalier Michal Cichon + Tero Hanninen + +License: + This software is in the public domain. Where that dedication is not + recognized, you are granted a perpetual, irrevocable license to copy + and modify this file however you want. + */ #ifndef STBI_INCLUDE_STB_IMAGE_H #define STBI_INCLUDE_STB_IMAGE_H +// DOCUMENTATION +// // Limitations: -// - no jpeg progressive support -// - non-HDR formats support 8-bit samples only (jpeg, png) -// - no delayed line count (jpeg) -- IJG doesn't support either +// - no 16-bit-per-channel PNG +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding // - no 1-bit BMP // - GIF always returns *comp=4 // -// Basic usage (see HDR discussion below): +// Basic usage (see HDR discussion below for HDR usage): // int x,y,n; // unsigned char *data = stbi_load(filename, &x, &y, &n, 0); -// // ... process data if not NULL ... +// // ... process data if not NULL ... // // ... x = width, y = height, n = # 8-bit components per pixel ... // // ... replace '0' with '1'..'4' to force that many components per pixel // // ... but 'n' will always be the number that it would have been if you said 0 @@ -104,14 +227,16 @@ // int req_comp -- if non-zero, # of image components requested in result // // The return value from an image loader is an 'unsigned char *' which points -// to the pixel data. The pixel data consists of *y scanlines of *x pixels, +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, // with each pixel consisting of N interleaved 8-bit components; the first // pixel pointed to is top-left-most in the image. There is no padding between // image scanlines or between pixels, regardless of format. The number of // components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. // If req_comp is non-zero, *comp has the number of components that _would_ // have been output otherwise. E.g. if you set req_comp to 4, you will always -// get RGBA output, but you can check *comp to easily see if it's opaque. +// get RGBA output, but you can check *comp to see if it's trivially opaque +// because e.g. there were only 3 channels in the source image. // // An output image with N components has the following components interleaved // in this order in each pixel: @@ -133,18 +258,66 @@ // // =========================================================================== // -// iPhone PNG support: +// Philosophy // -// By default we convert iphone-formatted PNGs back to RGB; nominally they -// would silently load as BGR, except the existing code should have just -// failed on such iPhone PNGs. But you can disable this conversion by -// by calling stbi_convert_iphone_png_to_rgb(0), in which case -// you will always just get the native iphone "format" through. +// stb libraries are designed with the following priorities: // -// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per -// pixel to remove any premultiplied alpha *only* if the image file explicitly -// says there's premultiplied data (currently only happens in iPhone images, -// and only if iPhone convert-to-rgb processing is on). +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy to use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries do not emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// make more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// The output of the JPEG decoder is slightly different from versions where +// SIMD support was introduced (that is, for versions before 1.49). The +// difference is only +-1 in the 8-bit RGB channels, and only on a small +// fraction of pixels. You can force the pre-1.49 behavior by defining +// STBI_JPEG_OLD, but this will disable some of the SIMD decoding path +// and hence cost some performance. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. // // =========================================================================== // @@ -167,7 +340,7 @@ // (linear) floats to preserve the full dynamic range: // // float *data = stbi_loadf(filename, &x, &y, &n, 0); -// +// // If you load LDR images through this interface, those images will // be promoted to floating point values, run through the inverse of // constants corresponding to the above: @@ -184,17 +357,22 @@ // // =========================================================================== // -// I/O callbacks +// iPhone PNG support: // -// I/O callbacks allow you to read from arbitrary sources, like packaged -// files or some other source. Data read from callbacks are processed -// through a small internal buffer (currently 128 bytes) to try to reduce -// overhead. +// By default we convert iphone-formatted PNGs back to RGB, even though +// they are internally encoded differently. You can disable this conversion +// by by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through (which +// is BGR stored in RGB). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). // -// The three functions you must define are "read" (reads some bytes of data), -// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). #define STBI_NO_HDR // RaySan: not required by raylib +#define STBI_NO_SIMD // RaySan: issues when compiling with GCC 4.7.2 #ifndef STBI_NO_STDIO #include @@ -238,41 +416,43 @@ extern "C" { // load image by filename, open file, or memory buffer // -STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); - -#ifndef STBI_NO_STDIO -STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); -STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); -// for stbi_load_from_file, file pointer is left pointing immediately after image -#endif - typedef struct { - int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative int (*eof) (void *user); // returns nonzero if we are at end of file/data } stbi_io_callbacks; -STBIDEF stbi_uc *stbi_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *comp, int req_comp); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *comp, int req_comp); -#ifndef STBI_NO_HDR - STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif - #ifndef STBI_NO_STDIO - STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); - STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); - #endif - +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp); + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + #endif +#endif + +#ifndef STBI_NO_HDR STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif +#ifndef STBI_NO_LINEAR STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); STBIDEF void stbi_ldr_to_hdr_scale(float scale); #endif // STBI_NO_HDR -// stbi_is_hdr is always defined +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); #ifndef STBI_NO_STDIO @@ -283,7 +463,7 @@ STBIDEF int stbi_is_hdr_from_file(FILE *f); // get a VERY brief reason for failure // NOT THREADSAFE -STBIDEF const char *stbi_failure_reason (void); +STBIDEF const char *stbi_failure_reason (void); // free the loaded image -- this is just free() STBIDEF void stbi_image_free (void *retval_from_stbi_load); @@ -321,26 +501,6 @@ STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); -// define faster low-level operations (typically SIMD support) -#ifdef STBI_SIMD -typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize); -// compute an integer IDCT on "input" -// input[x] = data[x] * dequantize[x] -// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride' -// CLAMP results to 0..255 -typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step); -// compute a conversion from YCbCr to RGB -// 'count' pixels -// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B -// y: Y input channel -// cb: Cb input channel; scale/biased to be 0..255 -// cr: Cr input channel; scale/biased to be 0..255 - -STBIDEF void stbi_install_idct(stbi_idct_8x8 func); -STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); -#endif // STBI_SIMD - - #ifdef __cplusplus } #endif @@ -352,22 +512,62 @@ STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); #ifdef STB_IMAGE_IMPLEMENTATION -#ifndef STBI_NO_HDR +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) #include // ldexp -#include // strcmp, strtok #endif #ifndef STBI_NO_STDIO #include #endif -#include -#include + #ifndef STBI_ASSERT #include #define STBI_ASSERT(x) assert(x) #endif -#include -#include // ptrdiff_t on osx + #ifndef _MSC_VER #ifdef __cplusplus @@ -412,6 +612,86 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) #endif +#if defined(STBI_MALLOC) && defined(STBI_FREE) && defined(STBI_REALLOC) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,sz) realloc(p,sz) +#define STBI_FREE(p) free(p) +#endif + +#if !defined(STBI_NO_SIMD) && (defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +static int stbi__sse2_available() +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +static int stbi__sse2_available() +{ +#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 // GCC 4.8 or later + // GCC 4.8+ has a nice way to do this + return __builtin_cpu_supports("sse2"); +#else + // portable way to do this, preferably without using GCC inline ASM? + // just bail for now. + return 0; +#endif +} +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + /////////////////////////////////////////////// // // stbi__context struct and start_xxx functions @@ -422,7 +702,7 @@ typedef struct { stbi__uint32 img_x, img_y; int img_n, img_out_n; - + stbi_io_callbacks io; void *io_user_data; @@ -498,29 +778,59 @@ static void stbi__rewind(stbi__context *s) s->img_buffer = s->img_buffer_original; } +#ifndef STBI_NO_JPEG static int stbi__jpeg_test(stbi__context *s); static stbi_uc *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG static int stbi__png_test(stbi__context *s); static stbi_uc *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_BMP static int stbi__bmp_test(stbi__context *s); static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA static int stbi__tga_test(stbi__context *s); static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD static int stbi__psd_test(stbi__context *s); static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +#endif + #ifndef STBI_NO_HDR static int stbi__hdr_test(stbi__context *s); static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); #endif + +#ifndef STBI_NO_PIC static int stbi__pic_test(stbi__context *s); static stbi_uc *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF static int stbi__gif_test(stbi__context *s); static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +#endif // this is not threadsafe static const char *stbi__g_failure_reason; @@ -538,7 +848,7 @@ static int stbi__err(const char *str) static void *stbi__malloc(size_t size) { - return malloc(size); + return STBI_MALLOC(size); } // stbi__err - error @@ -558,22 +868,40 @@ static void *stbi__malloc(size_t size) STBIDEF void stbi_image_free(void *retval_from_stbi_load) { - free(retval_from_stbi_load); + STBI_FREE(retval_from_stbi_load); } -#ifndef STBI_NO_HDR +#ifndef STBI_NO_LINEAR static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); #endif static unsigned char *stbi_load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) { + #ifndef STBI_NO_JPEG if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PNG if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_BMP if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_GIF if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PSD if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PIC if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp); + #endif #ifndef STBI_NO_HDR if (stbi__hdr_test(s)) { @@ -582,15 +910,18 @@ static unsigned char *stbi_load_main(stbi__context *s, int *x, int *y, int *comp } #endif + #ifndef STBI_NO_TGA // test tga last because it's a crappy test! if (stbi__tga_test(s)) return stbi__tga_load(s,x,y,comp,req_comp); + #endif + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); } #ifndef STBI_NO_STDIO -FILE *stbi__fopen(char const *filename, char const *mode) +static FILE *stbi__fopen(char const *filename, char const *mode) { FILE *f; #if defined(_MSC_VER) && _MSC_VER >= 1400 @@ -603,7 +934,7 @@ FILE *stbi__fopen(char const *filename, char const *mode) } -STBIDEF unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) { FILE *f = stbi__fopen(filename, "rb"); unsigned char *result; @@ -613,7 +944,7 @@ STBIDEF unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp return result; } -STBIDEF unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) { unsigned char *result; stbi__context s; @@ -627,23 +958,22 @@ STBIDEF unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, i } #endif //!STBI_NO_STDIO -STBIDEF unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) { stbi__context s; stbi__start_mem(&s,buffer,len); return stbi_load_main(&s,x,y,comp,req_comp); } -unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); return stbi_load_main(&s,x,y,comp,req_comp); } -#ifndef STBI_NO_HDR - -float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +#ifndef STBI_NO_LINEAR +static float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) { unsigned char *data; #ifndef STBI_NO_HDR @@ -656,14 +986,14 @@ float *stbi_loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); } -float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) { stbi__context s; stbi__start_mem(&s,buffer,len); return stbi_loadf_main(&s,x,y,comp,req_comp); } -float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) { stbi__context s; stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); @@ -671,7 +1001,7 @@ float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int } #ifndef STBI_NO_STDIO -float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) { float *result; FILE *f = stbi__fopen(filename, "rb"); @@ -681,7 +1011,7 @@ float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) return result; } -float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) { stbi__context s; stbi__start_file(&s,f); @@ -689,13 +1019,13 @@ float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) } #endif // !STBI_NO_STDIO -#endif // !STBI_NO_HDR +#endif // !STBI_NO_LINEAR -// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is -// defined, for API simplicity; if STBI_NO_HDR is defined, it always +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always // reports false! -int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) { #ifndef STBI_NO_HDR stbi__context s; @@ -743,17 +1073,17 @@ STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void #endif } -#ifndef STBI_NO_HDR static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; -void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } -void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } - -void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } -void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#ifndef STBI_NO_LINEAR +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } #endif +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + ////////////////////////////////////////////////////////////////////////////// // @@ -762,9 +1092,9 @@ void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } enum { - SCAN_load=0, - SCAN_type, - SCAN_header + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header }; static void stbi__refill_buffer(stbi__context *s) @@ -803,7 +1133,7 @@ stbi_inline static int stbi__at_eof(stbi__context *s) if (s->read_from_callbacks == 0) return 1; } - return s->img_buffer >= s->img_buffer_end; + return s->img_buffer >= s->img_buffer_end; } static void stbi__skip(stbi__context *s, int n) @@ -827,7 +1157,7 @@ static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) int res, count; memcpy(buffer, s->img_buffer, blen); - + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); res = (count == (n-blen)); s->img_buffer = s->img_buffer_end; @@ -867,6 +1197,9 @@ static stbi__uint32 stbi__get32le(stbi__context *s) return z + (stbi__get16le(s) << 16); } +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + + ////////////////////////////////////////////////////////////////////////////// // // generic converter from built-in img_n to req_comp @@ -893,7 +1226,7 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r good = (unsigned char *) stbi__malloc(req_comp * x * y); if (good == NULL) { - free(data); + STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } @@ -923,16 +1256,16 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int r #undef CASE } - free(data); + STBI_FREE(data); return good; } -#ifndef STBI_NO_HDR +#ifndef STBI_NO_LINEAR static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) { int i,k,n; float *output = (float *) stbi__malloc(x * y * comp * sizeof(float)); - if (output == NULL) { free(data); return stbi__errpf("outofmem", "Out of memory"); } + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } // compute number of non-alpha components if (comp & 1) n = comp; else n = comp-1; for (i=0; i < x*y; ++i) { @@ -941,16 +1274,18 @@ static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) } if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; } - free(data); + STBI_FREE(data); return output; } +#endif +#ifndef STBI_NO_HDR #define stbi__float2int(x) ((int) (x)) static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) { int i,k,n; stbi_uc *output = (stbi_uc *) stbi__malloc(x * y * comp); - if (output == NULL) { free(data); return stbi__errpuc("outofmem", "Out of memory"); } + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } // compute number of non-alpha components if (comp & 1) n = comp; else n = comp-1; for (i=0; i < x*y; ++i) { @@ -967,17 +1302,16 @@ static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) output[i*comp + k] = (stbi_uc) stbi__float2int(z); } } - free(data); + STBI_FREE(data); return output; } #endif ////////////////////////////////////////////////////////////////////////////// // -// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation) +// "baseline" JPEG/JFIF decoder // // simple implementation -// - channel subsampling of at most 2 in each dimension // - doesn't support delayed output of y-dimension // - simple interface (only one output format: 8-bit interleaved RGB) // - doesn't try to recover corrupt jpegs @@ -991,13 +1325,10 @@ static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) // - quality integer IDCT derived from IJG's 'slow' // performance // - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON // - uses a lot of intermediate memory, could cache poorly -// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4 -// stb_jpeg: 1.34 seconds (MSVC6, default release build) -// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro) -// IJL11.dll: 1.08 seconds (compiled by intel) -// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG) -// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro) + +#ifndef STBI_NO_JPEG // huffman decoding acceleration #define FAST_BITS 9 // larger handles more cases; smaller stomps less cache @@ -1015,13 +1346,11 @@ typedef struct typedef struct { - #ifdef STBI_SIMD - unsigned short dequant2[4][64]; - #endif stbi__context *s; stbi__huffman huff_dc[4]; stbi__huffman huff_ac[4]; stbi_uc dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; // sizes for components, interleaved MCUs int img_h_max, img_v_max; @@ -1039,17 +1368,31 @@ typedef struct int x,y,w2,h2; stbi_uc *data; - void *raw_data; + void *raw_data, *raw_coeff; stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks } img_comp[4]; - stbi__uint32 code_buffer; // jpeg entropy-coded buffer + stbi__uint32 code_buffer; // jpeg entropy-coded buffer int code_bits; // number of valid bits unsigned char marker; // marker seen while filling entropy buffer int nomore; // flag if we saw a marker so must stop + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int scan_n, order[4]; int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); } stbi__jpeg; static int stbi__build_huffman(stbi__huffman *h, int *count) @@ -1093,6 +1436,33 @@ static int stbi__build_huffman(stbi__huffman *h, int *count) return 1; } +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (-1 << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits)); + } + } + } +} + static void stbi__grow_buffer_unsafe(stbi__jpeg *j) { do { @@ -1163,31 +1533,45 @@ stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) return h->values[c]; } +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); - #if 1 + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB k = stbi_lrot(j->code_buffer, n); j->code_buffer = k & ~stbi__bmask[n]; k &= stbi__bmask[n]; j->code_bits -= n; - #else - k = (j->code_buffer >> (32 - n)) & stbi__bmask[n]; + return k + (stbi__jbias[n] & ~sgn); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; j->code_bits -= n; - j->code_buffer <<= n; - #endif - // the following test is probably a random branch that won't - // predict well. I tried to table accelerate it but failed. - // maybe it's compiling as a conditional move? - if (k < m) - return (-1 << n) + k + 1; - else - return k; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; } // given a value that's at position X in the zigzag stream, @@ -1208,10 +1592,13 @@ static stbi_uc stbi__jpeg_dezigzag[64+15] = }; // decode one 64-entry block-- -static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, int b) +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi_uc *dequant) { int diff,dc,k; - int t = stbi__jpeg_huff_decode(j, hdc); + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); // 0 all the ac values now so we can do it 32-bits at a time @@ -1220,28 +1607,195 @@ static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman diff = t ? stbi__extend_receive(j, t) : 0; dc = j->img_comp[b].dc_pred + diff; j->img_comp[b].dc_pred = dc; - data[0] = (short) dc; + data[0] = (short) (dc * dequant[0]); // decode AC components, see JPEG spec k = 1; do { - int r,s; - int rs = stbi__jpeg_huff_decode(j, hac); - if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); - s = rs & 15; - r = rs >> 4; - if (s == 0) { - if (rs != 0xf0) break; // end block - k += 16; - } else { - k += r; + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; // decode into unzigzag'd location - data[stbi__jpeg_dezigzag[k++]] = (short) stbi__extend_receive(j,s); + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } } } while (k < 64); return 1; } +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc << j->succ_low); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) << shift); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) << shift); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + { + if ((*p & bit)==0) + { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else + r = 16; // r=15 is the code for 16 0s + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + { + if ((*p & bit)==0) + { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + ++k; + } else { + if (r == 0) { + if (s) + data[stbi__jpeg_dezigzag[k++]] = s; + break; + } + --r; + ++k; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + // take a -128..127 value and stbi__clamp it and convert to 0..255 stbi_inline static stbi_uc stbi__clamp(int x) { @@ -1253,21 +1807,21 @@ stbi_inline static stbi_uc stbi__clamp(int x) return (stbi_uc) x; } -#define stbi__f2f(x) (int) (((x) * 4096 + 0.5)) +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) #define stbi__fsh(x) ((x) << 12) // derived from jidctint -- DCT_ISLOW -#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ p2 = s2; \ p3 = s6; \ - p1 = (p2+p3) * stbi__f2f(0.5411961f); \ - t2 = p1 + p3*stbi__f2f(-1.847759065f); \ - t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ p2 = s0; \ p3 = s4; \ - t0 = stbi__fsh(p2+p3); \ - t1 = stbi__fsh(p2-p3); \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ x0 = t0+t3; \ x3 = t0-t3; \ x1 = t1+t2; \ @@ -1280,36 +1834,28 @@ stbi_inline static stbi_uc stbi__clamp(int x) p4 = t1+t3; \ p1 = t0+t3; \ p2 = t1+t2; \ - p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ - t0 = t0*stbi__f2f( 0.298631336f); \ - t1 = t1*stbi__f2f( 2.053119869f); \ - t2 = t2*stbi__f2f( 3.072711026f); \ - t3 = t3*stbi__f2f( 1.501321110f); \ - p1 = p5 + p1*stbi__f2f(-0.899976223f); \ - p2 = p5 + p2*stbi__f2f(-2.562915447f); \ - p3 = p3*stbi__f2f(-1.961570560f); \ - p4 = p4*stbi__f2f(-0.390180644f); \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ t3 += p1+p4; \ t2 += p2+p3; \ t1 += p2+p4; \ t0 += p1+p3; -#ifdef STBI_SIMD -typedef unsigned short stbi_dequantize_t; -#else -typedef stbi_uc stbi_dequantize_t; -#endif - -// .344 seconds on 3*anemones.jpg -static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64], stbi_dequantize_t *dequantize) +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) { int i,val[64],*v=val; - stbi_dequantize_t *dq = dequantize; stbi_uc *o; short *d = data; // columns - for (i=0; i < 8; ++i,++d,++dq, ++v) { + for (i=0; i < 8; ++i,++d, ++v) { // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 && d[40]==0 && d[48]==0 && d[56]==0) { @@ -1317,11 +1863,10 @@ static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64], stbi_ // (1|2|3|4|5|6|7)==0 0 seconds // all separate -0.047 seconds // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds - int dcterm = d[0] * dq[0] << 2; + int dcterm = d[0] << 2; v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; } else { - STBI__IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24], - d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56]) + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) // constants scaled things up by 1<<12; let's bring them back // down, but keep 2 extra bits of precision x0 += 512; x1 += 512; x2 += 512; x3 += 512; @@ -1362,14 +1907,394 @@ static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64], stbi_ } } -#ifdef STBI_SIMD -static stbi_idct_8x8 stbi__idct_installed = stbi__idct_block; - -STBIDEF void stbi_install_idct(stbi_idct_8x8 func) +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) { - stbi__idct_installed = func; + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass } -#endif + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON #define STBI__MARKER_none 0xff // if there's a pending marker from the entropy stream, return that @@ -1400,6 +2325,7 @@ static void stbi__jpeg_reset(stbi__jpeg *j) j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; j->marker = STBI__MARKER_none; j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, // since we don't even allow 1<<30 pixels } @@ -1407,73 +2333,152 @@ static void stbi__jpeg_reset(stbi__jpeg *j) static int stbi__parse_entropy_coded_data(stbi__jpeg *z) { stbi__jpeg_reset(z); - if (z->scan_n == 1) { - int i,j; - #ifdef STBI_SIMD - __declspec(align(16)) - #endif - short data[64]; - int n = z->order[0]; - // non-interleaved data, we just need to process one block at a time, - // in trivial scanline order - // number of blocks to do just depends on how many actual "pixels" this - // component has, independent of interleaved MCU blocking and such - int w = (z->img_comp[n].x+7) >> 3; - int h = (z->img_comp[n].y+7) >> 3; - for (j=0; j < h; ++j) { - for (i=0; i < w; ++i) { - if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; - #ifdef STBI_SIMD - stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); - #else - stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); - #endif - // every data block is an MCU, so countdown the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - // if it's NOT a restart, then just bail, so we get corrupt data - // rather than no data - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); - } - } - } - } else { // interleaved! - int i,j,k,x,y; - short data[64]; - for (j=0; j < z->img_mcu_y; ++j) { - for (i=0; i < z->img_mcu_x; ++i) { - // scan an interleaved mcu... process scan_n components in order - for (k=0; k < z->scan_n; ++k) { - int n = z->order[k]; - // scan out an mcu's worth of this component; that's just determined - // by the basic H and V specified for the component - for (y=0; y < z->img_comp[n].v; ++y) { - for (x=0; x < z->img_comp[n].h; ++x) { - int x2 = (i*z->img_comp[n].h + x)*8; - int y2 = (j*z->img_comp[n].v + y)*8; - if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; - #ifdef STBI_SIMD - stbi__idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); - #else - stbi__idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); - #endif - } + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); } } - // after all interleaved components, that's an interleaved MCU, - // so now count down the restart interval - if (--z->todo <= 0) { - if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); - // if it's NOT a restart, then just bail, so we get corrupt data - // rather than no data - if (!STBI__RESTART(z->marker)) return 1; - stbi__jpeg_reset(z); + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + //int ha = z->img_comp[n].ha; // RaySan: Unused, commented to avoid warning + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi_uc *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); } } } } - return 1; } static int stbi__process_marker(stbi__jpeg *z, int m) @@ -1483,9 +2488,6 @@ static int stbi__process_marker(stbi__jpeg *z, int m) case STBI__MARKER_none: // no marker found return stbi__err("expected marker","Corrupt JPEG"); - case 0xC2: // stbi__SOF - progressive - return stbi__err("progressive jpeg","JPEG format not supported (progressive)"); - case 0xDD: // DRI - specify restart interval if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); z->restart_interval = stbi__get16be(z->s); @@ -1501,10 +2503,6 @@ static int stbi__process_marker(stbi__jpeg *z, int m) if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); for (i=0; i < 64; ++i) z->dequant[t][stbi__jpeg_dezigzag[i]] = stbi__get8(z->s); - #ifdef STBI_SIMD - for (i=0; i < 64; ++i) - z->dequant2[t][i] = z->dequant[t][i]; - #endif L -= 65; } return L==0; @@ -1532,6 +2530,8 @@ static int stbi__process_marker(stbi__jpeg *z, int m) } for (i=0; i < n; ++i) v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); L -= n; } return L==0; @@ -1544,28 +2544,42 @@ static int stbi__process_marker(stbi__jpeg *z, int m) return 0; } -// after we see stbi__SOS +// after we see SOS static int stbi__process_scan_header(stbi__jpeg *z) { int i; int Ls = stbi__get16be(z->s); z->scan_n = stbi__get8(z->s); - if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad stbi__SOS component count","Corrupt JPEG"); - if (Ls != 6+2*z->scan_n) return stbi__err("bad stbi__SOS len","Corrupt JPEG"); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); for (i=0; i < z->scan_n; ++i) { int id = stbi__get8(z->s), which; int q = stbi__get8(z->s); for (which = 0; which < z->s->img_n; ++which) if (z->img_comp[which].id == id) break; - if (which == z->s->img_n) return 0; + if (which == z->s->img_n) return 0; // no match z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); z->order[i] = which; } - if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG"); - stbi__get8(z->s); // should be 63, but might be 0 - if (stbi__get8(z->s) != 0) return stbi__err("bad stbi__SOS","Corrupt JPEG"); + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } return 1; } @@ -1574,8 +2588,8 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan) { stbi__context *s = z->s; int Lf,p,i,q, h_max=1,v_max=1,c; - Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad stbi__SOF len","Corrupt JPEG"); // JPEG - p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires c = stbi__get8(s); @@ -1586,7 +2600,7 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan) z->img_comp[i].linebuf = NULL; } - if (Lf != 8+3*s->img_n) return stbi__err("bad stbi__SOF len","Corrupt JPEG"); + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); for (i=0; i < s->img_n; ++i) { z->img_comp[i].id = stbi__get8(s); @@ -1599,7 +2613,7 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan) z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); } - if (scan != SCAN_load) return 1; + if (scan != STBI__SCAN_load) return 1; if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); @@ -1627,54 +2641,68 @@ static int stbi__process_frame_header(stbi__jpeg *z, int scan) z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; z->img_comp[i].raw_data = stbi__malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); + if (z->img_comp[i].raw_data == NULL) { for(--i; i >= 0; --i) { - free(z->img_comp[i].raw_data); + STBI_FREE(z->img_comp[i].raw_data); z->img_comp[i].data = NULL; } return stbi__err("outofmem", "Out of memory"); } - // align blocks for installable-idct using mmx/sse + // align blocks for idct using mmx/sse z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); z->img_comp[i].linebuf = NULL; + if (z->progressive) { + z->img_comp[i].coeff_w = (z->img_comp[i].w2 + 7) >> 3; + z->img_comp[i].coeff_h = (z->img_comp[i].h2 + 7) >> 3; + z->img_comp[i].raw_coeff = STBI_MALLOC(z->img_comp[i].coeff_w * z->img_comp[i].coeff_h * 64 * sizeof(short) + 15); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } else { + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + } } return 1; } -// use comparisons since in some cases we handle more than one case (e.g. stbi__SOF) +// use comparisons since in some cases we handle more than one case (e.g. SOF) #define stbi__DNL(x) ((x) == 0xdc) #define stbi__SOI(x) ((x) == 0xd8) #define stbi__EOI(x) ((x) == 0xd9) -#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) #define stbi__SOS(x) ((x) == 0xda) -static int decode_jpeg_header(stbi__jpeg *z, int scan) +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) { int m; z->marker = STBI__MARKER_none; // initialize cached marker to empty m = stbi__get_marker(z); - if (!stbi__SOI(m)) return stbi__err("no stbi__SOI","Corrupt JPEG"); - if (scan == SCAN_type) return 1; + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; m = stbi__get_marker(z); while (!stbi__SOF(m)) { if (!stbi__process_marker(z,m)) return 0; m = stbi__get_marker(z); while (m == STBI__MARKER_none) { // some files have extra padding after their blocks, so ok, we'll scan - if (stbi__at_eof(z->s)) return stbi__err("no stbi__SOF", "Corrupt JPEG"); + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); m = stbi__get_marker(z); } } + z->progressive = stbi__SOF_progressive(m); if (!stbi__process_frame_header(z, scan)) return 0; return 1; } -static int decode_jpeg_image(stbi__jpeg *j) +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) { int m; j->restart_interval = 0; - if (!decode_jpeg_header(j, SCAN_load)) return 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; m = stbi__get_marker(j); while (!stbi__EOI(m)) { if (stbi__SOS(m)) { @@ -1688,7 +2716,7 @@ static int decode_jpeg_image(stbi__jpeg *j) j->marker = stbi__get8(j->s); break; } else if (x != 0) { - return 0; + return stbi__err("junk before marker", "Corrupt JPEG"); } } // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 @@ -1698,6 +2726,8 @@ static int decode_jpeg_image(stbi__jpeg *j) } m = stbi__get_marker(j); } + if (j->progressive) + stbi__jpeg_finish(j); return 1; } @@ -1781,6 +2811,123 @@ static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc return out; } +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) { // resample with nearest-neighbor @@ -1792,10 +2939,10 @@ static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_ return out; } +#ifdef STBI_JPEG_OLD +// this is the same YCbCr-to-RGB calculation that stb_image has used +// historically before the algorithm changes in 1.49 #define float2fixed(x) ((int) ((x) * 65536 + 0.5)) - -// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro) -// VC6 without processor=Pro is generating multiple LEAs per multiply! static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) { int i; @@ -1820,16 +2967,196 @@ static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc out += step; } } - -#ifdef STBI_SIMD -static stbi_YCbCr_to_RGB_run stbi__YCbCr_installed = stbi__YCbCr_to_RGB_row; - -STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func) +#else +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) { - stbi__YCbCr_installed = func; + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* float2fixed(1.40200f); + g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } } #endif +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* float2fixed(1.40200f); + g = y_fixed + cr*-float2fixed(0.71414f) + ((cb*-float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + #ifndef STBI_JPEG_OLD + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + #endif + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + #ifndef STBI_JPEG_OLD + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + #endif + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} // clean up the temporary component buffers static void stbi__cleanup_jpeg(stbi__jpeg *j) @@ -1837,12 +3164,17 @@ static void stbi__cleanup_jpeg(stbi__jpeg *j) int i; for (i=0; i < j->s->img_n; ++i) { if (j->img_comp[i].raw_data) { - free(j->img_comp[i].raw_data); + STBI_FREE(j->img_comp[i].raw_data); j->img_comp[i].raw_data = NULL; j->img_comp[i].data = NULL; } + if (j->img_comp[i].raw_coeff) { + STBI_FREE(j->img_comp[i].raw_coeff); + j->img_comp[i].raw_coeff = 0; + j->img_comp[i].coeff = 0; + } if (j->img_comp[i].linebuf) { - free(j->img_comp[i].linebuf); + STBI_FREE(j->img_comp[i].linebuf); j->img_comp[i].linebuf = NULL; } } @@ -1853,7 +3185,7 @@ typedef struct resample_row_func resample; stbi_uc *line0,*line1; int hs,vs; // expansion factor in each axis - int w_lores; // horizontal pixels pre-expansion + int w_lores; // horizontal pixels pre-expansion int ystep; // how far through vertical expansion we are int ypos; // which pre-expansion row we're on } stbi__resample; @@ -1866,8 +3198,8 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp // validate req_comp if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); - // load a jpeg image from whichever source - if (!decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } // determine actual number of components to generate n = req_comp ? req_comp : z->s->img_n; @@ -1904,7 +3236,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; - else if (r->hs == 2 && r->vs == 2) r->resample = stbi__resample_row_hv_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; else r->resample = stbi__resample_row_generic; } @@ -1932,11 +3264,7 @@ static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp if (n >= 3) { stbi_uc *y = coutput[0]; if (z->s->img_n == 3) { - #ifdef STBI_SIMD - stbi__YCbCr_installed(out, y, coutput[1], coutput[2], z->s->img_x, n); - #else - stbi__YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n); - #endif + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); } else for (i=0; i < z->s->img_x; ++i) { out[0] = out[1] = out[2] = y[i]; @@ -1963,6 +3291,7 @@ static unsigned char *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *com { stbi__jpeg j; j.s = s; + stbi__setup_jpeg(&j); return load_jpeg_image(&j, x,y,comp,req_comp); } @@ -1971,14 +3300,15 @@ static int stbi__jpeg_test(stbi__context *s) int r; stbi__jpeg j; j.s = s; - r = decode_jpeg_header(&j, SCAN_type); + stbi__setup_jpeg(&j); + r = stbi__decode_jpeg_header(&j, STBI__SCAN_type); stbi__rewind(s); return r; } static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) { - if (!decode_jpeg_header(j, SCAN_header)) { + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { stbi__rewind( j->s ); return 0; } @@ -1994,6 +3324,7 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) j.s = s; return stbi__jpeg_info_raw(&j, x, y, comp); } +#endif // public domain zlib decode v0.2 Sean Barrett 2006-11-18 // simple implementation @@ -2002,6 +3333,8 @@ static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) // performance // - fast huffman +#ifndef STBI_NO_ZLIB + // fast-way is faster to check than jpeg huffman, but slow way is slower #define STBI__ZFAST_BITS 9 // accelerate all cases in default tables #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) @@ -2015,7 +3348,7 @@ typedef struct int maxcode[17]; stbi__uint16 firstsymbol[16]; stbi_uc size[288]; - stbi__uint16 value[288]; + stbi__uint16 value[288]; } stbi__zhuffman; stbi_inline static int stbi__bitreverse16(int n) @@ -2042,8 +3375,8 @@ static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num) // DEFLATE spec for generating codes memset(sizes, 0, sizeof(sizes)); - memset(z->fast, 255, sizeof(z->fast)); - for (i=0; i < num; ++i) + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) ++sizes[sizelist[i]]; sizes[0] = 0; for (i=1; i < 16; ++i) @@ -2065,12 +3398,13 @@ static int stbi__zbuild_huffman(stbi__zhuffman *z, stbi_uc *sizelist, int num) int s = sizelist[i]; if (s) { int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); z->size [c] = (stbi_uc ) s; z->value[c] = (stbi__uint16) i; if (s <= STBI__ZFAST_BITS) { int k = stbi__bit_reverse(next_code[s],s); while (k < (1 << STBI__ZFAST_BITS)) { - z->fast[k] = (stbi__uint16) c; + z->fast[k] = fastv; k += (1 << s); } } @@ -2122,21 +3456,12 @@ stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) k = z->code_buffer & ((1 << n) - 1); z->code_buffer >>= n; z->num_bits -= n; - return k; + return k; } -stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) { int b,s,k; - if (a->num_bits < 16) stbi__fill_bits(a); - b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; - if (b < 0xffff) { - s = z->size[b]; - a->code_buffer >>= s; - a->num_bits -= s; - return z->value[b]; - } - // not resolved by fast table, so compute it the slow way // use jpeg approach, which requires MSbits at top k = stbi__bit_reverse(a->code_buffer, 16); @@ -2152,16 +3477,31 @@ stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) return z->value[b]; } -static int stbi__zexpand(stbi__zbuf *z, int n) // need to make room for n bytes +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) stbi__fill_bits(a); + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes { char *q; int cur, limit; + z->zout = zout; if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); cur = (int) (z->zout - z->zout_start); limit = (int) (z->zout_end - z->zout_start); while (cur + n > limit) limit *= 2; - q = (char *) realloc(z->zout_start, limit); + q = (char *) STBI_REALLOC(z->zout_start, limit); if (q == NULL) return stbi__err("outofmem", "Out of memory"); z->zout_start = q; z->zout = q + cur; @@ -2174,7 +3514,7 @@ static int stbi__zlength_base[31] = { 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 }; -static int stbi__zlength_extra[31]= +static int stbi__zlength_extra[31]= { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, @@ -2185,16 +3525,23 @@ static int stbi__zdist_extra[32] = static int stbi__parse_huffman_block(stbi__zbuf *a) { + char *zout = a->zout; for(;;) { int z = stbi__zhuffman_decode(a, &a->z_length); if (z < 256) { if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes - if (a->zout >= a->zout_end) if (!stbi__zexpand(a, 1)) return 0; - *a->zout++ = (char) z; + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; } else { stbi_uc *p; int len,dist; - if (z == 256) return 1; + if (z == 256) { + a->zout = zout; + return 1; + } z -= 257; len = stbi__zlength_base[z]; if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); @@ -2202,11 +3549,18 @@ static int stbi__parse_huffman_block(stbi__zbuf *a) if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); dist = stbi__zdist_base[z]; if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); - if (a->zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); - if (a->zout + len > a->zout_end) if (!stbi__zexpand(a, len)) return 0; - p = (stbi_uc *) (a->zout - dist); - while (len--) - *a->zout++ = *p++; + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + do *zout++ = v; while (--len); + } else { + do *zout++ = *p++; while (--len); + } } } } @@ -2279,7 +3633,7 @@ static int stbi__parse_uncomperssed_block(stbi__zbuf *a) if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); if (a->zout + len > a->zout_end) - if (!stbi__zexpand(a, len)) return 0; + if (!stbi__zexpand(a, a->zout, len)) return 0; memcpy(a->zout, a->zbuffer, len); a->zbuffer += len; a->zout += len; @@ -2362,7 +3716,7 @@ STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; } else { - free(a.zout_start); + STBI_FREE(a.zout_start); return NULL; } } @@ -2383,7 +3737,7 @@ STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, i if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; } else { - free(a.zout_start); + STBI_FREE(a.zout_start); return NULL; } } @@ -2410,7 +3764,7 @@ STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int if (outlen) *outlen = (int) (a.zout - a.zout_start); return a.zout_start; } else { - free(a.zout_start); + STBI_FREE(a.zout_start); return NULL; } } @@ -2425,6 +3779,7 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char else return -1; } +#endif // public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 // simple implementation @@ -2436,15 +3791,13 @@ STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char // performance // - uses stb_zlib, a PD zlib implementation with fast huffman decoding - +#ifndef STBI_NO_PNG typedef struct { stbi__uint32 length; stbi__uint32 type; } stbi__pngchunk; -#define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) - static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) { stbi__pngchunk c; @@ -2470,13 +3823,23 @@ typedef struct enum { - STBI__F_none=0, STBI__F_sub=1, STBI__F_up=2, STBI__F_avg=3, STBI__F_paeth=4, - STBI__F_avg_first, STBI__F_paeth_first + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first }; static stbi_uc first_row_filter[5] = { - STBI__F_none, STBI__F_sub, STBI__F_none, STBI__F_avg_first, STBI__F_paeth_first + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first }; static int stbi__paeth(int a, int b, int c) @@ -2490,32 +3853,50 @@ static int stbi__paeth(int a, int b, int c) return c; } -#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings +static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; // create the png data from post-deflated data -static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y) +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) { stbi__context *s = a->s; stbi__uint32 i,j,stride = x*out_n; + stbi__uint32 img_len, img_width_bytes; int k; int img_n = s->img_n; // copy it into a local for later + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); - a->out = (stbi_uc *) stbi__malloc(x * y * out_n); + a->out = (stbi_uc *) stbi__malloc(x * y * out_n); // extra bytes to write off the end into if (!a->out) return stbi__err("outofmem", "Out of memory"); + + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; if (s->img_x == x && s->img_y == y) { - if (raw_len != (img_n * x + 1) * y) return stbi__err("not enough pixels","Corrupt PNG"); + if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt PNG"); } else { // interlaced: - if (raw_len < (img_n * x + 1) * y) return stbi__err("not enough pixels","Corrupt PNG"); + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); } + for (j=0; j < y; ++j) { stbi_uc *cur = a->out + stride*j; stbi_uc *prior = cur - stride; int filter = *raw++; - if (filter > 4) return stbi__err("invalid filter","Corrupt PNG"); + int filter_bytes = img_n; + int width = x; + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + STBI_ASSERT(img_width_bytes <= x); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + // if first row, use special filter that doesn't sample previous row if (j == 0) filter = first_row_filter[filter]; - // handle first pixel explicitly - for (k=0; k < img_n; ++k) { + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { switch (filter) { case STBI__F_none : cur[k] = raw[k]; break; case STBI__F_sub : cur[k] = raw[k]; break; @@ -2526,26 +3907,37 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r case STBI__F_paeth_first: cur[k] = raw[k]; break; } } - if (img_n != out_n) cur[img_n] = 255; - raw += img_n; - cur += out_n; - prior += out_n; + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else { + raw += 1; + cur += 1; + prior += 1; + } + // this is a little gross, so that we don't switch per-pixel or per-component - if (img_n == out_n) { + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*img_n; #define CASE(f) \ case f: \ - for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \ - for (k=0; k < img_n; ++k) + for (k=0; k < nk; ++k) switch (filter) { - CASE(STBI__F_none) cur[k] = raw[k]; break; - CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-img_n]); break; + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + CASE(STBI__F_sub) cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); break; CASE(STBI__F_up) cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; - CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-img_n])>>1)); break; - CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; - CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-img_n] >> 1)); break; - CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-img_n],0,0)); break; + CASE(STBI__F_avg) cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); break; + CASE(STBI__F_paeth) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); break; + CASE(STBI__F_avg_first) cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); break; + CASE(STBI__F_paeth_first) cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); break; } #undef CASE + raw += nk; } else { STBI_ASSERT(img_n+1 == out_n); #define CASE(f) \ @@ -2564,15 +3956,90 @@ static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 r #undef CASE } } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + // insert alpha = 255 + stbi_uc *cur = a->out + stride*j; + int i; + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + cur[i*2+1] = 255; + cur[i*2+0] = cur[i]; + } + } else { + assert(img_n == 3); + for (i=x-1; i >= 0; --i) { + cur[i*4+3] = 255; + cur[i*4+2] = cur[i*3+2]; + cur[i*4+1] = cur[i*3+1]; + cur[i*4+0] = cur[i*3+0]; + } + } + } + } + } + return 1; } -static int stbi__create_png_image(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, int interlaced) +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) { stbi_uc *final; int p; if (!interlaced) - return stbi__create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y); + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); // de-interlacing final = (stbi_uc *) stbi__malloc(a->s->img_x * a->s->img_y * out_n); @@ -2586,17 +4053,22 @@ static int stbi__create_png_image(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_l x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; if (x && y) { - if (!stbi__create_png_image_raw(a, raw, raw_len, out_n, x, y)) { - free(final); + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); return 0; } - for (j=0; j < y; ++j) - for (i=0; i < x; ++i) - memcpy(final + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n, + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_n + out_x*out_n, a->out + (j*x+i)*out_n, out_n); - free(a->out); - raw += (x*out_n+1)*y; - raw_len -= (x*out_n+1)*y; + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; } } a->out = final; @@ -2658,7 +4130,7 @@ static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int p += 4; } } - free(a->out); + STBI_FREE(a->out); a->out = temp_out; STBI_NOTUSED(len); @@ -2706,7 +4178,7 @@ static void stbi__de_iphone(stbi__png *z) } else { p[0] = p[2]; p[2] = t; - } + } p += 4; } } else { @@ -2721,12 +4193,14 @@ static void stbi__de_iphone(stbi__png *z) } } +#define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) { stbi_uc palette[1024], pal_img_n=0; stbi_uc has_trans=0, tc[3]; stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; - int first=1,k,interlace=0, is_iphone=0; + int first=1,k,interlace=0, color=0, depth=0, is_iphone=0; stbi__context *s = z->s; z->expanded = NULL; @@ -2735,23 +4209,23 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) if (!stbi__check_png_header(s)) return 0; - if (scan == SCAN_type) return 1; + if (scan == STBI__SCAN_type) return 1; for (;;) { stbi__pngchunk c = stbi__get_chunk_header(s); switch (c.type) { - case PNG_TYPE('C','g','B','I'): + case STBI__PNG_TYPE('C','g','B','I'): is_iphone = 1; stbi__skip(s, c.length); break; - case PNG_TYPE('I','H','D','R'): { - int depth,color,comp,filter; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); first = 0; if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); - depth = stbi__get8(s); if (depth != 8) return stbi__err("8bit only","PNG not supported: 8-bit only"); + depth = stbi__get8(s); if (depth != 1 && depth != 2 && depth != 4 && depth != 8) return stbi__err("1/2/4/8-bit only","PNG not supported: 1/2/4/8-bit only"); color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); @@ -2761,7 +4235,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) if (!pal_img_n) { s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); - if (scan == SCAN_header) return 1; + if (scan == STBI__SCAN_header) return 1; } else { // if paletted, then pal_n is our final components, and // img_n is # components to decompress/filter. @@ -2772,7 +4246,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) break; } - case PNG_TYPE('P','L','T','E'): { + case STBI__PNG_TYPE('P','L','T','E'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); pal_len = c.length / 3; @@ -2786,11 +4260,11 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) break; } - case PNG_TYPE('t','R','N','S'): { + case STBI__PNG_TYPE('t','R','N','S'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); if (pal_img_n) { - if (scan == SCAN_header) { s->img_n = 4; return 1; } + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); pal_img_n = 4; @@ -2801,21 +4275,21 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); has_trans = 1; for (k=0; k < s->img_n; ++k) - tc[k] = (stbi_uc) (stbi__get16be(s) & 255); // non 8-bit images will be larger + tc[k] = (stbi_uc) (stbi__get16be(s) & 255) * stbi__depth_scale_table[depth]; // non 8-bit images will be larger } break; } - case PNG_TYPE('I','D','A','T'): { + case STBI__PNG_TYPE('I','D','A','T'): { if (first) return stbi__err("first not IHDR", "Corrupt PNG"); if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); - if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; } + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } if (ioff + c.length > idata_limit) { stbi_uc *p; if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; while (ioff + c.length > idata_limit) idata_limit *= 2; - p = (stbi_uc *) realloc(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + p = (stbi_uc *) STBI_REALLOC(z->idata, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); z->idata = p; } if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); @@ -2823,19 +4297,22 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) break; } - case PNG_TYPE('I','E','N','D'): { - stbi__uint32 raw_len; + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; if (first) return stbi__err("first not IHDR", "Corrupt PNG"); - if (scan != SCAN_load) return 1; + if (scan != STBI__SCAN_load) return 1; if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); - z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !is_iphone); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); if (z->expanded == NULL) return 0; // zlib should set error - free(z->idata); z->idata = NULL; + STBI_FREE(z->idata); z->idata = NULL; if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) s->img_out_n = s->img_n+1; else s->img_out_n = s->img_n; - if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, depth, color, interlace)) return 0; if (has_trans) if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) @@ -2848,7 +4325,7 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) return 0; } - free(z->expanded); z->expanded = NULL; + STBI_FREE(z->expanded); z->expanded = NULL; return 1; } @@ -2878,7 +4355,7 @@ static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req { unsigned char *result=NULL; if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); - if (stbi__parse_png_file(p, SCAN_load, req_comp)) { + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { result = p->out; p->out = NULL; if (req_comp && req_comp != p->s->img_out_n) { @@ -2890,9 +4367,9 @@ static unsigned char *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req *y = p->s->img_y; if (n) *n = p->s->img_out_n; } - free(p->out); p->out = NULL; - free(p->expanded); p->expanded = NULL; - free(p->idata); p->idata = NULL; + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; return result; } @@ -2914,7 +4391,7 @@ static int stbi__png_test(stbi__context *s) static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) { - if (!stbi__parse_png_file(p, SCAN_header, 0)) { + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { stbi__rewind( p->s ); return 0; } @@ -2930,8 +4407,11 @@ static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) p.s = s; return stbi__png_info_raw(&p, x, y, comp); } +#endif // Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP static int stbi__bmp_test_raw(stbi__context *s) { int r; @@ -3094,7 +4574,7 @@ static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int if (!out) return stbi__errpuc("outofmem", "Out of memory"); if (bpp < 16) { int z=0; - if (psize == 0 || psize > 256) { free(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } for (i=0; i < psize; ++i) { pal[i][2] = stbi__get8(s); pal[i][1] = stbi__get8(s); @@ -3105,7 +4585,7 @@ static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int stbi__skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); if (bpp == 4) width = (s->img_x + 1) >> 1; else if (bpp == 8) width = s->img_x; - else { free(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } pad = (-width)&3; for (j=0; j < (int) s->img_y; ++j) { for (i=0; i < (int) s->img_x; i += 2) { @@ -3143,7 +4623,7 @@ static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int easy = 2; } if (!easy) { - if (!mr || !mg || !mb) { free(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } // right shift amt to put high bit in position #7 rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); @@ -3169,7 +4649,7 @@ static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); - if (target == 4) out[z++] = STBI__BYTECAST(a); + if (target == 4) out[z++] = STBI__BYTECAST(a); } } stbi__skip(s, pad); @@ -3196,10 +4676,11 @@ static stbi_uc *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int if (comp) *comp = s->img_n; return out; } +#endif // Targa Truevision - TGA // by Jonathan Dummer - +#ifndef STBI_NO_TGA static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) { int tga_w, tga_h, tga_comp; @@ -3340,12 +4821,12 @@ static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int // load the palette tga_palette = (unsigned char*)stbi__malloc( tga_palette_len * tga_palette_bits / 8 ); if (!tga_palette) { - free(tga_data); + STBI_FREE(tga_data); return stbi__errpuc("outofmem", "Out of memory"); } if (!stbi__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) { - free(tga_data); - free(tga_palette); + STBI_FREE(tga_data); + STBI_FREE(tga_palette); return stbi__errpuc("bad palette", "Corrupt TGA"); } } @@ -3427,7 +4908,7 @@ static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int // clear my palette, if I had one if ( tga_palette != NULL ) { - free( tga_palette ); + STBI_FREE( tga_palette ); } } @@ -3455,10 +4936,12 @@ static stbi_uc *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int // OK, done return tga_data; } +#endif // ************************************************************************************************* // Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB +#ifndef STBI_NO_PSD static int stbi__psd_test(stbi__context *s) { int r = (stbi__get32be(s) == 0x38425053); @@ -3493,7 +4976,7 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int // Read the rows and columns of the image. h = stbi__get32be(s); w = stbi__get32be(s); - + // Make sure the depth is 8 bits. if (stbi__get16be(s) != 8) return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 bit"); @@ -3535,7 +5018,7 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int // Initialize the data to zero. //memset( out, 0, pixelCount * 4 ); - + // Finally, the image data. if (compression) { // RLE as used by .PSD and .TIFF @@ -3553,7 +5036,7 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int // Read the RLE data by channel. for (channel = 0; channel < 4; channel++) { stbi_uc *p; - + p = out+channel; if (channel >= channelCount) { // Fill this channel with default data. @@ -3591,15 +5074,15 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int } } } - + } else { // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) // where each channel consists of an 8-bit value for each pixel in the image. - + // Read the data by channel. for (channel = 0; channel < 4; channel++) { stbi_uc *p; - + p = out + channel; if (channel > channelCount) { // Fill this channel with default data. @@ -3620,9 +5103,10 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int if (comp) *comp = channelCount; *y = h; *x = w; - + return out; } +#endif // ************************************************************************************************* // Softimage PIC loader @@ -3631,6 +5115,7 @@ static stbi_uc *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int // See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format // See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ +#ifndef STBI_NO_PIC static int stbi__pic_is4(stbi__context *s,const char *str) { int i; @@ -3818,7 +5303,7 @@ static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int re memset(result, 0xff, x*y*4); if (!stbi__pic_load_core(s,x,y,comp, result)) { - free(result); + STBI_FREE(result); result=0; } *px = x; @@ -3835,10 +5320,13 @@ static int stbi__pic_test(stbi__context *s) stbi__rewind(s); return r; } +#endif // ************************************************************************************************* // GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb -typedef struct + +#ifndef STBI_NO_GIF +typedef struct { stbi__int16 prefix; stbi_uc first; @@ -3886,8 +5374,8 @@ static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], in pal[i][2] = stbi__get8(s); pal[i][1] = stbi__get8(s); pal[i][0] = stbi__get8(s); - pal[i][3] = transp ? 0 : 255; - } + pal[i][3] = transp == i ? 0 : 255; + } } static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) @@ -3898,8 +5386,8 @@ static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_in version = stbi__get8(s); if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); - if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); - + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + stbi__g_failure_reason = ""; g->w = stbi__get16le(s); g->h = stbi__get16le(s); @@ -3920,7 +5408,7 @@ static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_in static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) { - stbi__gif g; + stbi__gif g; if (!stbi__gif_header(s, &g, comp, 1)) { stbi__rewind( s ); return 0; @@ -3940,7 +5428,7 @@ static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) stbi__out_gif_code(g, g->codes[code].prefix); if (g->cur_y >= g->max_y) return; - + p = &g->out[g->cur_x + g->cur_y]; c = &g->color_table[g->codes[code].suffix * 4]; @@ -3994,7 +5482,7 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) if (valid_bits < codesize) { if (len == 0) { len = stbi__get8(s); // start new block - if (len == 0) + if (len == 0) return g->out; } --len; @@ -4039,7 +5527,7 @@ static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) } else { return stbi__errpuc("illegal code in raster", "Corrupt GIF"); } - } + } } } @@ -4077,7 +5565,7 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i memcpy(g->out, old_out, g->w*g->h*4); } } - + for (;;) { switch (stbi__get8(s)) { case 0x2C: /* Image Descriptor */ @@ -4112,16 +5600,16 @@ static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, i if (g->lflags & 0x80) { stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); - g->color_table = (stbi_uc *) g->lpal; + g->color_table = (stbi_uc *) g->lpal; } else if (g->flags & 0x80) { for (i=0; i < 256; ++i) // @OPTIMIZE: stbi__jpeg_reset only the previous transparent - g->pal[i][3] = 255; + g->pal[i][3] = 255; if (g->transparent >= 0 && (g->eflags & 0x01)) g->pal[g->transparent][3] = 0; g->color_table = (stbi_uc *) g->pal; } else return stbi__errpuc("missing color table", "Corrupt GIF"); - + o = stbi__process_gif_raster(s, g); if (o == NULL) return NULL; @@ -4178,7 +5666,7 @@ static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) { return stbi__gif_info_raw(s,x,y,comp); } - +#endif // ************************************************************************************************* // Radiance RGBE HDR loader @@ -4267,7 +5755,7 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re // Check identifier if (strcmp(stbi__hdr_gettoken(s,buffer), "#?RADIANCE") != 0) return stbi__errpf("not HDR", "Corrupt HDR image"); - + // Parse header for(;;) { token = stbi__hdr_gettoken(s,buffer); @@ -4328,14 +5816,14 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re stbi__hdr_convert(hdr_data, rgbe, req_comp); i = 1; j = 0; - free(scanline); + STBI_FREE(scanline); goto main_decode_loop; // yes, this makes no sense } len <<= 8; len |= stbi__get8(s); - if (len != width) { free(hdr_data); free(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } if (scanline == NULL) scanline = (stbi_uc *) stbi__malloc(width * 4); - + for (k = 0; k < 4; ++k) { i = 0; while (i < width) { @@ -4356,7 +5844,7 @@ static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int re for (i=0; i < width; ++i) stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); } - free(scanline); + STBI_FREE(scanline); } return hdr_data; @@ -4402,6 +5890,7 @@ static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) } #endif // STBI_NO_HDR +#ifndef STBI_NO_BMP static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) { int hsz; @@ -4429,7 +5918,9 @@ static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) *comp = stbi__get16le(s) / 8; return 1; } +#endif +#ifndef STBI_NO_PSD static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) { int channelCount; @@ -4460,7 +5951,9 @@ static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) *comp = 4; return 1; } +#endif +#ifndef STBI_NO_PIC static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) { int act_comp=0,num_packets=0,chained; @@ -4505,28 +5998,156 @@ static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) return 1; } +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) +// Does not support 16-bit-per-channel + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *out; + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + return 0; + *x = s->img_x; + *y = s->img_y; + *comp = s->img_n; + + out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv; + char c, p, t; + + stbi__rewind( s ); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + + if (maxv > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#endif static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) { - if (stbi__jpeg_info(s, x, y, comp)) - return 1; - if (stbi__png_info(s, x, y, comp)) - return 1; - if (stbi__gif_info(s, x, y, comp)) - return 1; - if (stbi__bmp_info(s, x, y, comp)) - return 1; - if (stbi__psd_info(s, x, y, comp)) - return 1; - if (stbi__pic_info(s, x, y, comp)) - return 1; - #ifndef STBI_NO_HDR - if (stbi__hdr_info(s, x, y, comp)) - return 1; + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA if (stbi__tga_info(s, x, y, comp)) return 1; + #endif return stbi__err("unknown image type", "Image not of any known type, or corrupt"); } @@ -4571,123 +6192,134 @@ STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int /* revision history: - 1.46 (2014-08-26) - fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG - 1.45 (2014-08-16) - fix MSVC-ARM internal compiler error by wrapping malloc - 1.44 (2014-08-07) - various warning fixes from Ronny Chevalier - 1.43 (2014-07-15) - fix MSVC-only compiler problem in code changed in 1.42 - 1.42 (2014-07-09) - don't define _CRT_SECURE_NO_WARNINGS (affects user code) - fixes to stbi__cleanup_jpeg path - added STBI_ASSERT to avoid requiring assert.h - 1.41 (2014-06-25) - fix search&replace from 1.36 that messed up comments/error messages - 1.40 (2014-06-22) - fix gcc struct-initialization warning - 1.39 (2014-06-15) - fix to TGA optimization when req_comp != number of components in TGA; - fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) - add support for BMP version 5 (more ignored fields) - 1.38 (2014-06-06) - suppress MSVC warnings on integer casts truncating values - fix accidental rename of 'skip' field of I/O - 1.37 (2014-06-04) - remove duplicate typedef - 1.36 (2014-06-03) - convert to header file single-file library - if de-iphone isn't set, load iphone images color-swapped instead of returning NULL - 1.35 (2014-05-27) - various warnings - fix broken STBI_SIMD path - fix bug where stbi_load_from_file no longer left file pointer in correct place - fix broken non-easy path for 32-bit BMP (possibly never used) - TGA optimization by Arseny Kapoulkine - 1.34 (unknown) - use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case - 1.33 (2011-07-14) - make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements - 1.32 (2011-07-13) - support for "info" function for all supported filetypes (SpartanJ) - 1.31 (2011-06-20) - a few more leak fixes, bug in PNG handling (SpartanJ) - 1.30 (2011-06-11) - added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) - removed deprecated format-specific test/load functions - removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway - error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) - fix inefficiency in decoding 32-bit BMP (David Woo) - 1.29 (2010-08-16) - various warning fixes from Aurelien Pocheville - 1.28 (2010-08-01) - fix bug in GIF palette transparency (SpartanJ) - 1.27 (2010-08-01) - cast-to-stbi_uc to fix warnings - 1.26 (2010-07-24) - fix bug in file buffering for PNG reported by SpartanJ - 1.25 (2010-07-17) - refix trans_data warning (Won Chun) - 1.24 (2010-07-12) - perf improvements reading from files on platforms with lock-heavy fgetc() - minor perf improvements for jpeg - deprecated type-specific functions so we'll get feedback if they're needed - attempt to fix trans_data warning (Won Chun) - 1.23 fixed bug in iPhone support - 1.22 (2010-07-10) - removed image *writing* support - stbi_info support from Jetro Lauha - GIF support from Jean-Marc Lienher - iPhone PNG-extensions from James Brown - warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) - 1.21 fix use of 'stbi_uc' in header (reported by jon blow) - 1.20 added support for Softimage PIC, by Tom Seddon - 1.19 bug in interlaced PNG corruption check (found by ryg) + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) 1.18 2008-08-02 - fix a threading bug (local mutable static) - 1.17 support interlaced PNG - 1.16 major bugfix - stbi__convert_format converted one too many pixels - 1.15 initialize some fields for thread safety - 1.14 fix threadsafe conversion bug - header-file-only version (#define STBI_HEADER_FILE_ONLY before including) - 1.13 threadsafe - 1.12 const qualifiers in the API - 1.11 Support installable IDCT, colorspace conversion routines - 1.10 Fixes for 64-bit (don't use "unsigned long") - optimized upsampling by Fabian "ryg" Giesen - 1.09 Fix format-conversion for PSD code (bad global variables!) - 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz - 1.07 attempt to fix C++ warning/errors again - 1.06 attempt to fix C++ warning/errors again - 1.05 fix TGA loading to return correct *comp and use good luminance calc - 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free - 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR - 1.02 support for (subset of) HDR files, float interface for preferred access to them - 1.01 fix bug: possible bug in handling right-side up bmps... not sure - fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all - 1.00 interface to zlib that skips zlib header - 0.99 correct handling of alpha in palette - 0.98 TGA loader by lonesock; dynamically add loaders (untested) - 0.97 jpeg errors on too large a file; also catch another malloc failure - 0.96 fix detection of invalid v value - particleman@mollyrocket forum - 0.95 during header scan, seek to markers in case of padding - 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same - 0.93 handle jpegtran output; verbose errors - 0.92 read 4,8,16,24,32-bit BMP files of several formats - 0.91 output 24-bit Windows 3.0 BMP files - 0.90 fix a few more warnings; bump version number to approach 1.0 - 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd - 0.60 fix compiling as c++ - 0.59 fix warnings: merge Dave Moore's -Wall fixes - 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian - 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available - 0.56 fix bug: zlib uncompressed mode len vs. nlen - 0.55 fix bug: restart_interval not initialized to 0 - 0.54 allow NULL for 'int *comp' - 0.53 fix bug in png 3->4; speedup png decoding - 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments - 0.51 obey req_comp requests, 1-component jpegs return as 1-component, - on 'test' only check type, not whether we support this variant - 0.50 first released version + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 first released version */ diff --git a/src/text.c b/src/text.c index 8b7e5b12..94481857 100644 --- a/src/text.c +++ b/src/text.c @@ -63,7 +63,6 @@ static SpriteFont defaultFont; // Default font provided by raylib //---------------------------------------------------------------------------------- static bool PixelIsMagenta(Color p); // Check if a pixel is magenta static int ParseImageData(Color *imgDataPixel, int imgWidth, int imgHeight, Character **charSet); // Parse image pixel data to obtain character set measures -static int GetNextPOT(int num); // Calculate next power-of-two value for a given value static SpriteFont LoadRBMF(const char *fileName); // Load a rBMF font file (raylib BitMap Font) extern void LoadDefaultFont(void); @@ -135,7 +134,7 @@ extern void LoadDefaultFont(void) if (counter > 256) counter = 0; // Security check... } - defaultFont.texture = CreateTexture(image, false); // Convert loaded image to OpenGL texture + defaultFont.texture = LoadTextureFromImage(image, false); // Convert loaded image to OpenGL texture UnloadImage(image); // Reconstruct charSet using charsWidth[], charsHeight, charsDivisor, numChars @@ -168,7 +167,7 @@ extern void LoadDefaultFont(void) else currentPosX = testPosX; } - TraceLog(INFO, "Default font loaded successfully"); + TraceLog(INFO, "[TEX ID %i] Default font loaded successfully", defaultFont.texture.id); } extern void UnloadDefaultFont(void) @@ -195,9 +194,10 @@ SpriteFont LoadSpriteFont(const char *fileName) Image image = LoadImage(fileName); // At this point we have a pixel array with all the data... - - TraceLog(INFO, "[%s] SpriteFont image loaded: %i x %i", fileName, image.width, image.height); - + +#if defined(PLATFORM_RPI) || defined(PLATFORM_WEB) + ConvertToPOT(&image, MAGENTA); +#endif // Process bitmap Font pixel data to get measures (Character array) // spriteFont.charSet data is filled inside the function and memory is allocated! int numChars = ParseImageData(image.pixels, image.width, image.height, &spriteFont.charSet); @@ -207,40 +207,8 @@ SpriteFont LoadSpriteFont(const char *fileName) spriteFont.numChars = numChars; - // Convert image font to POT image before conversion to texture - // NOTE: Not required, we skip this step -/* - // Just add the required amount of pixels at the right and bottom sides of image... - int potWidth = GetNextPOT(image.width); - int potHeight = GetNextPOT(image.height); - - // Check if POT texture generation is required (if texture is not already POT) - if ((potWidth != image.width) || (potHeight != image.height)) - { - Color *imgDataPixelPOT = NULL; - - // Generate POT array from NPOT data - imgDataPixelPOT = (Color *)malloc(potWidth * potHeight * sizeof(Color)); - - for (int j = 0; j < potHeight; j++) - { - for (int i = 0; i < potWidth; i++) - { - if ((j < image.height) && (i < image.width)) imgDataPixelPOT[j*potWidth + i] = image.pixels[j*image.width + i]; - else imgDataPixelPOT[j*potWidth + i] = MAGENTA; - } - } - - TraceLog(WARNING, "SpriteFont texture converted to POT: %ix%i", potWidth, potHeight); - - free(image.pixels); - - image.pixels = imgDataPixelPOT; - image.width = potWidth; - image.height = potHeight; - } -*/ - spriteFont.texture = CreateTexture(image, false); // Convert loaded image to OpenGL texture + spriteFont.texture = LoadTextureFromImage(image, false); // Convert loaded image to OpenGL texture + UnloadImage(image); } @@ -475,23 +443,6 @@ static int ParseImageData(Color *imgDataPixel, int imgWidth, int imgHeight, Char return index; } -// Calculate next power-of-two value for a given num -static int GetNextPOT(int num) -{ - if (num != 0) - { - num--; - num |= (num >> 1); // Or first 2 bits - num |= (num >> 2); // Or next 2 bits - num |= (num >> 4); // Or next 4 bits - num |= (num >> 8); // Or next 8 bits - num |= (num >> 16); // Or next 16 bits - num++; - } - - return num; -} - // Load a rBMF font file (raylib BitMap Font) static SpriteFont LoadRBMF(const char *fileName) { @@ -517,91 +468,96 @@ static SpriteFont LoadRBMF(const char *fileName) Image image; rbmfInfoHeader rbmfHeader; - unsigned int *rbmfFileData; - unsigned char *rbmfCharWidthData; + unsigned int *rbmfFileData = NULL; + unsigned char *rbmfCharWidthData = NULL; int charsDivisor = 1; // Every char is separated from the consecutive by a 1 pixel divisor, horizontally and vertically FILE *rbmfFile = fopen(fileName, "rb"); // Define a pointer to bitmap file and open it in read-binary mode - // TODO: Check if file could be loaded! (rbmfFile == NULL)? - - fread(&rbmfHeader, sizeof(rbmfInfoHeader), 1, rbmfFile); - - TraceLog(INFO, "[%s] Loading rBMF file, size: %ix%i, numChars: %i, charHeight: %i", fileName, rbmfHeader.imgWidth, rbmfHeader.imgHeight, rbmfHeader.numChars, rbmfHeader.charHeight); - - spriteFont.numChars = (int)rbmfHeader.numChars; - - image.width = (int)rbmfHeader.imgWidth; - image.height = (int)rbmfHeader.imgHeight; - - int numPixelBits = rbmfHeader.imgWidth * rbmfHeader.imgHeight / 32; - - rbmfFileData = (unsigned int *)malloc(numPixelBits * sizeof(unsigned int)); - - for(int i = 0; i < numPixelBits; i++) fread(&rbmfFileData[i], sizeof(unsigned int), 1, rbmfFile); - - rbmfCharWidthData = (unsigned char *)malloc(spriteFont.numChars * sizeof(unsigned char)); - - for(int i = 0; i < spriteFont.numChars; i++) fread(&rbmfCharWidthData[i], sizeof(unsigned char), 1, rbmfFile); - - // Re-construct image from rbmfFileData - //----------------------------------------- - image.pixels = (Color *)malloc(image.width * image.height * sizeof(Color)); - - for (int i = 0; i < image.width * image.height; i++) image.pixels[i] = BLANK; // Initialize array - - int counter = 0; // Font data elements counter - - // Fill image data (convert from bit to pixel!) - for (int i = 0; i < image.width * image.height; i += 32) + if (rbmfFile == NULL) { - for (int j = 31; j >= 0; j--) + TraceLog(WARNING, "[%s] rBMF font file could not be opened", fileName); + } + else + { + fread(&rbmfHeader, sizeof(rbmfInfoHeader), 1, rbmfFile); + + TraceLog(INFO, "[%s] Loading rBMF file, size: %ix%i, numChars: %i, charHeight: %i", fileName, rbmfHeader.imgWidth, rbmfHeader.imgHeight, rbmfHeader.numChars, rbmfHeader.charHeight); + + spriteFont.numChars = (int)rbmfHeader.numChars; + + image.width = (int)rbmfHeader.imgWidth; + image.height = (int)rbmfHeader.imgHeight; + + int numPixelBits = rbmfHeader.imgWidth * rbmfHeader.imgHeight / 32; + + rbmfFileData = (unsigned int *)malloc(numPixelBits * sizeof(unsigned int)); + + for(int i = 0; i < numPixelBits; i++) fread(&rbmfFileData[i], sizeof(unsigned int), 1, rbmfFile); + + rbmfCharWidthData = (unsigned char *)malloc(spriteFont.numChars * sizeof(unsigned char)); + + for(int i = 0; i < spriteFont.numChars; i++) fread(&rbmfCharWidthData[i], sizeof(unsigned char), 1, rbmfFile); + + // Re-construct image from rbmfFileData + //----------------------------------------- + image.pixels = (Color *)malloc(image.width * image.height * sizeof(Color)); + + for (int i = 0; i < image.width * image.height; i++) image.pixels[i] = BLANK; // Initialize array + + int counter = 0; // Font data elements counter + + // Fill image data (convert from bit to pixel!) + for (int i = 0; i < image.width * image.height; i += 32) { - if (BIT_CHECK(rbmfFileData[counter], j)) image.pixels[i+j] = WHITE; + for (int j = 31; j >= 0; j--) + { + if (BIT_CHECK(rbmfFileData[counter], j)) image.pixels[i+j] = WHITE; + } + + counter++; } - counter++; - } + TraceLog(INFO, "[%s] Image reconstructed correctly, now converting it to texture", fileName); - TraceLog(INFO, "[%s] Image reconstructed correctly, now converting it to texture", fileName); + spriteFont.texture = LoadTextureFromImage(image, false); + UnloadImage(image); // Unload image data - spriteFont.texture = CreateTexture(image, false); - UnloadImage(image); // Unload image data + //TraceLog(INFO, "[%s] Starting charSet reconstruction", fileName); - TraceLog(INFO, "[%s] Starting charSet reconstruction", fileName); + // Reconstruct charSet using rbmfCharWidthData, rbmfHeader.charHeight, charsDivisor, rbmfHeader.numChars + spriteFont.charSet = (Character *)malloc(spriteFont.numChars * sizeof(Character)); // Allocate space for our character data - // Reconstruct charSet using rbmfCharWidthData, rbmfHeader.charHeight, charsDivisor, rbmfHeader.numChars - spriteFont.charSet = (Character *)malloc(spriteFont.numChars * sizeof(Character)); // Allocate space for our character data + int currentLine = 0; + int currentPosX = charsDivisor; + int testPosX = charsDivisor; - int currentLine = 0; - int currentPosX = charsDivisor; - int testPosX = charsDivisor; - - for (int i = 0; i < spriteFont.numChars; i++) - { - spriteFont.charSet[i].value = (int)rbmfHeader.firstChar + i; - spriteFont.charSet[i].x = currentPosX; - spriteFont.charSet[i].y = charsDivisor + currentLine * ((int)rbmfHeader.charHeight + charsDivisor); - spriteFont.charSet[i].w = (int)rbmfCharWidthData[i]; - spriteFont.charSet[i].h = (int)rbmfHeader.charHeight; - - testPosX += (spriteFont.charSet[i].w + charsDivisor); - - if (testPosX > spriteFont.texture.width) + for (int i = 0; i < spriteFont.numChars; i++) { - currentLine++; - currentPosX = 2 * charsDivisor + (int)rbmfCharWidthData[i]; - testPosX = currentPosX; + spriteFont.charSet[i].value = (int)rbmfHeader.firstChar + i; + spriteFont.charSet[i].x = currentPosX; + spriteFont.charSet[i].y = charsDivisor + currentLine * ((int)rbmfHeader.charHeight + charsDivisor); + spriteFont.charSet[i].w = (int)rbmfCharWidthData[i]; + spriteFont.charSet[i].h = (int)rbmfHeader.charHeight; - spriteFont.charSet[i].x = charsDivisor; - spriteFont.charSet[i].y = charsDivisor + currentLine * (rbmfHeader.charHeight + charsDivisor); + testPosX += (spriteFont.charSet[i].w + charsDivisor); + + if (testPosX > spriteFont.texture.width) + { + currentLine++; + currentPosX = 2 * charsDivisor + (int)rbmfCharWidthData[i]; + testPosX = currentPosX; + + spriteFont.charSet[i].x = charsDivisor; + spriteFont.charSet[i].y = charsDivisor + currentLine * (rbmfHeader.charHeight + charsDivisor); + } + else currentPosX = testPosX; } - else currentPosX = testPosX; + + TraceLog(INFO, "[%s] rBMF file loaded correctly as SpriteFont", fileName); } - - TraceLog(INFO, "[%s] rBMF file loaded correctly as SpriteFont", fileName); - + fclose(rbmfFile); free(rbmfFileData); // Now we can free loaded data from RAM memory diff --git a/src/textures.c b/src/textures.c index 929cba78..f701c380 100644 --- a/src/textures.c +++ b/src/textures.c @@ -126,9 +126,9 @@ Image LoadImage(const char *fileName) image.width = imgWidth; image.height = imgHeight; - TraceLog(INFO, "[%s] Image loaded successfully", fileName); + TraceLog(INFO, "[%s] Image loaded successfully (%ix%i)", fileName, image.width, image.height); } - else TraceLog(WARNING, "[%s] Image could not be loaded, file format not recognized", fileName); + else TraceLog(WARNING, "[%s] Image could not be loaded, file not recognized", fileName); } else if (strcmp(GetExtension(fileName),"dds") == 0) { @@ -175,8 +175,6 @@ Image LoadImage(const char *fileName) // Load an image from rRES file (raylib Resource) Image LoadImageFromRES(const char *rresName, int resId) { - // TODO: rresName could be directly a char array with all the data! --> support it! :P - Image image; bool found = false; @@ -189,7 +187,10 @@ Image LoadImageFromRES(const char *rresName, int resId) FILE *rresFile = fopen(rresName, "rb"); - if (!rresFile) TraceLog(WARNING, "[%s] Could not open raylib resource file", rresName); + if (rresFile == NULL) + { + TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName); + } else { // Read rres file (basic file check - id) @@ -295,6 +296,11 @@ Image LoadImageFromRES(const char *rresName, int resId) Texture2D LoadTexture(const char *fileName) { Texture2D texture; + + // Init texture to default values + texture.id = 0; + texture.width = 0; + texture.height = 0; if (strcmp(GetExtension(fileName),"dds") == 0) { @@ -334,10 +340,13 @@ Texture2D LoadTexture(const char *fileName) else { Image image = LoadImage(fileName); - + if (image.pixels != NULL) { - texture = CreateTexture(image, false); +#if defined(PLATFORM_RPI) || defined(PLATFORM_WEB) + ConvertToPOT(&image, BLANK); +#endif + texture = LoadTextureFromImage(image, false); UnloadImage(image); } } @@ -345,13 +354,66 @@ Texture2D LoadTexture(const char *fileName) return texture; } +// Load a texture from image data +// NOTE: image is not unloaded, it must be done manually +Texture2D LoadTextureFromImage(Image image, bool genMipmaps) +{ + Texture2D texture; + + // Init texture to default values + texture.id = 0; + texture.width = 0; + texture.height = 0; + + if ((image.pixels != NULL) && (image.width > 0) && (image.height > 0)) + { + unsigned char *imgData = malloc(image.width * image.height * 4); + + int j = 0; + + for (int i = 0; i < image.width * image.height * 4; i += 4) + { + imgData[i] = image.pixels[j].r; + imgData[i+1] = image.pixels[j].g; + imgData[i+2] = image.pixels[j].b; + imgData[i+3] = image.pixels[j].a; + + j++; + } + + // NOTE: rlglLoadTexture() can generate mipmaps (POT image required) + texture.id = rlglLoadTexture(imgData, image.width, image.height, genMipmaps); + + texture.width = image.width; + texture.height = image.height; + + free(imgData); + } + else TraceLog(WARNING, "Texture could not be loaded, image data is not valid"); + + return texture; +} + +// [DEPRECATED] Load a texture from image data +// NOTE: Use LoadTextureFromImage() instead +Texture2D CreateTexture(Image image, bool genMipmaps) +{ + Texture2D texture; + + texture = LoadTextureFromImage(image, genMipmaps); + + TraceLog(INFO, "Created texture id: %i", texture.id); + + return texture; +} + // Load an image as texture from rRES file (raylib Resource) Texture2D LoadTextureFromRES(const char *rresName, int resId) { Texture2D texture; Image image = LoadImageFromRES(rresName, resId); - texture = CreateTexture(image, false); + texture = LoadTextureFromImage(image, false); UnloadImage(image); return texture; @@ -369,6 +431,41 @@ void UnloadTexture(Texture2D texture) rlDeleteTextures(texture.id); } +// Convert image to POT (power-of-two) +// NOTE: Requirement on OpenGL ES 2.0 (RPI, HTML5) +void ConvertToPOT(Image *image, Color fillColor) +{ + // Just add the required amount of pixels at the right and bottom sides of image... + int potWidth = GetNextPOT(image->width); + int potHeight = GetNextPOT(image->height); + + // Check if POT texture generation is required (if texture is not already POT) + if ((potWidth != image->width) || (potHeight != image->height)) + { + Color *imgDataPixelPOT = NULL; + + // Generate POT array from NPOT data + imgDataPixelPOT = (Color *)malloc(potWidth * potHeight * sizeof(Color)); + + for (int j = 0; j < potHeight; j++) + { + for (int i = 0; i < potWidth; i++) + { + if ((j < image->height) && (i < image->width)) imgDataPixelPOT[j*potWidth + i] = image->pixels[j*image->width + i]; + else imgDataPixelPOT[j*potWidth + i] = fillColor; + } + } + + TraceLog(WARNING, "Image converted to POT: (%ix%i) -> (%ix%i)", image->width, image->height, potWidth, potHeight); + + free(image->pixels); + + image->pixels = imgDataPixelPOT; + image->width = potWidth; + image->height = potHeight; + } +} + // Draw a Texture2D void DrawTexture(Texture2D texture, int posX, int posY, Color tint) { @@ -436,49 +533,13 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V rlDisableTexture(); } -// Create a texture from an image -// NOTE: image is not unloaded, iot must be done manually -Texture2D CreateTexture(Image image, bool genMipmaps) -{ - Texture2D texture; - - // Init texture to default values - texture.id = 0; - texture.width = 0; - texture.height = 0; - - if (image.pixels != NULL) - { - unsigned char *imgData = malloc(image.width * image.height * 4); - - int j = 0; - - for (int i = 0; i < image.width * image.height * 4; i += 4) - { - imgData[i] = image.pixels[j].r; - imgData[i+1] = image.pixels[j].g; - imgData[i+2] = image.pixels[j].b; - imgData[i+3] = image.pixels[j].a; - - j++; - } - - // NOTE: rlglLoadTexture() can generate mipmaps (POT image required) - texture.id = rlglLoadTexture(imgData, image.width, image.height, genMipmaps); - - texture.width = image.width; - texture.height = image.height; - - free(imgData); - } - else TraceLog(WARNING, "Texture could not be created, image data is not valid"); - - return texture; -} +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- // Loading DDS image data (compressed or uncompressed) // NOTE: Compressed data loading not supported on OpenGL 1.1 -ImageEx LoadDDS(const char *fileName) +static ImageEx LoadDDS(const char *fileName) { #define FOURCC_DXT1 0x31545844 // Equivalent to "DXT1" in ASCII #define FOURCC_DXT3 0x33545844 // Equivalent to "DXT3" in ASCII @@ -528,12 +589,18 @@ ImageEx LoadDDS(const char *fileName) ImageEx image; ddsHeader header; + + image.data = NULL; + image.width = 0; + image.height = 0; + image.mipmaps = 0; + image.compFormat = 0; FILE *ddsFile = fopen(fileName, "rb"); if (ddsFile == NULL) { - TraceLog(WARNING, "DDS File could not be opened"); + TraceLog(WARNING, "[%s] DDS image file could not be opened", fileName); } else { @@ -544,7 +611,7 @@ ImageEx LoadDDS(const char *fileName) if (strncmp(filecode, "DDS ", 4) != 0) { - TraceLog(WARNING, "DDS File does not seem to be valid"); + TraceLog(WARNING, "[%s] DDS file does not seem to be a valid image", fileName); fclose(ddsFile); } else @@ -636,7 +703,7 @@ ImageEx LoadDDS(const char *fileName) // Loading PKM image data (ETC1/ETC2 compression) // NOTE: KTX is the standard Khronos Group compression format (ETC1/ETC2, mipmaps) // PKM is a much simpler file format used mainly to contain a single ETC1/ETC2 compressed image (no mipmaps) -ImageEx LoadPKM(const char *fileName) +static ImageEx LoadPKM(const char *fileName) { // If OpenGL ES 2.0. the following format could be supported (ETC1): //GL_ETC1_RGB8_OES @@ -679,7 +746,7 @@ ImageEx LoadPKM(const char *fileName) if (pkmFile == NULL) { - TraceLog(WARNING, "[%s] PKM File could not be opened", fileName); + TraceLog(WARNING, "[%s] PKM image file could not be opened", fileName); } else { @@ -690,7 +757,7 @@ ImageEx LoadPKM(const char *fileName) if (strncmp(filecode, "PKM ", 4) != 0) { - TraceLog(WARNING, "[%s] PKM File does not seem to be valid", fileName); + TraceLog(WARNING, "[%s] PKM file does not seem to be a valid image", fileName); fclose(pkmFile); } else diff --git a/src/utils.c b/src/utils.c index b5112111..c3c20b47 100644 --- a/src/utils.c +++ b/src/utils.c @@ -133,18 +133,25 @@ void WriteBitmap(const char *fileName, unsigned char *imgData, int width, int he FILE *bmpFile = fopen(fileName, "wb"); // Define a pointer to bitmap file and open it in write-binary mode - // NOTE: fwrite parameters are: data pointer, size in bytes of each element to be written, number of elements, file-to-write pointer - fwrite(bmpFileHeader, sizeof(unsigned char), 14, bmpFile); // Write BMP file header data - fwrite(bmpInfoHeader, sizeof(unsigned char), 40, bmpFile); // Write BMP info header data - - // Write pixel data to file - for (int y = 0; y < height ; y++) + if (bmpFile == NULL) { - for (int x = 0; x < width; x++) + TraceLog(WARNING, "[%s] BMP file could not be created", fileName); + } + else + { + // NOTE: fwrite parameters are: data pointer, size in bytes of each element to be written, number of elements, file-to-write pointer + fwrite(bmpFileHeader, sizeof(unsigned char), 14, bmpFile); // Write BMP file header data + fwrite(bmpInfoHeader, sizeof(unsigned char), 40, bmpFile); // Write BMP info header data + + // Write pixel data to file + for (int y = 0; y < height ; y++) { - fputc(imgData[(x*4)+2 + (y*width*4)], bmpFile); - fputc(imgData[(x*4)+1 + (y*width*4)], bmpFile); - fputc(imgData[(x*4) + (y*width*4)], bmpFile); + for (int x = 0; x < width; x++) + { + fputc(imgData[(x*4)+2 + (y*width*4)], bmpFile); + fputc(imgData[(x*4)+1 + (y*width*4)], bmpFile); + fputc(imgData[(x*4) + (y*width*4)], bmpFile); + } } } @@ -157,7 +164,9 @@ void WritePNG(const char *fileName, unsigned char *imgData, int width, int heigh { stbi_write_png(fileName, width, height, 4, imgData, width*4); // It WORKS!!! } +#endif +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) // Outputs a trace log message (INFO, ERROR, WARNING) // NOTE: If a file has been init, output log is written there void TraceLog(int msgType, const char *text, ...) @@ -262,6 +271,23 @@ const char *GetExtension(const char *fileName) return (dot + 1); } +// Calculate next power-of-two value for a given num +int GetNextPOT(int num) +{ + if (num != 0) + { + num--; + num |= (num >> 1); // Or first 2 bits + num |= (num >> 2); // Or next 2 bits + num |= (num >> 4); // Or next 4 bits + num |= (num >> 8); // Or next 8 bits + num |= (num >> 16); // Or next 16 bits + num++; + } + + return num; +} + //---------------------------------------------------------------------------------- // Module specific Functions Definition //---------------------------------------------------------------------------------- diff --git a/src/utils.h b/src/utils.h index 784c7926..882aebf6 100644 --- a/src/utils.h +++ b/src/utils.h @@ -77,6 +77,7 @@ void WritePNG(const char *fileName, unsigned char *imgData, int width, int heigh void TraceLog(int msgType, const char *text, ...); // Outputs a trace log message const char *GetExtension(const char *fileName); // Returns extension of a filename +int GetNextPOT(int num); // Calculate next power-of-two value for a given num #if defined(PLATFORM_ANDROID) void InitAssetManager(AAssetManager *manager); // Initialize asset manager from android app