diff --git a/examples/audio_module_playing.lua b/examples/audio_module_playing.lua new file mode 100644 index 000000000..c309c2537 --- /dev/null +++ b/examples/audio_module_playing.lua @@ -0,0 +1,131 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [audio] example - Module playing (streaming) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +MAX_CIRCLES = 64 + +typedef struct { -- TODO: Find a Lua alternative: TABLES? + Vector2 position + float radius + float alpha + float speed + Color color +} CircleWave + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)") + +InitAudioDevice() -- Initialize audio device + +local colors = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, + YELLOW, GREEN, SKYBLUE, PURPLE, BEIGE } + +-- Creates ome circles for visual effect +local circles = {} + +for i = MAX_CIRCLES, 1, -1 do + circles[i].alpha = 0.0 + circles[i].radius = GetRandomValue(10, 40) + circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius) + circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius) + circles[i].speed = (float)GetRandomValue(1, 100)/20000.0 + circles[i].color = colors[GetRandomValue(1, 14)] +end + +-- Load postprocessing bloom shader +local shader = LoadShader("resources/shaders/glsl330/base.vs", + "resources/shaders/glsl330/bloom.fs") + +-- Create a RenderTexture2D to be used for render to texture +local target = LoadRenderTexture(screenWidth, screenHeight) + +local xm = LoadMusicStream("resources/audio/mini1111.xm") + +PlayMusicStream(xm) + +local timePlayed = 0.0 + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + for i = MAX_CIRCLES, 1, -1 do + circles[i].alpha += circles[i].speed + circles[i].radius += circles[i].speed*10.0 + + if (circles[i].alpha > 1.0) then circles[i].speed = circles[i].speed*-1 end + + if (circles[i].alpha <= 0.0) then + circles[i].alpha = 0.0 + circles[i].radius = GetRandomValue(10, 40) + circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius) + circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius) + circles[i].color = colors[GetRandomValue(0, 13)] + circles[i].speed = (float)GetRandomValue(1, 100)/20000.0 + end + end + + -- Get timePlayed scaled to bar dimensions + timePlayed = (GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40))*2 + + UpdateMusicStream(xm) -- Update music buffer with new stream data + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(BLACK) + + BeginTextureMode(target) -- Enable drawing to texture + + for i = MAX_CIRCLES, 1, -1 do + DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha)) + end + + EndTextureMode() -- End drawing to texture (now we have a texture available for next passes) + + BeginShaderMode(shader) + + -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom) + DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE) + + EndShaderMode() + + -- Draw time bar + DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY) + DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, MAROON) + DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadShader(shader) -- Unload shader +UnloadRenderTexture(target) -- Unload render texture + +UnloadMusicStream(xm) -- Unload music stream buffers from RAM + +CloseAudioDevice() -- Close audio device (music streaming is automatically stopped) + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- + +return 0 +} \ No newline at end of file diff --git a/examples/audio_music_stream.lua b/examples/audio_music_stream.lua new file mode 100644 index 000000000..33cf335f3 --- /dev/null +++ b/examples/audio_music_stream.lua @@ -0,0 +1,66 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [audio] example - Music playing (streaming) +-- +-- NOTE: This example requires OpenAL Soft library installed +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)") + +InitAudioDevice() -- Initialize audio device + +local music = LoadMusicStream("resources/audio/guitar_noodling.ogg") + +PlayMusicStream(music) + +local framesCounter = 0 +local timePlayed = 0.0 + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + framesCounter = framesCounter + 1 + + timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4 -- We scale by 4 to fit 400 pixels + + UpdateMusicStream(music) -- Update music buffer with new stream data + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY) + + DrawRectangle(200, 250, 400, 12, LIGHTGRAY) + DrawRectangle(200, 250, timePlayed//1, 12, MAROON) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadMusicStream(music) -- Unload music stream buffers from RAM + +CloseAudioDevice() -- Close audio device (music streaming is automatically stopped) + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/audio_raw_stream.lua b/examples/audio_raw_stream.lua new file mode 100644 index 000000000..070984f9b --- /dev/null +++ b/examples/audio_raw_stream.lua @@ -0,0 +1,97 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [audio] example - Raw audio streaming +-- +-- NOTE: This example requires OpenAL Soft library installed +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +MAX_SAMPLES = 20000 +DEG2RAD = math.pi/180.0 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming") + +InitAudioDevice() -- Initialize audio device + +-- Init raw audio stream (sample rate: 22050, sample size: 32bit-float, channels: 1-mono) +local stream = InitAudioStream(22050, 32, 1) + +-- Fill audio stream with some samples (sine wave) +local data = {} + +for i = 1, MAX_SAMPLES do + data[i] = math.sin(((2*math.pi*i)/2)*DEG2RAD) +end + +-- NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop +-- for that reason, there is a clip everytime audio stream is looped + +PlayAudioStream(stream) + +local totalSamples = MAX_SAMPLES +local samplesLeft = totalSamples + +local position = Vector2(0, 0) + +SetTargetFPS(30) -- Set our game to run at 30 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + + -- Refill audio stream if required + if (IsAudioBufferProcessed(stream)) then + local numSamples = 0 + + if (samplesLeft >= 4096) then numSamples = 4096 + else numSamples = samplesLeft end + + UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples) + + samplesLeft = samplesLeft - numSamples + + -- Reset samples feeding (loop audio) + if (samplesLeft <= 0) then samplesLeft = totalSamples end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY) + + -- NOTE: Draw a part of the sine wave (only screen width) + for i = 1, GetScreenWidth() do + position.x = (i - 1) + position.y = 250 + 50*data[i] + + DrawPixelV(position, RED) + end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseAudioStream(stream) -- Close raw audio stream and delete buffers from RAM + +CloseAudioDevice() -- Close audio device (music streaming is automatically stopped) + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/audio_sound_loading.lua b/examples/audio_sound_loading.lua new file mode 100644 index 000000000..7107eea4e --- /dev/null +++ b/examples/audio_sound_loading.lua @@ -0,0 +1,59 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [audio] example - Sound loading and playing +-- +-- NOTE: This example requires OpenAL Soft library installed +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing") + +InitAudioDevice() -- Initialize audio device + +local fxWav = LoadSound("resources/audio/weird.wav") -- Load WAV audio file +local fxOgg = LoadSound("resources/audio/tanatana.ogg") -- Load OGG audio file + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyPressed(KEY.SPACE)) then PlaySound(fxWav) end -- Play WAV sound + if (IsKeyPressed(KEY.ENTER)) then PlaySound(fxOgg) end -- Play OGG sound + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY) + + DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadSound(fxWav) -- Unload sound data +UnloadSound(fxOgg) -- Unload sound data + +CloseAudioDevice() -- Close audio device + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_2d_camera.lua b/examples/core_2d_camera.lua new file mode 100644 index 000000000..a7c0515a6 --- /dev/null +++ b/examples/core_2d_camera.lua @@ -0,0 +1,130 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - 2d camera +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +MAX_BUILDINGS = 100 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera") + +local player = Rectangle(400, 280, 40, 40) +local buildings = {} +local buildColors = {} + +local spacing = 0; + +for i = 1, MAX_BUILDINGS do + buildings[i] = Rectangle(0, 0, 0, 0) + buildings[i].width = GetRandomValue(50, 200) + buildings[i].height = GetRandomValue(100, 800) + buildings[i].y = screenHeight - 130 - buildings[i].height + buildings[i].x = -6000 + spacing + + spacing = spacing + buildings[i].width + + buildColors[i] = Color(GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255) +end + +local camera = Camera2D(Vector2(0, 0), Vector2(0, 0), 0.0, 1.0) + +camera.target = Vector2(player.x + 20, player.y + 20) +camera.offset = Vector2(0, 0) +camera.rotation = 0.0 +camera.zoom = 1.0 + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyDown(KEY.RIGHT)) then + player.x = player.x + 2 -- Player movement + camera.offset.x = camera.offset.x - 2 -- Camera displacement with player movement + elseif (IsKeyDown(KEY.LEFT)) then + player.x = player.x - 2 -- Player movement + camera.offset.x = camera.offset.x + 2 -- Camera displacement with player movement + end + + -- Camera target follows player + camera.target = Vector2(player.x + 20, player.y + 20) + + -- Camera rotation controls + if (IsKeyDown(KEY.A)) then camera.rotation = camera.rotation - 1 + elseif (IsKeyDown(KEY.S)) then camera.rotation = camera.rotation + 1 + end + + -- Limit camera rotation to 80 degrees (-40 to 40) + if (camera.rotation > 40) then camera.rotation = 40 + elseif (camera.rotation < -40) then camera.rotation = -40 + end + + -- Camera zoom controls + camera.zoom = camera.zoom + (GetMouseWheelMove()*0.05) + + if (camera.zoom > 3.0) then camera.zoom = 3.0 + elseif (camera.zoom < 0.1) then camera.zoom = 0.1 + end + + -- Camera reset (zoom and rotation) + if (IsKeyPressed(KEY.R)) then + camera.zoom = 1.0 + camera.rotation = 0.0 + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin2dMode(camera) -- ERROR: Lua Error: attempt to index a number value (?) + + DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY) + + for i = 1, MAX_BUILDINGS, 1 do DrawRectangleRec(buildings[i], buildColors[i]) end + + DrawRectangleRec(player, RED) + + DrawRectangle(camera.target.x, -500, 1, screenHeight*4, GREEN) + DrawRectangle(-500, camera.target.y, screenWidth*4, 1, GREEN) + + End2dMode() + + DrawText("SCREEN AREA", 640, 10, 20, RED) + + DrawRectangle(0, 0, screenWidth, 5, RED) + DrawRectangle(0, 5, 5, screenHeight - 10, RED) + DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, RED) + DrawRectangle(0, screenHeight - 5, screenWidth, 5, RED) + + DrawRectangle( 10, 10, 250, 113, Fade(SKYBLUE, 0.5)) + DrawRectangleLines( 10, 10, 250, 113, BLUE) + + DrawText("Free 2d camera controls:", 20, 20, 10, BLACK) + DrawText("- Right/Left to move Offset", 40, 40, 10, DARKGRAY) + DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, DARKGRAY) + DrawText("- A / S to Rotate", 40, 80, 10, DARKGRAY) + DrawText("- R to reset Zoom and Rotation", 40, 100, 10, DARKGRAY) + + EndDrawing(); + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- diff --git a/examples/core_3d_camera_first_person.lua b/examples/core_3d_camera_first_person.lua new file mode 100644 index 000000000..800c3c2a1 --- /dev/null +++ b/examples/core_3d_camera_first_person.lua @@ -0,0 +1,85 @@ +-------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - 3d camera first person +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +-------------------------------------------------------------------------------------------- + +MAX_COLUMNS = 20 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person") + +-- Define the camera to look into our 3d world (position, target, up vector) +local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 60.0) + +-- Generates some random columns +local heights = {} +local positions = {} +local colors = {} + +for i = 1, MAX_COLUMNS do + heights[i] = GetRandomValue(1, 12) + positions[i] = Vector3(GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15)) + colors[i] = Color(GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255) +end + +local playerPosition = Vector3(4.0, 2.0, 4.0) -- Define player position + +SetCameraMode(CameraMode.FIRST_PERSON) -- Set a first person camera mode +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + camera, playerPosition = UpdateCameraPlayer(camera, playerPosition) -- Update camera and player position + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawPlane(Vector3(0.0, 0.0, 0.0), Vector2(32.0, 32.0), LIGHTGRAY) -- Draw ground + DrawCube(Vector3(-16.0, 2.5, 0.0), 1.0, 5.0, 32.0, BLUE) -- Draw a blue wall + DrawCube(Vector3(16.0, 2.5, 0.0), 1.0, 5.0, 32.0, LIME) -- Draw a green wall + DrawCube(Vector3(0.0, 2.5, 16.0), 32.0, 5.0, 1.0, GOLD) -- Draw a yellow wall + + -- Draw some cubes around + for i = 1, MAX_COLUMNS do + DrawCube(positions[i], 2.0, heights[i], 2.0, colors[i]) + DrawCubeWires(positions[i], 2.0, heights[i], 2.0, MAROON) + end + + End3dMode() + + DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5)) + DrawRectangleLines( 10, 10, 220, 70, BLUE) + + DrawText("First person camera default controls:", 20, 20, 10, BLACK) + DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY) + DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_3d_camera_free.lua b/examples/core_3d_camera_free.lua new file mode 100644 index 000000000..244aad6b8 --- /dev/null +++ b/examples/core_3d_camera_free.lua @@ -0,0 +1,75 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Initialize 3d camera free +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +-------------------------------------------------------------------------------------------- + +-- Initialization +---------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free") + +-- Define the camera to look into our 3d world +local camera = {} +camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position +camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point +camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target) +camera.fovy = 45.0 -- Camera field-of-view Y + +local cubePosition = Vector3(0.0, 0.0, 0.0) + +SetCameraMode(CameraMode.FREE) -- Set a free camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + camera = UpdateCamera(camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawCube(cubePosition, 2.0, 2.0, 2.0, RED) + DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON) + + DrawGrid(10, 1.0) + + End3dMode() + + DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5)) + DrawRectangleLines( 10, 10, 320, 133, BLUE) + + DrawText("Free camera default controls:", 20, 20, 10, BLACK) + DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY) + DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY) + DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY) + DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY) + DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_3d_mode.lua b/examples/core_3d_mode.lua new file mode 100644 index 000000000..c0f7a038f --- /dev/null +++ b/examples/core_3d_mode.lua @@ -0,0 +1,64 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Initialize 3d mode +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode") + +-- Define the camera to look into our 3d world +local camera = {} +camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position +camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point +camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target) +camera.fovy = 45.0 -- Camera field-of-view Y + +local cubePosition = Vector3(0.0, 0.0, 0.0) + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) -- ERROR: Lua Error: attempt to index a number value (?) + + DrawCube(cubePosition, 2.0, 2.0, 2.0, RED) + DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON) + + DrawGrid(10, 1.0) + + End3dMode() + + DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_3d_picking.lua b/examples/core_3d_picking.lua new file mode 100644 index 000000000..f3f285304 --- /dev/null +++ b/examples/core_3d_picking.lua @@ -0,0 +1,96 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Picking in 3d mode +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking") + +-- Define the camera to look into our 3d world +local camera = {} +camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position +camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point +camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target) +camera.fovy = 45.0 -- Camera field-of-view Y + +local cubePosition = Vector3(0.0, 1.0, 0.0) +local cubeSize = Vector3(2.0, 2.0, 2.0) + +local ray = Ray(Vector3(0, 0, 0), Vector3(0, 0, 0)) -- Picking line ray + +local collision = false + +SetCameraMode(CameraMode.FREE) -- Set a free camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(camera) -- Update internal camera and our camera + + if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then + -- NOTE: This function is NOT WORKING properly! + ray = GetMouseRay(GetMousePosition(), camera) + + -- Check collision between ray and box + collision = CheckCollisionRayBox(ray, + (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 }, + (Vector3){ cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 }}) + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + if (collision) then + DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED) + DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON) + + DrawCubeWires(cubePosition, cubeSize.x + 0.2, cubeSize.y + 0.2, cubeSize.z + 0.2, GREEN) + else + DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY) + DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY) + end + + DrawRay(ray, MAROON) + + DrawGrid(10, 1.0) + + End3dMode() + + DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY) + + if (collision) then + DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30))/2, screenHeight*0.1, 30, GREEN) + end + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_basic_window.lua b/examples/core_basic_window.lua index 4f2880059..ea3337a15 100644 --- a/examples/core_basic_window.lua +++ b/examples/core_basic_window.lua @@ -1,28 +1,33 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Basic window +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + -- Initialization ----------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------- local screenWidth = 800 local screenHeight = 450 -InitWindow(screenWidth, screenHeight, "raylib [rlua] example - basic window") - -InitAudioDevice() - ---local pause = false ---local texture = LoadTexture("resources/texture.png") +InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window") SetTargetFPS(60) -- Set target frames-per-second ----------------------------------------------------------------------------------------- +------------------------------------------------------------------------------------------- -while not WindowShouldClose() do +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key -- Update - ------------------------------------------------------------------------------------ - --if (IsKeyPressed(KEY.SPACE)) then - -- pause = not pause - --end - ------------------------------------------------------------------------------------ + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- -- Draw - ------------------------------------------------------------------------------------ + --------------------------------------------------------------------------------------- BeginDrawing() ClearBackground(RAYWHITE) @@ -30,12 +35,10 @@ while not WindowShouldClose() do DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY) EndDrawing() - ------------------------------------------------------------------------------------ + --------------------------------------------------------------------------------------- end -- De-Initialization ------------------------------------------------------------------------------------- -CloseAudioDevice() -- Close audio device - +------------------------------------------------------------------------------------------- CloseWindow() -- Close window and OpenGL context ------------------------------------------------------------------------------------- \ No newline at end of file +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_color_select.lua b/examples/core_color_select.lua new file mode 100644 index 000000000..2d9c7a963 --- /dev/null +++ b/examples/core_color_select.lua @@ -0,0 +1,82 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Color selection by mouse (collision detection) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +NUM_RECTANGLES = 21 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)") + +local colors = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN, + GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW, + GREEN, SKYBLUE, PURPLE, BEIGE } + +local colorsRecs = {} -- Rectangles array +local selected = {} + +-- Fills colorsRecs data (for every rectangle) +for i = 1, NUM_RECTANGLES do + colorsRecs[i] = Rectangle(0, 0, 0, 0) + colorsRecs[i].x = 20 + 100*((i-1)%7) + 10*((i-1)%7) + colorsRecs[i].y = 60 + 100*((i-1)//7) + 10*((i-1)//7) -- Using floor division: // + colorsRecs[i].width = 100 + colorsRecs[i].height = 100 + selected[i] = false +end + +local mousePoint = Vector2(0, 0) + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + mousePoint = GetMousePosition() + + for i = 1, NUM_RECTANGLES do -- Iterate along all the rectangles + if (CheckCollisionPointRec(mousePoint, colorsRecs[i])) then + colors[i].a = 120 + if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then selected[i] = not selected[i] end + else colors[i].a = 255 end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + for i = 1, NUM_RECTANGLES do -- Draw all rectangles + DrawRectangleRec(colorsRecs[i], colors[i]) + + -- Draw four rectangles around selected rectangle + if (selected[i]) then + DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 100, 10, RAYWHITE) -- Square top rectangle + DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 10, 100, RAYWHITE) -- Square left rectangle + DrawRectangle(colorsRecs[i].x + 90, colorsRecs[i].y, 10, 100, RAYWHITE) -- Square right rectangle + DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + 90, 100, 10, RAYWHITE) -- Square bottom rectangle + end + end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_drop_files.lua b/examples/core_drop_files.lua new file mode 100644 index 000000000..0a437422d --- /dev/null +++ b/examples/core_drop_files.lua @@ -0,0 +1,63 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Windows drop files +-- +-- This example only works on platforms that support drag & drop (Windows, Linux, OSX) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files") + +local count = 0 +--char **droppedFiles -- ??? + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsFileDropped()) then droppedFiles = GetDroppedFiles(count) end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + if (count == 0) then DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY) + else + DrawText("Dropped files:", 100, 40, 20, DARKGRAY) + + for i = 0, count do + if (i%2 == 0) then DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5)) + else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3)) end + + DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY) + end + + DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY) + end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +ClearDroppedFiles() -- Clear internal buffers + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_gestures_detection.lua b/examples/core_gestures_detection.lua new file mode 100644 index 000000000..9316b9901 --- /dev/null +++ b/examples/core_gestures_detection.lua @@ -0,0 +1,102 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Gestures Detection +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +MAX_GESTURE_STRINGS = 20 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - gestures detection") + +local touchPosition = Vector2(0, 0) +local touchArea = Rectangle(220, 10, screenWidth - 230, screenHeight - 20) + +local gesturesCount = 0 +local gestureStrings = {} + +for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "" end + +local currentGesture = Gestures.NONE +local lastGesture = Gestures.NONE + +--SetGesturesEnabled(0b0000000000001001) -- Enable only some gestures to be detected + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + lastGesture = currentGesture + currentGesture = GetGestureDetected() + touchPosition = GetTouchPosition(0) + + if (CheckCollisionPointRec(touchPosition, touchArea) and (currentGesture ~= Gestures.NONE)) then + if (currentGesture ~= lastGesture) then + -- Store gesture string + if (currentGesture == Gestures.TAP) then gestureStrings[gesturesCount] = "GESTURE TAP" + elseif (currentGesture == Gestures.DOUBLETAP) then gestureStrings[gesturesCount] = "GESTURE DOUBLETAP" + elseif (currentGesture == Gestures.HOLD) then gestureStrings[gesturesCount] = "GESTURE HOLD" + elseif (currentGesture == Gestures.DRAG) then gestureStrings[gesturesCount] = "GESTURE DRAG" + elseif (currentGesture == Gestures.SWIPE_RIGHT) then gestureStrings[gesturesCount] = "GESTURE SWIPE RIGHT" + elseif (currentGesture == Gestures.SWIPE_LEFT) then gestureStrings[gesturesCount] = "GESTURE SWIPE LEFT" + elseif (currentGesture == Gestures.SWIPE_UP) then gestureStrings[gesturesCount] = "GESTURE SWIPE UP" + elseif (currentGesture == Gestures.SWIPE_DOWN) then gestureStrings[gesturesCount] = "GESTURE SWIPE DOWN" + elseif (currentGesture == Gestures.PINCH_IN) then gestureStrings[gesturesCount] = "GESTURE PINCH IN" + elseif (currentGesture == Gestures.PINCH_OUT) then gestureStrings[gesturesCount] = "GESTURE PINCH OUT" + end + + gesturesCount = gesturesCount + 1 + + -- Reset gestures strings + if (gesturesCount >= MAX_GESTURE_STRINGS) then + for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "\0" end + gesturesCount = 0 + end + end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawRectangleRec(touchArea, GRAY) + DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE) + + DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5)) + + for i = 1, gesturesCount do + if ((i - 1)%2 == 0) then DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.5)) + else DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.3)) end + + if (i < gesturesCount) then DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, DARKGRAY) + else DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, MAROON) end + end + + DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY) + DrawText("DETECTED GESTURES", 50, 15, 10, GRAY) + + if (currentGesture ~= GESTURE_NONE) then DrawCircleV(touchPosition, 30, MAROON) end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_input_gamepad.lua b/examples/core_input_gamepad.lua new file mode 100644 index 000000000..eea2532cc --- /dev/null +++ b/examples/core_input_gamepad.lua @@ -0,0 +1,63 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Gamepad input +-- +-- NOTE: This example requires a Gamepad connected to the system +-- raylib is configured to work with Xbox 360 gamepad, check raylib.h for buttons configuration +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input") + +local ballPosition = Vector2(screenWidth/2, screenHeight/2) +local gamepadMovement = Vector2(0, 0) + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsGamepadAvailable(GAMEPAD.PLAYER1)) then + gamepadMovement.x = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_X) + gamepadMovement.y = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_Y) + + ballPosition.x = ballPosition.x + gamepadMovement.x + ballPosition.y = ballPosition.y - gamepadMovement.y + + if (IsGamepadButtonPressed(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_A)) then + ballPosition.x = screenWidth/2 + ballPosition.y = screenHeight/2 + end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY) + + DrawCircleV(ballPosition, 50, MAROON) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_input_keys.lua b/examples/core_input_keys.lua new file mode 100644 index 000000000..523b73175 --- /dev/null +++ b/examples/core_input_keys.lua @@ -0,0 +1,51 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Keyboard input +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window") + +local ballPosition = Vector2(screenWidth/2, screenHeight/2) + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyDown(KEY.RIGHT)) then ballPosition.x = ballPosition.x + 0.8 end + if (IsKeyDown(KEY.LEFT)) then ballPosition.x = ballPosition.x - 0.8 end + if (IsKeyDown(KEY.UP)) then ballPosition.y = ballPosition.y - 0.8 end + if (IsKeyDown(KEY.DOWN)) then ballPosition.y = ballPosition.y + 0.8 end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY) + + DrawCircleV(ballPosition, 50, MAROON) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- diff --git a/examples/core_input_mouse.lua b/examples/core_input_mouse.lua new file mode 100644 index 000000000..35ca8e738 --- /dev/null +++ b/examples/core_input_mouse.lua @@ -0,0 +1,54 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Mouse input +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input") + +local ballPosition = Vector2(-100.0, -100.0) +local ballColor = DARKBLUE + +SetTargetFPS(60) -- Set target frames-per-second +----------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + ------------------------------------------------------------------------------------ + ballPosition = GetMousePosition() + + if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then ballColor = MAROON + elseif (IsMouseButtonPressed(MOUSE.MIDDLE_BUTTON)) then ballColor = LIME + elseif (IsMouseButtonPressed(MOUSE.RIGHT_BUTTON)) then ballColor = DARKBLUE + end + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawCircleV(ballPosition, 40, ballColor) + + DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY) + + EndDrawing() + ------------------------------------------------------------------------------------ +end + +-- De-Initialization +---------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +---------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_mouse_wheel.lua b/examples/core_mouse_wheel.lua new file mode 100644 index 000000000..92e0a160b --- /dev/null +++ b/examples/core_mouse_wheel.lua @@ -0,0 +1,50 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] examples - Mouse wheel +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel") + +local boxPositionY = screenHeight/2 - 40 +local scrollSpeed = 4 -- Scrolling speed in pixels + +SetTargetFPS(60) -- Set target frames-per-second +---------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + ------------------------------------------------------------------------------------ + boxPositionY = boxPositionY - (GetMouseWheelMove()*scrollSpeed) + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON) + + DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY) + DrawText(string.format("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY) + + EndDrawing() + ------------------------------------------------------------------------------------ +end + +-- De-Initialization +---------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +---------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_oculus_rift.lua b/examples/core_oculus_rift.lua new file mode 100644 index 000000000..2626d1783 --- /dev/null +++ b/examples/core_oculus_rift.lua @@ -0,0 +1,73 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Oculus Rift CV1 +-- +-- NOTE: Example requires linkage with LibOVR +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 1080 +local screenHeight = 600 + +-- NOTE: screenWidth/screenHeight should match VR device aspect ratio + +InitWindow(screenWidth, screenHeight, "raylib [core] example - oculus rift") + +-- NOTE: If device is not available, it fallbacks to default device (simulator) +InitVrDevice(VrDevice.OCULUS_RIFT_CV1) -- Init VR device (Oculus Rift CV1) + +-- Define the camera to look into our 3d world +local camera = {} +camera.position = Vector3(5.0, 5.0, 5.0) -- Camera position +camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point +camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target) +camera.fovy = 60.0 -- Camera field-of-view Y + +local cubePosition = Vector3(0.0, 0.0, 0.0) + +SetTargetFPS(90) -- Set our game to run at 90 frames-per-second +---------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + ------------------------------------------------------------------------------------ + UpdateVrTracking() + + if (IsKeyPressed(KEY.SPACE)) then ToggleVrMode() end + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawCube(cubePosition, 2.0, 2.0, 2.0, RED) + DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON) + + DrawGrid(10, 1.0) + + End3dMode() + + DrawFPS(10, 10) + + EndDrawing() + ------------------------------------------------------------------------------------ +end + +-- De-Initialization +---------------------------------------------------------------------------------------- +CloseVrDevice() -- Close VR device + +CloseWindow() -- Close window and OpenGL context +---------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_random_values.lua b/examples/core_random_values.lua new file mode 100644 index 000000000..b80ab9e2b --- /dev/null +++ b/examples/core_random_values.lua @@ -0,0 +1,56 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Generate random values +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values") + +local framesCounter = 0 -- Variable used to count frames + +local randValue = GetRandomValue(-8, 5) -- Get a random integer number between -8 and 5 (both included) + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +---------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + ------------------------------------------------------------------------------------ + framesCounter = framesCounter + 1 + + -- Every two seconds (120 frames) a new random value is generated + if (((framesCounter/120)%2) == 1) then + randValue = GetRandomValue(-8, 5) + framesCounter = 0 + end + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON) + + DrawText(string.format("%i", randValue), 360, 180, 80, LIGHTGRAY) + + EndDrawing() + ------------------------------------------------------------------------------------ +end + +-- De-Initialization +---------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +---------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_storage_values.lua b/examples/core_storage_values.lua new file mode 100644 index 000000000..878b90e40 --- /dev/null +++ b/examples/core_storage_values.lua @@ -0,0 +1,74 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - Storage save/load values +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- NOTE: Storage positions must start with 0, directly related to file memory layout +STORAGE_SCORE = 0 +STORAGE_HISCORE = 1 + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values") + +local score = 0 +local hiscore = 0 + +local framesCounter = 0 + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyPressed(KEY.R)) then + score = GetRandomValue(1000, 2000) + hiscore = GetRandomValue(2000, 4000) + end + + if (IsKeyPressed(KEY.ENTER)) then + StorageSaveValue(STORAGE_SCORE, score) + StorageSaveValue(STORAGE_HISCORE, hiscore) + elseif (IsKeyPressed(KEY.SPACE)) then + -- NOTE: If requested position could not be found, value 0 is returned + score = StorageLoadValue(STORAGE_SCORE) + hiscore = StorageLoadValue(STORAGE_HISCORE) + end + + framesCounter = framesCounter + 1 + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText(string.format("SCORE: %i", score), 280, 130, 40, MAROON) + DrawText(string.format("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK) + + DrawText(string.format("frames: %i", framesCounter), 10, 10, 20, LIME) + + DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY) + DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY) + DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/core_world_screen.lua b/examples/core_world_screen.lua new file mode 100644 index 000000000..ebad41f87 --- /dev/null +++ b/examples/core_world_screen.lua @@ -0,0 +1,69 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [core] example - World to screen +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local cubePosition = Vector3(0.0, 0.0, 0.0) + +local cubeScreenPosition = Vector2(0, 0) + +SetCameraMode(CameraMode.FREE) -- Set a free camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +---------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + ------------------------------------------------------------------------------------ + camera = UpdateCamera(camera) -- Update internal camera and our camera + + -- Calculate cube screen space position (with a little offset to be in top) + cubeScreenPosition = GetWorldToScreen(Vector3(cubePosition.x, cubePosition.y + 2.5, cubePosition.z), camera) + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawCube(cubePosition, 2.0, 2.0, 2.0, RED) + DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON) + + DrawGrid(10, 1.0) + + End3dMode() + + DrawText("Enemy: 100 / 100", cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20)//2, cubeScreenPosition.y, 20, BLACK) + DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20))//2, 25, 20, GRAY) + + EndDrawing() + ------------------------------------------------------------------------------------ +end + +-- De-Initialization +---------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +---------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_billboard.lua b/examples/models_billboard.lua new file mode 100644 index 000000000..22f3a6c36 --- /dev/null +++ b/examples/models_billboard.lua @@ -0,0 +1,65 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Drawing billboards +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(5.0, 4.0, 5.0), Vector3(0.0, 2.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local bill = LoadTexture("resources/billboard.png") -- Our texture billboard +local billPosition = Vector3(0.0, 2.0, 0.0) -- Position where draw billboard + +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawBillboard(camera, bill, billPosition, 2.0f, WHITE) + + DrawGrid(10, 1.0f) -- Draw a grid + + End3dMode() + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(bill) -- Unload texture + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_box_collisions.lua b/examples/models_box_collisions.lua new file mode 100644 index 000000000..f2cbb154d --- /dev/null +++ b/examples/models_box_collisions.lua @@ -0,0 +1,115 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Detect basic 3d collisions (box vs sphere vs box) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local playerPosition = Vector3(0.0, 1.0, 2.0) +local playerSize = Vector3(1.0, 2.0, 1.0) +local playerColor = GREEN + +local enemyBoxPos = Vector3(-4.0, 1.0, 0.0) +local enemyBoxSize = Vector3(2.0, 2.0, 2.0) + +local enemySpherePos = Vector3(4.0, 0.0, 0.0) +local enemySphereSize = 1.5 + +local collision = false + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + + -- Move player + if (IsKeyDown(KEY.RIGHT)) then playerPosition.x = playerPosition.x + 0.2f end + elseif (IsKeyDown(KEY.LEFT)) then playerPosition.x = playerPosition.x - 0.2f end + elseif (IsKeyDown(KEY.DOWN)) then playerPosition.z = playerPosition.z + 0.2f end + elseif (IsKeyDown(KEY.UP)) then playerPosition.z = playerPosition.z - 0.2f end + + collision = false + + -- Check collisions player vs enemy-box + if (CheckCollisionBoxes( + BoundingBox(Vector3(playerPosition.x - playerSize.x/2, + playerPosition.y - playerSize.y/2, + playerPosition.z - playerSize.z/2), + Vector3(playerPosition.x + playerSize.x/2, + playerPosition.y + playerSize.y/2, + playerPosition.z + playerSize.z/2)), + BoundingBox(Vector3(enemyBoxPos.x - enemyBoxSize.x/2, + enemyBoxPos.y - enemyBoxSize.y/2, + enemyBoxPos.z - enemyBoxSize.z/2), + Vector3(enemyBoxPos.x + enemyBoxSize.x/2, + enemyBoxPos.y + enemyBoxSize.y/2, + enemyBoxPos.z + enemyBoxSize.z/2))) then collision = true + end + + -- Check collisions player vs enemy-sphere + if (CheckCollisionBoxSphere( + BoundingBox(Vector3(playerPosition.x - playerSize.x/2, + playerPosition.y - playerSize.y/2, + playerPosition.z - playerSize.z/2), + Vector3(playerPosition.x + playerSize.x/2, + playerPosition.y + playerSize.y/2, + playerPosition.z + playerSize.z/2)), + enemySpherePos, enemySphereSize)) then collision = true + end + + if (collision) then playerColor = RED + else playerColor = GREEN end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + -- Draw enemy-box + DrawCube(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, GRAY) + DrawCubeWires(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, DARKGRAY) + + -- Draw enemy-sphere + DrawSphere(enemySpherePos, enemySphereSize, GRAY) + DrawSphereWires(enemySpherePos, enemySphereSize, 16, 16, DARKGRAY) + + -- Draw player + DrawCubeV(playerPosition, playerSize, playerColor) + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawText("Move player with cursors to collide", 220, 40, 20, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_cubicmap.lua b/examples/models_cubicmap.lua new file mode 100644 index 000000000..293f1b3a4 --- /dev/null +++ b/examples/models_cubicmap.lua @@ -0,0 +1,79 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Cubicmap loading and drawing +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(16.0, 14.0, 16.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local image = LoadImage("resources/cubicmap.png") -- Load cubicmap image (RAM) +local cubicmap = LoadTextureFromImage(image) -- Convert image to texture to display (VRAM) +local map = LoadCubicmap(image) -- Load cubicmap model (generate model from image) + +-- NOTE: By default each cube is mapped to one part of texture atlas +local texture = LoadTexture("resources/cubicmap_atlas.png") -- Load map texture +map.material.texDiffuse = texture -- Set map diffuse texture + +local mapPosition = Vector3(-16.0, 0.0, -8.0) -- Set model position + +UnloadImage(image) -- Unload cubesmap image from RAM, already uploaded to VRAM + +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position +SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawModel(map, mapPosition, 1.0, WHITE) + + End3dMode() + + DrawTextureEx(cubicmap, (Vector2){ screenWidth - cubicmap.width*4 - 20, 20 }, 0.0, 4.0, WHITE) + DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN) + + DrawText("cubicmap image used to", 658, 90, 10, GRAY) + DrawText("generate map 3d model", 658, 104, 10, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(cubicmap) -- Unload cubicmap texture +UnloadTexture(texture) -- Unload map texture +UnloadModel(map) -- Unload map model + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_geometric_shapes.lua b/examples/models_geometric_shapes.lua new file mode 100644 index 000000000..0ce08e9f9 --- /dev/null +++ b/examples/models_geometric_shapes.lua @@ -0,0 +1,67 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) -- ERROR: Lua Error: attempt to index a number value + + DrawCube(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, RED) + DrawCubeWires(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, GOLD) + DrawCubeWires(Vector3(-4.0, 0.0, -2.0), 3.0, 6.0, 2.0, MAROON) + + DrawSphere(Vector3(-1.0, 0.0, -2.0), 1.0, GREEN) + DrawSphereWires(Vector3(1.0, 0.0, 2.0), 2.0, 16, 16, LIME) + + DrawCylinder(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, SKYBLUE) + DrawCylinderWires(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, DARKBLUE) + DrawCylinderWires(Vector3(4.5, -1.0, 2.0), 1.0, 1.0, 2.0, 6, BROWN) + + DrawCylinder(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, GOLD) + DrawCylinderWires(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, PINK) + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_heightmap.lua b/examples/models_heightmap.lua new file mode 100644 index 000000000..f78e3af55 --- /dev/null +++ b/examples/models_heightmap.lua @@ -0,0 +1,73 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Heightmap loading and drawing +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing") + +-- Define our custom camera to look into our 3d world +local camera = Camera(Vector3(18.0, 16.0, 18.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local image = LoadImage("resources/heightmap.png") -- Load heightmap image (RAM) +local texture = LoadTextureFromImage(image) -- Convert image to texture (VRAM) +local map = LoadHeightmap(image, Vector3(16, 8, 16) -- Load heightmap model with defined size +map.material.texDiffuse = texture -- Set map diffuse texture +local mapPosition = Vector3(-8.0, 0.0, -8.0) -- Set model position (depends on model scaling!) + +UnloadImage(image) -- Unload heightmap image from RAM, already uploaded to VRAM + +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +---------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + -- NOTE: Model is scaled to 1/4 of its original size (128x128 units) + DrawModel(map, mapPosition, 1.0, RED) + + DrawGrid(20, 1.0) + + End3dMode() + + DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE) + DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Unload texture +UnloadModel(map) -- Unload model + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/models_obj_loading.lua b/examples/models_obj_loading.lua new file mode 100644 index 000000000..c534ecae6 --- /dev/null +++ b/examples/models_obj_loading.lua @@ -0,0 +1,67 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [models] example - Load and draw a 3d model (OBJ) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) + +local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model +local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture +dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture +local position = Vector3(0.0, 0.0, 0.0) -- Set model position + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- ... + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawModel(dwarf, position, 2.0f, WHITE) -- Draw 3d model with texture + + DrawGrid(10, 1.0f) -- Draw a grid + + DrawGizmo(position) -- Draw gizmo + + End3dMode() + + DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Unload texture +UnloadModel(dwarf) -- Unload model + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/rlua_execute_file.c b/examples/rlua_execute_file.c index b21a44599..762159f39 100644 --- a/examples/rlua_execute_file.c +++ b/examples/rlua_execute_file.c @@ -28,7 +28,58 @@ int main() InitLuaDevice(); //-------------------------------------------------------------------------------------- - ExecuteLuaFile("core_basic_window.lua"); + // ExecuteLuaFile("core_basic_window.lua"); // OK! + // ExecuteLuaFile("core_input_keys.lua"); // OK! + // ExecuteLuaFile("core_input_mouse.lua"); // OK! + // ExecuteLuaFile("core_mouse_wheel.lua"); // OK! + // ExecuteLuaFile("core_input_gamepad.lua"); // OK! + // ExecuteLuaFile("core_random_values.lua"); // OK! + // ExecuteLuaFile("core_color_select.lua"); // OK! + // ExecuteLuaFile("core_drop_files.lua"); // ERROR: GetDroppedFiles() + // ExecuteLuaFile("core_storage_values.lua"); // OK! + // ExecuteLuaFile("core_gestures_detection.lua"); // OK! + // ExecuteLuaFile("core_3d_mode.lua"); // ERROR: Lua Error: attempt to index a number value - Begin3dMode() + // ExecuteLuaFile("core_3d_picking.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("core_3d_camera_free.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("core_3d_camera_first_person.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("core_2d_camera.lua"); // ERROR: Lua Error: attempt to index a number value - Begin2dMode() + // ExecuteLuaFile("core_world_screen.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("core_oculus_rift.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("shapes_logo_raylib.lua"); // OK! + // ExecuteLuaFile("shapes_basic_shapes.lua"); // OK! + // ExecuteLuaFile("shapes_colors_palette.lua"); // OK! + // ExecuteLuaFile("shapes_logo_raylib_anim.lua"); // OK! NOTE: Use lua string.sub() instead of raylib SubText() + // ExecuteLuaFile("textures_logo_raylib.lua"); // OK! + // ExecuteLuaFile("textures_image_loading.lua"); // OK! + // ExecuteLuaFile("textures_rectangle.lua"); // OK! + // ExecuteLuaFile("textures_srcrec_dstrec.lua"); // OK! + // ExecuteLuaFile("textures_to_image.lua"); // OK! + // ExecuteLuaFile("textures_raw_data.lua"); // ERROR: Lua Error: attempt to index a number value + // ExecuteLuaFile("textures_formats_loading.lua"); // ISSUE: texture.id not exposed to be checked + // ExecuteLuaFile("textures_particles_trail_blending.lua"); // ERROR: Using struct + // ExecuteLuaFile("textures_image_processing.lua"); // ERROR: GetImageData() --> UpdateTexture() + // ExecuteLuaFile("textures_image_drawing.lua"); // OK! + // ExecuteLuaFile("text_sprite_fonts.lua"); // OK! + // ExecuteLuaFile("text_bmfont_ttf.lua"); // OK! + // ExecuteLuaFile("text_rbmf_fonts.lua"); // ERROR: Lua Error: attempt to index a nil value + // ExecuteLuaFile("text_format_text.lua"); // OK! NOTE: Use lua string.format() instead of raylib FormatText() + // ExecuteLuaFile("text_font_select.lua"); // OK! + // ExecuteLuaFile("text_writing_anim.lua"); // ERROR: SubText() + // ExecuteLuaFile("models_geometric_shapes.lua"); // ERROR: Lua Error: attempt to index a number value - Begin3dMode(camera) + // ExecuteLuaFile("models_box_collisions.lua"); // + // ExecuteLuaFile("models_billboard.lua"); // + // ExecuteLuaFile("models_obj_loading.lua"); // + // ExecuteLuaFile("models_heightmap.lua"); // + // ExecuteLuaFile("models_cubicmap.lua"); // + // ExecuteLuaFile("shaders_model_shader.lua"); // + // ExecuteLuaFile("shaders_shapes_textures.lua"); // + // ExecuteLuaFile("shaders_custom_uniform.lua"); // + // ExecuteLuaFile("shaders_postprocessing.lua"); // + // ExecuteLuaFile("shaders_standard_lighting.lua"); // + // ExecuteLuaFile("audio_sound_loading.lua"); // OK! + // ExecuteLuaFile("audio_music_stream.lua"); // OK! + // ExecuteLuaFile("audio_module_playing.lua"); // ERROR: Using struct + // ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream() // De-Initialization //-------------------------------------------------------------------------------------- diff --git a/examples/shaders_custom_uniform.lua b/examples/shaders_custom_uniform.lua new file mode 100644 index 000000000..dbb672e62 --- /dev/null +++ b/examples/shaders_custom_uniform.lua @@ -0,0 +1,115 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shaders] example - Apply a postprocessing shader and connect a custom uniform variable +-- +-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support, +-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version. +-- +-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example +-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders +-- raylib comes with shaders ready for both versions, check raylib/shaders install folder +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available) + +InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) + +local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model +local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map) +dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture + +local position = Vector3(0.0, 0.0, 0.0) -- Set model position + +local shader = LoadShader("resources/shaders/glsl330/base.vs", + "resources/shaders/glsl330/swirl.fs") -- Load postpro shader + +-- Get variable (uniform) location on the shader to connect with the program +-- NOTE: If uniform variable could not be found in the shader, function returns -1 +local swirlCenterLoc = GetShaderLocation(shader, "center") + +local swirlCenter = { screenWidth/2, screenHeight/2 } + +-- Create a RenderTexture2D to be used for render to texture +local target = LoadRenderTexture(screenWidth, screenHeight) + +-- Setup orbital camera +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + local mousePosition = GetMousePosition() + + swirlCenter[0] = mousePosition.x + swirlCenter[1] = screenHeight - mousePosition.y + + -- Send new value to the shader to be used on drawing + SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2) + + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + BeginTextureMode(target) -- Enable drawing to texture + + Begin3dMode(camera) + + DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawText("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED) + + EndTextureMode() -- End drawing to texture (now we have a texture available for next passes) + + BeginShaderMode(shader) + + -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom) + DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE) + + EndShaderMode() + + DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadShader(shader) -- Unload shader +UnloadTexture(texture) -- Unload texture +UnloadModel(dwarf) -- Unload model +UnloadRenderTexture(target) -- Unload render texture + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shaders_model_shader.lua b/examples/shaders_model_shader.lua new file mode 100644 index 000000000..deaca11c9 --- /dev/null +++ b/examples/shaders_model_shader.lua @@ -0,0 +1,85 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shaders] example - Apply a shader to a 3d model +-- +-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support, +-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version. +-- +-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example +-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders +-- raylib comes with shaders ready for both versions, check raylib/shaders install folder +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available) + +InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) + +local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model +local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture +local shader = LoadShader("resources/shaders/glsl330/base.vs", + "resources/shaders/glsl330/grayscale.fs") -- Load model shader + +dwarf.material.shader = shader -- Set shader effect to 3d model +dwarf.material.texDiffuse = texture -- Bind texture to model + +local position = Vector3(0.0, 0.0, 0.0) -- Set model position + +-- Setup orbital camera +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadShader(shader) -- Unload shader +UnloadTexture(texture) -- Unload texture +UnloadModel(dwarf) -- Unload model + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shaders_postprocessing.lua b/examples/shaders_postprocessing.lua new file mode 100644 index 000000000..9e4dfa006 --- /dev/null +++ b/examples/shaders_postprocessing.lua @@ -0,0 +1,101 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shaders] example - Apply a postprocessing shader to a scene +-- +-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support, +-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version. +-- +-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example +-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders +-- raylib comes with shaders ready for both versions, check raylib/shaders install folder +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available) + +InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) + +local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model +local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map) +dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture + +local position = Vector3(0.0, 0.0, 0.0) -- Set model position + +local shader = LoadShader("resources/shaders/glsl330/base.vs", + "resources/shaders/glsl330/bloom.fs") -- Load postpro shader + +-- Create a RenderTexture2D to be used for render to texture +local target = LoadRenderTexture(screenWidth, screenHeight) + +-- Setup orbital camera +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + BeginTextureMode(target) -- Enable drawing to texture + + Begin3dMode(camera) + + DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawText("HELLO POSTPROCESSING!", 70, 190, 50, RED) + + EndTextureMode() -- End drawing to texture (now we have a texture available for next passes) + + BeginShaderMode(shader) + + -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom) + DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE) + + EndShaderMode() + + DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, DARKGRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +} + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadShader(shader) -- Unload shader +UnloadTexture(texture) -- Unload texture +UnloadModel(dwarf) -- Unload model +UnloadRenderTexture(target) -- Unload render texture + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shaders_shapes_textures.lua b/examples/shaders_shapes_textures.lua new file mode 100644 index 000000000..0adbefd2e --- /dev/null +++ b/examples/shaders_shapes_textures.lua @@ -0,0 +1,101 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shaders] example - Apply a shader to some shape or texture +-- +-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support, +-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version. +-- +-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example +-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders +-- raylib comes with shaders ready for both versions, check raylib/shaders install folder +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders") + +local sonic = LoadTexture("resources/texture_formats/sonic.png") + +-- NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version +local shader = LoadShader("resources/shaders/glsl330/base.vs", + "resources/shaders/glsl330/grayscale.fs") + +-- Shader usage is also different than models/postprocessing, shader is just activated when required + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + -- Start drawing with default shader + + DrawText("USING DEFAULT SHADER", 20, 40, 10, RED) + + DrawCircle(80, 120, 35, DARKBLUE) + DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE) + DrawCircleLines(80, 340, 80, DARKBLUE) + + + -- Activate our custom shader to be applied on next shapes/textures drawings + BeginShaderMode(shader) + + DrawText("USING CUSTOM SHADER", 190, 40, 10, RED) + + DrawRectangle(250 - 60, 90, 120, 60, RED) + DrawRectangleGradient(250 - 90, 170, 180, 130, MAROON, GOLD) + DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE) + + -- Activate our default shader for next drawings + EndShaderMode() + + DrawText("USING DEFAULT SHADER", 370, 40, 10, RED) + + DrawTriangle(Vector2(430, 80), + Vector2(430 - 60, 150), + Vector2(430 + 60, 150), VIOLET) + + DrawTriangleLines(Vector2(430, 160), + Vector2(430 - 20, 230), + Vector2(430 + 20, 230), DARKBLUE) + + DrawPoly(Vector2(430, 320), 6, 80, 0, BROWN) + + -- Activate our custom shader to be applied on next shapes/textures drawings + BeginShaderMode(shader) + + DrawTexture(sonic, 380, -10, WHITE) -- Using custom shader + + -- Activate our default shader for next drawings + EndShaderMode() + + EndDrawing() + --------------------------------------------------------------------------------------- +} + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadShader(shader) -- Unload shader +UnloadTexture(sonic) -- Unload texture + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shaders_standard_lighting.lua b/examples/shaders_standard_lighting.lua new file mode 100644 index 000000000..e8171a5f4 --- /dev/null +++ b/examples/shaders_standard_lighting.lua @@ -0,0 +1,114 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shaders] example - Standard lighting (materials and lights) +-- +-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support, +-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version. +-- +-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example +-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders +-- raylib comes with shaders ready for both versions, check raylib/shaders install folder +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available) + +InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader") + +-- Define the camera to look into our 3d world +local camera = Camera(Vector3(4.0, 4.0, 4.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) +local position = Vector3(0.0, 0.0, 0.0) -- Set model position + +local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model + +local material = LoadStandardMaterial() + +material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model diffuse texture +material.texNormal = LoadTexture("resources/model/dwarf_normal.png") -- Load model normal texture +material.texSpecular = LoadTexture("resources/model/dwarf_specular.png") -- Load model specular texture +material.colDiffuse = WHITE +material.colAmbient = (Color){0, 0, 10, 255} +material.colSpecular = WHITE +material.glossiness = 50.0f + +dwarf.material = material -- Apply material to model + +local spotLight = CreateLight(LIGHT_SPOT, (Vector3){3.0f, 5.0f, 2.0f}, (Color){255, 255, 255, 255}) +spotLight->target = (Vector3){0.0f, 0.0f, 0.0f} +spotLight->intensity = 2.0f +spotLight->diffuse = (Color){255, 100, 100, 255} +spotLight->coneAngle = 60.0f + +local dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3){0.0f, -3.0f, -3.0f}, (Color){255, 255, 255, 255}) +dirLight->target = (Vector3){1.0f, -2.0f, -2.0f} +dirLight->intensity = 2.0f +dirLight->diffuse = (Color){100, 255, 100, 255} + +local pointLight = CreateLight(LIGHT_POINT, (Vector3){0.0f, 4.0f, 5.0f}, (Color){255, 255, 255, 255}) +pointLight->intensity = 2.0f +pointLight->diffuse = (Color){100, 100, 255, 255} +pointLight->radius = 3.0f + +-- Setup orbital camera +SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraPosition(camera.position) -- Set internal camera position to match our camera position +SetCameraTarget(camera.target) -- Set internal camera target to match our camera target + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + UpdateCamera(&camera) -- Update internal camera and our camera + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + Begin3dMode(camera) + + DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture + + DrawLight(spotLight) -- Draw spot light + DrawLight(dirLight) -- Draw directional light + DrawLight(pointLight) -- Draw point light + + DrawGrid(10, 1.0) -- Draw a grid + + End3dMode() + + DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY) + + DrawFPS(10, 10) + + EndDrawing() + --------------------------------------------------------------------------------------- +} + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadMaterial(material) -- Unload material and assigned textures +UnloadModel(dwarf) -- Unload model + +-- Destroy all created lights +DestroyLight(pointLight) +DestroyLight(dirLight) +DestroyLight(spotLight) + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shapes_basic_shapes.lua b/examples/shapes_basic_shapes.lua new file mode 100644 index 000000000..cc943ba34 --- /dev/null +++ b/examples/shapes_basic_shapes.lua @@ -0,0 +1,64 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shapes] example - Draw basic shapes 2d (rectangle, circle, line...) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing") + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY) + + DrawLine(18, 42, screenWidth - 18, 42, BLACK) + + DrawCircle(screenWidth/4, 120, 35, DARKBLUE) + DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE) + DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE) + + DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED) + DrawRectangleGradient(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD) + DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE) + + DrawTriangle(Vector2(screenWidth/4*3, 80), + Vector2(screenWidth/4*3 - 60, 150), + Vector2(screenWidth/4*3 + 60, 150), VIOLET) + + DrawTriangleLines(Vector2(screenWidth/4*3, 160), + Vector2(screenWidth/4*3 - 20, 230), + Vector2(screenWidth/4*3 + 20, 230), DARKBLUE) + + DrawPoly(Vector2(screenWidth/4*3, 320), 6, 80, 0, BROWN) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shapes_colors_palette.lua b/examples/shapes_colors_palette.lua new file mode 100644 index 000000000..e884cd3ea --- /dev/null +++ b/examples/shapes_colors_palette.lua @@ -0,0 +1,89 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shapes] example - Draw raylib custom color palette +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette") + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("raylib color palette", 28, 42, 20, BLACK) + + DrawRectangle(26, 80, 100, 100, DARKGRAY) + DrawRectangle(26, 188, 100, 100, GRAY) + DrawRectangle(26, 296, 100, 100, LIGHTGRAY) + DrawRectangle(134, 80, 100, 100, MAROON) + DrawRectangle(134, 188, 100, 100, RED) + DrawRectangle(134, 296, 100, 100, PINK) + DrawRectangle(242, 80, 100, 100, ORANGE) + DrawRectangle(242, 188, 100, 100, GOLD) + DrawRectangle(242, 296, 100, 100, YELLOW) + DrawRectangle(350, 80, 100, 100, DARKGREEN) + DrawRectangle(350, 188, 100, 100, LIME) + DrawRectangle(350, 296, 100, 100, GREEN) + DrawRectangle(458, 80, 100, 100, DARKBLUE) + DrawRectangle(458, 188, 100, 100, BLUE) + DrawRectangle(458, 296, 100, 100, SKYBLUE) + DrawRectangle(566, 80, 100, 100, DARKPURPLE) + DrawRectangle(566, 188, 100, 100, VIOLET) + DrawRectangle(566, 296, 100, 100, PURPLE) + DrawRectangle(674, 80, 100, 100, DARKBROWN) + DrawRectangle(674, 188, 100, 100, BROWN) + DrawRectangle(674, 296, 100, 100, BEIGE) + + + DrawText("DARKGRAY", 65, 166, 10, BLACK) + DrawText("GRAY", 93, 274, 10, BLACK) + DrawText("LIGHTGRAY", 61, 382, 10, BLACK) + DrawText("MAROON", 186, 166, 10, BLACK) + DrawText("RED", 208, 274, 10, BLACK) + DrawText("PINK", 204, 382, 10, BLACK) + DrawText("ORANGE", 295, 166, 10, BLACK) + DrawText("GOLD", 310, 274, 10, BLACK) + DrawText("YELLOW", 300, 382, 10, BLACK) + DrawText("DARKGREEN", 382, 166, 10, BLACK) + DrawText("LIME", 420, 274, 10, BLACK) + DrawText("GREEN", 410, 382, 10, BLACK) + DrawText("DARKBLUE", 498, 166, 10, BLACK) + DrawText("BLUE", 526, 274, 10, BLACK) + DrawText("SKYBLUE", 505, 382, 10, BLACK) + DrawText("DARKPURPLE", 592, 166, 10, BLACK) + DrawText("VIOLET", 621, 274, 10, BLACK) + DrawText("PURPLE", 620, 382, 10, BLACK) + DrawText("DARKBROWN", 705, 166, 10, BLACK) + DrawText("BROWN", 733, 274, 10, BLACK) + DrawText("BEIGE", 737, 382, 10, BLACK) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shapes_logo_raylib.lua b/examples/shapes_logo_raylib.lua new file mode 100644 index 000000000..4e7f18c42 --- /dev/null +++ b/examples/shapes_logo_raylib.lua @@ -0,0 +1,48 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shapes] example - Draw raylib logo using basic shapes +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes") + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK) + DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE) + DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK) + + DrawText("this is NOT a texture!", 350, 370, 10, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/shapes_logo_raylib_anim.lua b/examples/shapes_logo_raylib_anim.lua new file mode 100644 index 000000000..c6c449956 --- /dev/null +++ b/examples/shapes_logo_raylib_anim.lua @@ -0,0 +1,127 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [shapes] example - raylib logo animation +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation") + +local logoPositionX = screenWidth/2 - 128 +local logoPositionY = screenHeight/2 - 128 + +local framesCounter = 0 +local lettersCount = 0 + +local topSideRecWidth = 16 +local leftSideRecHeight = 16 + +local bottomSideRecWidth = 16 +local rightSideRecHeight = 16 + +local state = 0 -- Tracking animation states (State Machine) +local alpha = 1.0 -- Useful for fading + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (state == 0) then -- State 0: Small box blinking + framesCounter = framesCounter + 1 + + if (framesCounter == 120) then + state = 1 + framesCounter = 0 -- Reset counter... will be used later... + end + elseif (state == 1) then -- State 1: Top and left bars growing + topSideRecWidth = topSideRecWidth + 4 + leftSideRecHeight = leftSideRecHeight + 4 + + if (topSideRecWidth == 256) then state = 2 end + elseif (state == 2) then -- State 2: Bottom and right bars growing + bottomSideRecWidth = bottomSideRecWidth + 4 + rightSideRecHeight = rightSideRecHeight + 4 + + if (bottomSideRecWidth == 256) then state = 3 end + elseif (state == 3) then -- State 3: Letters appearing (one by one) + framesCounter = framesCounter + 1 + + if (framesCounter//12 == 1) then -- Every 12 frames, one more letter! + lettersCount = lettersCount + 1 + framesCounter = 0 + end + + if (lettersCount >= 10) then -- When all letters have appeared, just fade out everything + alpha = alpha - 0.02 + + if (alpha <= 0.0) then + alpha = 0.0 + state = 4 + end + end + elseif (state == 4) then -- State 4: Reset and Replay + if (IsKeyPressed(KEY.R)) then + framesCounter = 0 + lettersCount = 0 + + topSideRecWidth = 16 + leftSideRecHeight = 16 + + bottomSideRecWidth = 16 + rightSideRecHeight = 16 + + alpha = 1.0 + state = 0 -- Return to State 0 + end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + if (state == 0) then + if ((framesCounter//15)%2 == 1) then DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK) end + elseif (state == 1) then + DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK) + DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK) + elseif (state == 2) then + DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK) + DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK) + + DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK) + DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK) + elseif (state == 3) then + DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, Fade(BLACK, alpha)) + DrawRectangle(logoPositionX, logoPositionY + 16, 16, leftSideRecHeight - 32, Fade(BLACK, alpha)) + + DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha)) + DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha)) + + DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha)) + + DrawText(string.sub("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha)) + elseif (state == 4) then DrawText("[R] REPLAY", 340, 200, 20, GRAY) end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_bmfont_ttf.lua b/examples/text_bmfont_ttf.lua new file mode 100644 index 000000000..3b8bf0042 --- /dev/null +++ b/examples/text_bmfont_ttf.lua @@ -0,0 +1,59 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - BMFont and TTF SpriteFonts loading +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading") + +local msgBm = "THIS IS AN AngelCode SPRITE FONT" +local msgTtf = "THIS FONT has been GENERATED from TTF" + +-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required) +local fontBm = LoadSpriteFont("resources/fonts/bmfont.fnt") -- BMFont (AngelCode) +local fontTtf = LoadSpriteFont("resources/fonts/pixantiqua.ttf") -- TTF font + +local fontPosition = Vector2(0, 0) +fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.size, 0).x/2 +fontPosition.y = screenHeight/2 - fontBm.size/2 - 80 + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update variables here... + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTextEx(fontBm, msgBm, fontPosition, fontBm.size, 0, MAROON) + DrawTextEx(fontTtf, msgTtf, Vector2(60.0, 240.0), fontTtf.size, 2, LIME) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadSpriteFont(fontBm) -- AngelCode SpriteFont unloading +UnloadSpriteFont(fontTtf) -- TTF SpriteFont unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_font_select.lua b/examples/text_font_select.lua new file mode 100644 index 000000000..e04f60243 --- /dev/null +++ b/examples/text_font_select.lua @@ -0,0 +1,143 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - Font selector +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - font selector") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) +local fonts = {} -- SpriteFont array + +fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf") -- SpriteFont loading +fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf") -- SpriteFont loading +fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf") -- SpriteFont loading +fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf") -- SpriteFont loading +fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf") -- SpriteFont loading +fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf") -- SpriteFont loading +fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf") -- SpriteFont loading +fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- SpriteFont loading + +local currentFont = 1 -- Selected font + +local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED } + +local fontNames = { "[1] Alagard", "[2] PixelPlay", "[3] MECHA", "[4] Setback", + "[5] Romulus", "[6] PixAntiqua", "[7] Alpha Beta", "[8] Jupiter Crash" } + +local text = "THIS is THE FONT you SELECTED!" -- Main text + +local textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1) + +local mousePoint + +local btnNextOutColor = DARKBLUE -- Button color (outside line) +local btnNextInColor = SKYBLUE -- Button color (inside) + +local framesCounter = 0 -- Useful to count frames button is 'active' = clicked + +local positionY = 180 -- Text selector and button Y position + +local btnNextRec = Rectangle(673, positionY, 109, 44) -- Button rectangle (useful for collision) + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + + -- Keyboard-based font selection (easy) + if (IsKeyPressed(KEY.RIGHT)) then + if (currentFont < 8) then currentFont = currentFont + 1 end + end + + if (IsKeyPressed(KEY.LEFT)) then + if (currentFont > 1) then currentFont = currentFont - 1 end + end + + if (IsKeyPressed(KEY.ZERO)) then currentFont = 0 + elseif (IsKeyPressed(KEY.ONE)) then currentFont = 1 + elseif (IsKeyPressed(KEY.TWO)) then currentFont = 2 + elseif (IsKeyPressed(KEY.THREE)) then currentFont = 3 + elseif (IsKeyPressed(KEY.FOUR)) then currentFont = 4 + elseif (IsKeyPressed(KEY.FIVE)) then currentFont = 5 + elseif (IsKeyPressed(KEY.SIX)) then currentFont = 6 + elseif (IsKeyPressed(KEY.SEVEN)) then currentFont = 7 + end + + -- Mouse-based font selection (NEXT button logic) + mousePoint = GetMousePosition() + + if (CheckCollisionPointRec(mousePoint, btnNextRec)) then + -- Mouse hover button logic + if (framesCounter == 0) then + btnNextOutColor = DARKPURPLE + btnNextInColor = PURPLE + end + + if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) then + framesCounter = 20 -- Frames button is 'active' + btnNextOutColor = MAROON + btnNextInColor = RED + end + else + -- Mouse not hover button + btnNextOutColor = DARKBLUE + btnNextInColor = SKYBLUE + end + + if (framesCounter > 0) then framesCounter = framesCounter - 1 end + + if (framesCounter == 1) then -- We change font on frame 1 + currentFont = currentFont + 1 + if (currentFont > 7) then currentFont = 0 end + end + + -- Text measurement for better positioning on screen + textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1) + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("font selector - use arroys, button or numbers", 160, 80, 20, DARKGRAY) + DrawLine(120, 120, 680, 120, DARKGRAY) + + DrawRectangle(18, positionY, 644, 44, DARKGRAY) + DrawRectangle(20, positionY + 2, 640, 40, LIGHTGRAY) + DrawText(fontNames[currentFont], 30, positionY + 13, 20, BLACK) + DrawText("< >", 610, positionY + 8, 30, BLACK) + + DrawRectangleRec(btnNextRec, btnNextOutColor) + DrawRectangle(675, positionY + 2, 105, 40, btnNextInColor) + DrawText("NEXT", 700, positionY + 13, 20, btnNextOutColor) + + DrawTextEx(fonts[currentFont], text, Vector2(screenWidth/2 - textSize.x/2, + 260 + (70 - textSize.y)/2), fonts[currentFont].size*3, + 1, colors[currentFont]) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +for i = 1, 8 do UnloadSpriteFont(fonts[i]) end -- SpriteFont(s) unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_format_text.lua b/examples/text_format_text.lua new file mode 100644 index 000000000..ba121db31 --- /dev/null +++ b/examples/text_format_text.lua @@ -0,0 +1,54 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - Text formatting +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting") + +local score = 100020 +local hiscore = 200450 +local lives = 5 + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText(string.format("Score: %08i", score), 200, 80, 20, RED) + + DrawText(string.format("HiScore: %08i", hiscore), 200, 120, 20, GREEN) + + DrawText(string.format("Lives: %02i", lives), 200, 160, 40, BLUE) + + DrawText(string.format("Elapsed Time: %02.02f ms", GetFrameTime()*1000), 200, 220, 20, BLACK) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_rbmf_fonts.lua b/examples/text_rbmf_fonts.lua new file mode 100644 index 000000000..d89e40715 --- /dev/null +++ b/examples/text_rbmf_fonts.lua @@ -0,0 +1,87 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - raylib bitmap font (rbmf) loading and usage +-- +-- NOTE: raylib is distributed with some free to use fonts (even for commercial pourposes!) +-- To view details and credits for those fonts, check raylib license file +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - rBMF fonts") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) +local fonts = {} + +fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf") -- rBMF font loading +fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf") -- rBMF font loading +fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf") -- rBMF font loading +fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf") -- rBMF font loading +fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf") -- rBMF font loading +fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf") -- rBMF font loading +fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf") -- rBMF font loading +fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- rBMF font loading + +local messages = { "ALAGARD FONT designed by Hewett Tsoi", + "PIXELPLAY FONT designed by Aleksander Shevchuk", + "MECHA FONT designed by Captain Falcon", + "SETBACK FONT designed by Brian Kent (AEnigma)", + "ROMULUS FONT designed by Hewett Tsoi", + "PIXANTIQUA FONT designed by Gerhard Grossmann", + "ALPHA_BETA FONT designed by Brian Kent (AEnigma)", + "JUPITER_CRASH FONT designed by Brian Kent (AEnigma)" } + +local spacings = { 2, 4, 8, 4, 3, 4, 4, 1 } + +local positions = {} + +for i = 1, 8 do + positions[i] = Vector2(0, 0) + positions[i].x = screenWidth/2 - MeasureTextEx(fonts[i], messages[i], fonts[i].size*2, spacings[i]).x/2 + positions[i].y = 60 + fonts[i].size + 50*i +end + +local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD } + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("free fonts included with raylib", 250, 20, 20, DARKGRAY) + DrawLine(220, 50, 590, 50, DARKGRAY) + + for i = 1, 8 do + DrawTextEx(fonts[i], messages[i], positions[i], fonts[i].size*2, spacings[i], colors[i]) + end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +for i = 1, 8 do UnloadSpriteFont(fonts[i]) end -- SpriteFont unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_sprite_fonts.lua b/examples/text_sprite_fonts.lua new file mode 100644 index 000000000..341e2ffe2 --- /dev/null +++ b/examples/text_sprite_fonts.lua @@ -0,0 +1,72 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - SpriteFont loading and usage +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage") + +local msg1 = "THIS IS A custom SPRITE FONT..." +local msg2 = "...and this is ANOTHER CUSTOM font..." +local msg3 = "...and a THIRD one! GREAT! :D" + +-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required) +local font1 = LoadSpriteFont("resources/fonts/custom_mecha.png") -- SpriteFont loading +local font2 = LoadSpriteFont("resources/fonts/custom_alagard.png") -- SpriteFont loading +local font3 = LoadSpriteFont("resources/fonts/custom_jupiter_crash.png") -- SpriteFont loading + +local fontPosition1 = Vector2(0, 0) +local fontPosition2 = Vector2(0, 0) +local fontPosition3 = Vector2(0, 0) + +fontPosition1.x = screenWidth/2 - MeasureTextEx(font1, msg1, font1.size, -3).x/2 +fontPosition1.y = screenHeight/2 - font1.size/2 - 80 + +fontPosition2.x = screenWidth/2 - MeasureTextEx(font2, msg2, font2.size, -2).x/2 +fontPosition2.y = screenHeight/2 - font2.size/2 - 10 + +fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.size, 2).x/2 +fontPosition3.y = screenHeight/2 - font3.size/2 + 50 + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update variables here... + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTextEx(font1, msg1, fontPosition1, font1.size, -3, WHITE) + DrawTextEx(font2, msg2, fontPosition2, font2.size, -2, WHITE) + DrawTextEx(font3, msg3, fontPosition3, font3.size, 2, WHITE) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadSpriteFont(font1) -- SpriteFont unloading +UnloadSpriteFont(font2) -- SpriteFont unloading +UnloadSpriteFont(font3) -- SpriteFont unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/text_writing_anim.lua b/examples/text_writing_anim.lua new file mode 100644 index 000000000..37f1efbad --- /dev/null +++ b/examples/text_writing_anim.lua @@ -0,0 +1,52 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [text] example - Text Writing Animation +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim") + +local message = "This sample illustrates a text writing\nanimation effect! Check it out! )" + +local framesCounter = 0 + +SetTargetFPS(60) -- Set target frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + framesCounter = framesCounter + 1 + + if (IsKeyPressed(KEY.ENTER)) then framesCounter = 0 end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText(SubText(message, 0, framesCounter/10), 210, 160, 20, MAROON) + + DrawText("PRESS [ENTER] to RESTART!", 240, 280, 20, LIGHTGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_formats_loading.lua b/examples/textures_formats_loading.lua new file mode 100644 index 000000000..1ce10492d --- /dev/null +++ b/examples/textures_formats_loading.lua @@ -0,0 +1,217 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - texture formats loading (compressed and uncompressed) +-- +-- NOTE: This example requires raylib OpenGL 3.3+ or ES2 versions for compressed textures, +-- OpenGL 1.1 does not support compressed textures, only uncompressed ones. +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +NUM_TEXTURES = 24 + +PNG_R8G8B8A8 = 1 +PVR_GRAYSCALE = 2 +PVR_GRAY_ALPHA = 3 +PVR_R5G6B5 = 4 +PVR_R5G5B5A1 = 5 +PVR_R4G4B4A4 = 6 +DDS_R5G6B5 = 7 +DDS_R5G5B5A1 = 8 +DDS_R4G4B4A4 = 9 +DDS_R8G8B8A8 = 10 +DDS_DXT1_RGB = 11 +DDS_DXT1_RGBA = 12 +DDS_DXT3_RGBA = 13 +DDS_DXT5_RGBA = 14 +PKM_ETC1_RGB = 15 +PKM_ETC2_RGB = 16 +PKM_ETC2_EAC_RGBA = 17 +KTX_ETC1_RGB = 18 +KTX_ETC2_RGB = 19 +KTX_ETC2_EAC_RGBA = 20 +ASTC_4x4_LDR = 21 +ASTC_8x8_LDR = 22 +PVR_PVRT_RGB = 23 +PVR_PVRT_RGBA = 24 + +local formatText = { + "PNG_R8G8B8A8", + "PVR_GRAYSCALE", + "PVR_GRAY_ALPHA", + "PVR_R5G6B5", + "PVR_R5G5B5A1", + "PVR_R4G4B4A4", + "DDS_R5G6B5", + "DDS_R5G5B5A1", + "DDS_R4G4B4A4", + "DDS_R8G8B8A8", + "DDS_DXT1_RGB", + "DDS_DXT1_RGBA", + "DDS_DXT3_RGBA", + "DDS_DXT5_RGBA", + "PKM_ETC1_RGB", + "PKM_ETC2_RGB", + "PKM_ETC2_EAC_RGBA", + "KTX_ETC1_RGB", + "KTX_ETC2_RGB", + "KTX_ETC2_EAC_RGBA", + "ASTC_4x4_LDR", + "ASTC_8x8_LDR", + "PVR_PVRT_RGB", + "PVR_PVRT_RGBA" +} + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture formats loading") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +local sonic = {} + +sonic[PNG_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic.png") + +-- Load UNCOMPRESSED PVR texture data +sonic[PVR_GRAYSCALE] = LoadTexture("resources/texture_formats/sonic_GRAYSCALE.pvr") +sonic[PVR_GRAY_ALPHA] = LoadTexture("resources/texture_formats/sonic_L8A8.pvr") +sonic[PVR_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.pvr") +sonic[PVR_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_R5G5B5A1.pvr") +sonic[PVR_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_R4G4B4A4.pvr") + +-- Load UNCOMPRESSED DDS texture data +sonic[DDS_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.dds") +sonic[DDS_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_A1R5G5B5.dds") +sonic[DDS_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_A4R4G4B4.dds") +sonic[DDS_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic_A8R8G8B8.dds") + +-- Load COMPRESSED DXT DDS texture data (if supported) +sonic[DDS_DXT1_RGB] = LoadTexture("resources/texture_formats/sonic_DXT1_RGB.dds") +sonic[DDS_DXT1_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT1_RGBA.dds") +sonic[DDS_DXT3_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT3_RGBA.dds") +sonic[DDS_DXT5_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT5_RGBA.dds") + +-- Load COMPRESSED ETC texture data (if supported) +sonic[PKM_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.pkm") +sonic[PKM_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.pkm") +sonic[PKM_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.pkm") + +sonic[KTX_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.ktx") +sonic[KTX_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.ktx") +sonic[KTX_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.ktx") + +-- Load COMPRESSED ASTC texture data (if supported) +sonic[ASTC_4x4_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_4x4_ldr.astc") +sonic[ASTC_8x8_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_8x8_ldr.astc") + +-- Load COMPRESSED PVR texture data (if supported) +sonic[PVR_PVRT_RGB] = LoadTexture("resources/texture_formats/sonic_PVRT_RGB.pvr") +sonic[PVR_PVRT_RGBA] = LoadTexture("resources/texture_formats/sonic_PVRT_RGBA.pvr") + +local selectedFormat = PNG_R8G8B8A8 + +local selectRecs = {} + +for i = 1, NUM_TEXTURES do + if ((i - 1) < NUM_TEXTURES//2) then selectRecs[i] = Rectangle(40, 30 + 32*(i - 1), 150, 30) + else selectRecs[i] = Rectangle(40 + 152, 30 + 32*((i - 1) - NUM_TEXTURES//2), 150, 30) end +end + +-- Texture sizes in KB +local textureSizes = { + 512*512*32/8/1024, --PNG_R8G8B8A8 (32 bpp) + 512*512*8/8/1024, --PVR_GRAYSCALE (8 bpp) + 512*512*16/8/1024, --PVR_GRAY_ALPHA (16 bpp) + 512*512*16/8/1024, --PVR_R5G6B5 (16 bpp) + 512*512*16/8/1024, --PVR_R5G5B5A1 (16 bpp) + 512*512*16/8/1024, --PVR_R4G4B4A4 (16 bpp) + 512*512*16/8/1024, --DDS_R5G6B5 (16 bpp) + 512*512*16/8/1024, --DDS_R5G5B5A1 (16 bpp) + 512*512*16/8/1024, --DDS_R4G4B4A4 (16 bpp) + 512*512*32/8/1024, --DDS_R8G8B8A8 (32 bpp) + 512*512*4/8/1024, --DDS_DXT1_RGB (4 bpp) -Compressed- + 512*512*4/8/1024, --DDS_DXT1_RGBA (4 bpp) -Compressed- + 512*512*8/8/1024, --DDS_DXT3_RGBA (8 bpp) -Compressed- + 512*512*8/8/1024, --DDS_DXT5_RGBA (8 bpp) -Compressed- + 512*512*4/8/1024, --PKM_ETC1_RGB (4 bpp) -Compressed- + 512*512*4/8/1024, --PKM_ETC2_RGB (4 bpp) -Compressed- + 512*512*8/8/1024, --PKM_ETC2_EAC_RGBA (8 bpp) -Compressed- + 512*512*4/8/1024, --KTX_ETC1_RGB (4 bpp) -Compressed- + 512*512*4/8/1024, --KTX_ETC2_RGB (4 bpp) -Compressed- + 512*512*8/8/1024, --KTX_ETC2_EAC_RGBA (8 bpp) -Compressed- + 512*512*8/8/1024, --ASTC_4x4_LDR (8 bpp) -Compressed- + 512*512*2/8/1024, --ASTC_8x8_LDR (2 bpp) -Compressed- + 512*512*4/8/1024, --PVR_PVRT_RGB (4 bpp) -Compressed- + 512*512*4/8/1024, --PVR_PVRT_RGBA (4 bpp) -Compressed- +} + +SetTargetFPS(60) -- Set our game to run at 60 frames-per-second +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyPressed(KEY.DOWN)) then + selectedFormat = selectedFormat + 1 + if (selectedFormat > NUM_TEXTURES) then selectedFormat = 1 end + elseif (IsKeyPressed(KEY.UP)) then + selectedFormat = selectedFormat - 1 + if (selectedFormat < 1) then selectedFormat = NUM_TEXTURES end + elseif (IsKeyPressed(KEY.RIGHT)) then + if (selectedFormat < NUM_TEXTURES//2) then selectedFormat = selectedFormat + NUM_TEXTURES//2 end + elseif (IsKeyPressed(KEY.LEFT)) then + if (selectedFormat > NUM_TEXTURES//2) then selectedFormat = selectedFormat - NUM_TEXTURES//2 end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + + BeginDrawing() + + ClearBackground(RAYWHITE) + + -- Draw rectangles + for i = 1, NUM_TEXTURES do + if (i == selectedFormat) then + DrawRectangleRec(selectRecs[i], SKYBLUE) + DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE) + DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKBLUE) + else + DrawRectangleRec(selectRecs[i], LIGHTGRAY) + DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY) + DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKGRAY) + end + end + + -- Draw selected texture + if (sonic[selectedFormat].id ~= 0) then DrawTexture(sonic[selectedFormat], 350, -10, WHITE) + else + DrawRectangleLines(488, 165, 200, 110, DARKGRAY) + DrawText("FORMAT", 550, 180, 20, MAROON) + DrawText("NOT SUPPORTED", 500, 210, 20, MAROON) + DrawText("ON YOUR GPU", 520, 240, 20, MAROON) + end + + DrawText("Select texture format (use cursor keys):", 40, 10, 10, DARKGRAY) + DrawText("Required GPU memory size (VRAM):", 40, 427, 10, DARKGRAY) + DrawText(string.format("%4.0f KB", textureSizes[selectedFormat]), 240, 420, 20, DARKBLUE) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +for i = 1, NUM_TEXTURES do UnloadTexture(sonic[i]) end + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_image_drawing.lua b/examples/textures_image_drawing.lua new file mode 100644 index 000000000..0261b2432 --- /dev/null +++ b/examples/textures_image_drawing.lua @@ -0,0 +1,70 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Image loading and drawing on it +-- +-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - image drawing") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +local cat = LoadImage("resources/cat.png") -- Load image in CPU memory (RAM) +cat = ImageCrop(cat, Rectangle(100, 10, 280, 380)) -- Crop an image piece +cat = ImageFlipHorizontal(cat) -- Flip cropped image horizontally +cat = ImageResize(cat, 150, 200) -- Resize flipped-cropped image + +local parrots = LoadImage("resources/parrots.png") -- Load image in CPU memory (RAM) + +-- Draw one image over the other with a scaling of 1.5f +parrots = ImageDraw(parrots, cat, Rectangle(0, 0, cat.width, cat.height), Rectangle(30, 40, cat.width*1.5, cat.height*1.5)) +parrots = ImageCrop(parrots, Rectangle(0, 50, parrots.width, parrots.height - 100)) -- Crop resulting image + +UnloadImage(cat) -- Unload image from RAM + +local texture = LoadTextureFromImage(parrots) -- Image converted to texture, uploaded to GPU memory (VRAM) +UnloadImage(parrots) -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, WHITE) + DrawRectangleLines(screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, texture.width, texture.height, DARKGRAY) + + DrawText("We are drawing only one texture from various images composed!", 240, 350, 10, DARKGRAY) + DrawText("Source images have been cropped, scaled, flipped and copied one over the other.", 190, 370, 10, DARKGRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_image_loading.lua b/examples/textures_image_loading.lua new file mode 100644 index 000000000..05dbce7fe --- /dev/null +++ b/examples/textures_image_loading.lua @@ -0,0 +1,55 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Image loading and texture creation +-- +-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +local image = LoadImage("resources/raylib_logo.png") -- Loaded in CPU memory (RAM) +local texture = LoadTextureFromImage(image) -- Image converted to texture, GPU memory (VRAM) + +UnloadImage(image) -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE) + + DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_image_processing.lua b/examples/textures_image_processing.lua new file mode 100644 index 000000000..b7304b376 --- /dev/null +++ b/examples/textures_image_processing.lua @@ -0,0 +1,134 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Image processing +-- +-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +--#include -- Required for: free() + +NUM_PROCESSES = 8 + +-- enum ImageProcess +local COLOR_NONE = 1 +local COLOR_GRAYSCALE = 2 +local COLOR_TINT = 3 +local COLOR_INVERT = 4 +local COLOR_CONTRAST = 5 +local COLOR_BRIGHTNESS = 6 +local FLIP_VERTICAL = 7 +local FLIP_HORIZONTAL = 8 + +local processText = { + "NO PROCESSING", + "COLOR GRAYSCALE", + "COLOR TINT", + "COLOR INVERT", + "COLOR CONTRAST", + "COLOR BRIGHTNESS", + "FLIP VERTICAL", + "FLIP HORIZONTAL" +} + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - image processing") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +local image = LoadImage("resources/parrots.png") -- Loaded in CPU memory (RAM) +image = ImageFormat(image, TextureFormat.UNCOMPRESSED_R8G8B8A8) -- Format image to RGBA 32bit (required for texture update) +local texture = LoadTextureFromImage(image) -- Image converted to texture, GPU memory (VRAM) + +local currentProcess = COLOR_NONE +local textureReload = false + +local selectRecs = {} + +for i = 1, NUM_PROCESSES do selectRecs[i] = Rectangle(40, 50 + 32*i, 150, 30) end + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyPressed(KEY.DOWN)) then + currentProcess = currentProcess + 1 + if (currentProcess > NUM_PROCESSES) then currentProcess = 1 end + textureReload = true + elseif (IsKeyPressed(KEY.UP)) then + currentProcess = currentProcess - 1 + if (currentProcess < 1) then currentProcess = NUM_PROCESSES end + textureReload = true + end + + if (textureReload) then + UnloadImage(image) -- Unload current image data + image = LoadImage("resources/parrots.png") -- Re-load image data + + -- NOTE: Image processing is a costly CPU process to be done every frame, + -- If image processing is required in a frame-basis, it should be done + -- with a texture and by shaders + if (currentProcess == COLOR_GRAYSCALE) then image = ImageColorGrayscale(image) + elseif (currentProcess == COLOR_TINT) then image = ImageColorTint(image, GREEN) + elseif (currentProcess == COLOR_INVERT) then image = ImageColorInvert(image) + elseif (currentProcess == COLOR_CONTRAST) then image = ImageColorContrast(image, -40) + elseif (currentProcess == COLOR_BRIGHTNESS) then image = ImageColorBrightness(image, -80) + elseif (currentProcess == FLIP_VERTICAL) then image = ImageFlipVertical(image) + elseif (currentProcess == FLIP_HORIZONTAL) then image = ImageFlipHorizontal(image) + end + + local pixels = {} + pixels = GetImageData(image) -- Get pixel data from image (RGBA 32bit) + texture = UpdateTexture(texture, pixels) -- Update texture with new image data + + textureReload = false + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawText("IMAGE PROCESSING:", 40, 30, 10, DARKGRAY) + + -- Draw rectangles + for i = 1, NUM_PROCESSES do + if (i == currentProcess) then + DrawRectangleRec(selectRecs[i], SKYBLUE) + DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE) + DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)//2, selectRecs[i].y + 11, 10, DARKBLUE) + else + DrawRectangleRec(selectRecs[i], LIGHTGRAY) + DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY) + DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)//2, selectRecs[i].y + 11, 10, DARKGRAY) + end + end + + DrawTexture(texture, screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, WHITE) + DrawRectangleLines(screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, texture.width, texture.height, BLACK) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Unload texture from VRAM +UnloadImage(image) -- Unload image from RAM + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_logo_raylib.lua b/examples/textures_logo_raylib.lua new file mode 100644 index 000000000..3abcd802a --- /dev/null +++ b/examples/textures_logo_raylib.lua @@ -0,0 +1,49 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Texture loading and drawing +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture loading and drawing") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) +local texture = LoadTexture("resources/raylib_logo.png") -- Texture loading +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE) + + DrawText("this IS a texture!", 360, 370, 10, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_particles_trail_blending.lua b/examples/textures_particles_trail_blending.lua new file mode 100644 index 000000000..d5ba7841e --- /dev/null +++ b/examples/textures_particles_trail_blending.lua @@ -0,0 +1,122 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib example - particles trail blending +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +MAX_PARTICLES = 200 + +-- Particle structure with basic data +struct.Particle { + position, + color, + alpha, + size, + rotation, + active -- NOTE: Use it to activate/deactive particle +} + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles trail blending") + +-- Particles pool, reuse them! +local mouseTail = {} + +-- Initialize particles +for i = 1, MAX_PARTICLES do + mouseTail[i].position = Vector2(0, 0) + mouseTail[i].color = Color(GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255) + mouseTail[i].alpha = 1.0 + mouseTail[i].size = GetRandomValue(1, 30)/20.0 + mouseTail[i].rotation = GetRandomValue(0, 360) + mouseTail[i].active = false +end + +local gravity = 3.0 + +local smoke = LoadTexture("resources/smoke.png") + +local blending = BLEND.ALPHA + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + + -- Activate one particle every frame and Update active particles + -- NOTE: Particles initial position should be mouse position when activated + -- NOTE: Particles fall down with gravity and rotation... and disappear after 2 seconds (alpha = 0) + -- NOTE: When a particle disappears, active = false and it can be reused. + for i = 1, MAX_PARTICLES do + if (not mouseTail[i].active) then + mouseTail[i].active = true + mouseTail[i].alpha = 1.0 + mouseTail[i].position = GetMousePosition() + i = MAX_PARTICLES + end + end + + for i = 1, MAX_PARTICLES do + if (mouseTail[i].active) then + mouseTail[i].position.y = mouseTail[i].position.y + gravity + mouseTail[i].alpha = mouseTail[i].alpha - 0.01 + + if (mouseTail[i].alpha <= 0.0) then mouseTail[i].active = false end + + mouseTail[i].rotation = mouseTail[i].rotation + 5.0 + end + end + + if (IsKeyPressed(KEY.SPACE)) then + if (blending == BLEND.ALPHA) then blending = BLEND_ADDITIVE + else blending = BLEND.ALPHA end + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(DARKGRAY) + + BeginBlendMode(blending) + + -- Draw active particles + for i = 1, MAX_PARTICLES do + if (mouseTail[i].active) then + DrawTexturePro(smoke, Rectangle(0, 0, smoke.width, smoke.height), + Rectangle(mouseTail[i].position.x, mouseTail[i].position.y, + smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size), + Vector2(smoke.width*mouseTail[i].size/2, smoke.height*mouseTail[i].size/2), + mouseTail[i].rotation, Fade(mouseTail[i].color, mouseTail[i].alpha)) end + end + + EndBlendMode() + + DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK) + + if (blending == BLEND_ALPHA) then DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK) + else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE) end + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(smoke) + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_raw_data.lua b/examples/textures_raw_data.lua new file mode 100644 index 000000000..16c1c0ad3 --- /dev/null +++ b/examples/textures_raw_data.lua @@ -0,0 +1,83 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Load textures from raw data +-- +-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +--#include -- Required for malloc() and free() + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture from raw data") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +-- Load RAW image data (512x512, 32bit RGBA, no file header) +local sonicRaw = LoadImageRaw("resources/texture_formats/sonic_R8G8B8A8.raw", 512, 512, TextureFormat.UNCOMPRESSED_R8G8B8A8, 0) +local sonic = LoadTextureFromImage(sonicRaw) -- Upload CPU (RAM) image to GPU (VRAM) +UnloadImage(sonicRaw) -- Unload CPU (RAM) image data + +-- Generate a checked texture by code (1024x1024 pixels) +local width = 1024 +local height = 1024 + +-- Dynamic memory allocation to store pixels data (Color type) +local pixels = {} + +for y = 1, height do + for x = 1, width do + if (((x/32+y/32)/1)%2 == 0) then pixels[y*height + x] = DARKBLUE + else pixels[y*height + x] = SKYBLUE end + end +end + +-- Load pixels data into an image structure and create texture +local checkedIm = LoadImageEx(pixels, width, height) +local checked = LoadTextureFromImage(checkedIm) +UnloadImage(checkedIm) -- Unload CPU (RAM) image data + +-- Dynamic memory must be freed after using it +--free(pixels) -- Unload CPU (RAM) pixels data +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(checked, screenWidth/2 - checked.width/2, screenHeight/2 - checked.height/2, Fade(WHITE, 0.3)) + DrawTexture(sonic, 330, -20, WHITE) + + DrawText("CHECKED TEXTURE ", 84, 100, 30, DARKBLUE) + DrawText("GENERATED by CODE", 72, 164, 30, DARKBLUE) + DrawText("and RAW IMAGE LOADING", 46, 226, 30, DARKBLUE) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(sonic) -- Texture unloading +UnloadTexture(checked) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_rectangle.lua b/examples/textures_rectangle.lua new file mode 100644 index 000000000..5f4816799 --- /dev/null +++ b/examples/textures_rectangle.lua @@ -0,0 +1,69 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Texture loading and drawing a part defined by a rectangle +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) +local guybrush = LoadTexture("resources/guybrush.png") -- Texture loading + +local position = Vector2(350.0, 240.0) +local frameRec = Rectangle(0, 0, guybrush.width/7, guybrush.height) +local currentFrame = 0 +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + if (IsKeyPressed(KEY.RIGHT)) then + currentFrame = currentFrame + 1 + + if (currentFrame > 6) then currentFrame = 0 end + + frameRec.x = currentFrame*guybrush.width/7 + end + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(guybrush, 35, 40, WHITE) + DrawRectangleLines(35, 40, guybrush.width, guybrush.height, LIME) + + DrawTextureRec(guybrush, frameRec, position, WHITE) -- Draw part of the texture + + DrawRectangleLines(35 + frameRec.x, 40 + frameRec.y, frameRec.width, frameRec.height, RED) + + DrawText("PRESS RIGHT KEY to", 540, 310, 10, GRAY) + DrawText("CHANGE DRAWING RECTANGLE", 520, 330, 10, GRAY) + + DrawText("Guybrush Ulysses Threepwood,", 100, 300, 10, GRAY) + DrawText("main character of the Monkey Island series", 80, 320, 10, GRAY) + DrawText("of computer adventure games by LucasArts.", 80, 340, 10, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(guybrush) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_srcrec_dstrec.lua b/examples/textures_srcrec_dstrec.lua new file mode 100644 index 000000000..f94deb3e9 --- /dev/null +++ b/examples/textures_srcrec_dstrec.lua @@ -0,0 +1,71 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Texture source and destination rectangles +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] examples - texture source and destination rectangles") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) +local guybrush = LoadTexture("resources/guybrush.png") -- Texture loading + +local frameWidth = guybrush.width/7 +local frameHeight = guybrush.height + +-- NOTE: Source rectangle (part of the texture to use for drawing) +local sourceRec = Rectangle(0, 0, frameWidth, frameHeight) + +-- NOTE: Destination rectangle (screen rectangle where drawing part of texture) +local destRec = Rectangle(screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2) + +-- NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size +local origin = Vector2(frameWidth, frameHeight) + +local rotation = 0 + +SetTargetFPS(60) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + rotation = rotation + 1 + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + -- NOTE: Using DrawTexturePro() we can easily rotate and scale the part of the texture we draw + -- sourceRec defines the part of the texture we use for drawing + -- destRec defines the rectangle where our texture part will fit (scaling it to fit) + -- origin defines the point of the texture used as reference for rotation and scaling + -- rotation defines the texture rotation (using origin as rotation point) + DrawTexturePro(guybrush, sourceRec, destRec, origin, rotation, WHITE) + + DrawLine(destRec.x, 0, destRec.x, screenHeight, GRAY) + DrawLine(0, destRec.y, screenWidth, destRec.y, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(guybrush) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/examples/textures_to_image.lua b/examples/textures_to_image.lua new file mode 100644 index 000000000..b7a2d4ed5 --- /dev/null +++ b/examples/textures_to_image.lua @@ -0,0 +1,60 @@ +------------------------------------------------------------------------------------------- +-- +-- raylib [textures] example - Retrieve image data from texture: GetTextureData() +-- +-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM) +-- +-- This example has been created using raylib 1.6 (www.raylib.com) +-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) +-- +-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) +-- +------------------------------------------------------------------------------------------- + +-- Initialization +------------------------------------------------------------------------------------------- +local screenWidth = 800 +local screenHeight = 450 + +InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image") + +-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) + +local image = LoadImage("resources/raylib_logo.png") -- Load image data into CPU memory (RAM) +local texture = LoadTextureFromImage(image) -- Image converted to texture, GPU memory (RAM -> VRAM) +UnloadImage(image) -- Unload image data from CPU memory (RAM) + +image = GetTextureData(texture) -- Retrieve image data from GPU memory (VRAM -> RAM) +UnloadTexture(texture) -- Unload texture from GPU memory (VRAM) + +texture = LoadTextureFromImage(image) -- Recreate texture from retrieved image data (RAM -> VRAM) +UnloadImage(image) -- Unload retrieved image data from CPU memory (RAM) +------------------------------------------------------------------------------------------- + +-- Main game loop +while not WindowShouldClose() do -- Detect window close button or ESC key + -- Update + --------------------------------------------------------------------------------------- + -- TODO: Update your variables here + --------------------------------------------------------------------------------------- + + -- Draw + --------------------------------------------------------------------------------------- + BeginDrawing() + + ClearBackground(RAYWHITE) + + DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE) + + DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY) + + EndDrawing() + --------------------------------------------------------------------------------------- +end + +-- De-Initialization +------------------------------------------------------------------------------------------- +UnloadTexture(texture) -- Texture unloading + +CloseWindow() -- Close window and OpenGL context +------------------------------------------------------------------------------------------- \ No newline at end of file