mirrors/raylib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove rlua from raylib main repo

Browse Source 
Moved to own repo at https://github.com/raysan5/raylib-lua
This commit is contained in:
raysan5 2017-02-05 03:15:43 +01:00
parent c4bd214cf0
commit 7bf6a712cc
56 changed files with 0 additions and 8935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
examples/audio_module_playing.lua
View File

@ -1,101 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-- 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] = {}
circles[i].alpha = 0.0
circles[i].radius = GetRandomValue(10, 40)
circles[i].position = Vector2(0, 0)
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 = GetRandomValue(1, 100)/20000.0
circles[i].color = colors[GetRandomValue(1, 14)]
end
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].alpha + circles[i].speed
circles[i].radius = 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(1, 14)]
circles[i].speed = 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(RAYWHITE)
for i = MAX_CIRCLES, 1, -1 do
DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha))
end
-- Draw time bar
DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY)
DrawRectangle(20, screenHeight - 20 - 12, timePlayed//1, 12, MAROON)
DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadMusicStream(xm) -- Unload music stream buffers from RAM
CloseAudioDevice() -- Close audio device (music streaming is automatically stopped)
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

66
examples/audio_music_stream.lua
View File

@ -1,66 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

97
examples/audio_raw_stream.lua
View File

@ -1,97 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

59
examples/audio_sound_loading.lua
View File

@ -1,59 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

130
examples/core_2d_camera.lua
View File

@ -1,130 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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)
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
-------------------------------------------------------------------------------------------

84
examples/core_3d_camera_first_person.lua
View File

@ -1,84 +0,0 @@
--------------------------------------------------------------------------------------------
--
-- 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(4.0, 2.0, 4.0), Vector3(0.0, 1.8, 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(camera, CameraMode.FIRST_PERSON) -- Set a first person camera mode
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 camera
---------------------------------------------------------------------------------------
-- 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
-------------------------------------------------------------------------------------------

72
examples/core_3d_camera_free.lua
View File

@ -1,72 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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(10.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(camera, CameraMode.FREE) -- Set a free camera mode
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 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
-------------------------------------------------------------------------------------------

64
examples/core_3d_mode.lua
View File

@ -1,64 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

96
examples/core_3d_picking.lua
View File

@ -1,96 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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(camera, CameraMode.FREE) -- Set a free camera mode
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 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)))
--print("collision check:", collision)
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
-------------------------------------------------------------------------------------------

44
examples/core_basic_window.lua
View File

@ -1,44 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 [core] example - basic window")
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("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

82
examples/core_color_select.lua
View File

@ -1,82 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

66
examples/core_drop_files.lua
View File

@ -1,66 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
local droppedFiles = {}
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsFileDropped()) then
droppedFiles = GetDroppedFiles()
count = #droppedFiles
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-1 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+1], 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
-------------------------------------------------------------------------------------------

102
examples/core_gestures_detection.lua
View File

@ -1,102 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

163
examples/core_input_gamepad.lua
View File

@ -1,163 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 texPs3Pad = LoadTexture("resources/ps3.png")
local texXboxPad = LoadTexture("resources/xbox.png")
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- ...
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
if (IsGamepadAvailable(GAMEPAD.PLAYER1)) then
DrawText(string.format("GP1: %s", GetGamepadName(GAMEPAD.PLAYER1)), 10, 10, 10, BLACK)
if (IsGamepadName(GAMEPAD.PLAYER1, "Xbox 360 Controller")) then
DrawTexture(texXboxPad, 0, 0, DARKGRAY)
-- Draw buttons: xbox home
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_HOME)) then DrawCircle(394, 89, 19, RED) end
-- Draw buttons: basic
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_START)) then DrawCircle(436, 150, 9, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_SELECT)) then DrawCircle(352, 150, 9, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_X)) then DrawCircle(501, 151, 15, BLUE) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_A)) then DrawCircle(536, 187, 15, LIME) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_B)) then DrawCircle(572, 151, 15, MAROON) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_Y)) then DrawCircle(536, 115, 15, GOLD) end
-- Draw buttons: d-pad
DrawRectangle(317, 202, 19, 71, BLACK)
DrawRectangle(293, 228, 69, 19, BLACK)
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_UP)) then DrawRectangle(317, 202, 19, 26, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_DOWN)) then DrawRectangle(317, 202 + 45, 19, 26, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_LEFT)) then DrawRectangle(292, 228, 25, 19, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_RIGHT)) then DrawRectangle(292 + 44, 228, 26, 19, RED) end
-- Draw buttons: left-right back
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_LB)) then DrawCircle(259, 61, 20, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.XBOX_BUTTON_RB)) then DrawCircle(536, 61, 20, RED) end
-- Draw axis: left joystick
DrawCircle(259, 152, 39, BLACK)
DrawCircle(259, 152, 34, LIGHTGRAY)
DrawCircle(259 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_X)*20),
152 - (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_Y)*20), 25, BLACK)
-- Draw axis: right joystick
DrawCircle(461, 237, 38, BLACK)
DrawCircle(461, 237, 33, LIGHTGRAY)
DrawCircle(461 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_RIGHT_X)*20),
237 - (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_RIGHT_Y)*20), 25, BLACK)
-- Draw axis: left-right triggers
DrawRectangle(170, 30, 15, 70, GRAY)
DrawRectangle(604, 30, 15, 70, GRAY)
DrawRectangle(170, 30, 15, (((1.0 + GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LT))/2.0)*70), RED)
DrawRectangle(604, 30, 15, (((1.0 + GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_RT))/2.0)*70), RED)
--DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LT)), 10, 40, 10, BLACK)
--DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_RT)), 10, 60, 10, BLACK)
elseif (IsGamepadName(GAMEPAD.PLAYER1, "PLAYSTATION(R)3 Controller")) then
DrawTexture(texPs3Pad, 0, 0, DARKGRAY)
-- Draw buttons: ps
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_PS)) then DrawCircle(396, 222, 13, RED) end
-- Draw buttons: basic
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_SELECT)) then DrawRectangle(328, 170, 32, 13, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_START)) then DrawTriangle((Vector2){ 436, 168 }, (Vector2){ 436, 185 }, (Vector2){ 464, 177 }, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_TRIANGLE)) then DrawCircle(557, 144, 13, LIME) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_CIRCLE)) then DrawCircle(586, 173, 13, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_CROSS)) then DrawCircle(557, 203, 13, VIOLET) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_SQUARE)) then DrawCircle(527, 173, 13, PINK) end
-- Draw buttons: d-pad
DrawRectangle(225, 132, 24, 84, BLACK)
DrawRectangle(195, 161, 84, 25, BLACK)
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_UP)) then DrawRectangle(225, 132, 24, 29, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_DOWN)) then DrawRectangle(225, 132 + 54, 24, 30, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_LEFT)) then DrawRectangle(195, 161, 30, 25, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_RIGHT)) then DrawRectangle(195 + 54, 161, 30, 25, RED) end
-- Draw buttons: left-right back buttons
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_L1)) then DrawCircle(239, 82, 20, RED) end
if (IsGamepadButtonDown(GAMEPAD.PLAYER1, GAMEPAD.PS3_BUTTON_R1)) then DrawCircle(557, 82, 20, RED) end
-- Draw axis: left joystick
DrawCircle(319, 255, 35, BLACK)
DrawCircle(319, 255, 31, LIGHTGRAY)
DrawCircle(319 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_LEFT_X)*20),
255 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_LEFT_Y)*20), 25, BLACK)
-- Draw axis: right joystick
DrawCircle(475, 255, 35, BLACK)
DrawCircle(475, 255, 31, LIGHTGRAY)
DrawCircle(475 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_RIGHT_X)*20),
255 + (GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_RIGHT_Y)*20), 25, BLACK)
-- Draw axis: left-right triggers
DrawRectangle(169, 48, 15, 70, GRAY)
DrawRectangle(611, 48, 15, 70, GRAY)
DrawRectangle(169, 48, 15, (((1.0 - GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_L2))/2.0)*70), RED)
DrawRectangle(611, 48, 15, (((1.0 - GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.PS3_AXIS_R2))/2.0)*70), RED)
else
DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY)
-- TODO: Draw generic gamepad
end
DrawText(string.format("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD.PLAYER1)), 10, 50, 10, MAROON)
for i = 1, GetGamepadAxisCount(GAMEPAD.PLAYER1) do -- Iterate along all the rectangles
DrawText(string.format("AXIS %i: %.02f", i, GetGamepadAxisMovement(GAMEPAD.PLAYER1, i)), 20, 70 + 20*i, 10, DARKGRAY)
end
if (GetGamepadButtonPressed() ~= -1) then DrawText(string.format("DETECTED BUTTON: %i", GetGamepadButtonPressed()), 10, 430, 10, RED)
else DrawText("DETECTED BUTTON: NONE", 10, 430, 10, GRAY) end
else
DrawText("GP1: NOT DETECTED", 10, 10, 10, GRAY)
DrawTexture(texXboxPad, 0, 0, LIGHTGRAY)
end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texPs3Pad) -- Unload gamepad texture
UnloadTexture(texXboxPad) -- Unload gamepad texture
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

51
examples/core_input_keys.lua
View File

@ -1,51 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

54
examples/core_input_mouse.lua
View File

@ -1,54 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
----------------------------------------------------------------------------------------

50
examples/core_mouse_wheel.lua
View File

@ -1,50 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
----------------------------------------------------------------------------------------

73
examples/core_oculus_rift.lua
View File

@ -1,73 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
----------------------------------------------------------------------------------------

56
examples/core_random_values.lua
View File

@ -1,56 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
----------------------------------------------------------------------------------------

74
examples/core_storage_values.lua
View File

@ -1,74 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

66
examples/core_world_screen.lua
View File

@ -1,66 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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(camera, CameraMode.FREE) -- Set a free camera mode
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 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//1 - MeasureText("Enemy: 100 / 100", 20)//2, cubeScreenPosition.y//1, 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
----------------------------------------------------------------------------------------

62
examples/models_billboard.lua
View File

@ -1,62 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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 camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawBillboard(camera, bill, billPosition, 2.0, WHITE)
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(bill) -- Unload texture
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

115
examples/models_box_collisions.lua
View File

@ -1,115 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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.2
elseif (IsKeyDown(KEY.LEFT)) then playerPosition.x = playerPosition.x - 0.2
elseif (IsKeyDown(KEY.DOWN)) then playerPosition.z = playerPosition.z + 0.2
elseif (IsKeyDown(KEY.UP)) then playerPosition.z = playerPosition.z - 0.2 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
-------------------------------------------------------------------------------------------

77
examples/models_cubicmap.lua
View File

@ -1,77 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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 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
-------------------------------------------------------------------------------------------

67
examples/models_geometric_shapes.lua
View File

@ -1,67 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

72
examples/models_heightmap.lua
View File

@ -1,72 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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 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
-------------------------------------------------------------------------------------------

67
examples/models_obj_loading.lua
View File

@ -1,67 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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.0, WHITE) -- Draw 3d model with texture
DrawGrid(10, 1.0) -- 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
-------------------------------------------------------------------------------------------

93
examples/rlua_execute_file.c
View File

@ -1,93 +0,0 @@
/*******************************************************************************************
*
* raylib [rlua] example - Lua file execution
*
* NOTE: This example requires Lua library (http://luabinaries.sourceforge.net/download.html)
*
* Compile example using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon /
* -I../src -I../src/external/lua/include -L../src/external/lua/lib /
* -lraylib -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -llua53 /
* -std=c99 -Wl,-allow-multiple-definition -Wl,--subsystem,windows
*
* 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) 2013-2016 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#define RLUA_IMPLEMENTATION
#include "rlua.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
InitLuaDevice();
//--------------------------------------------------------------------------------------
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"); // OK!
// ExecuteLuaFile("core_storage_values.lua"); // OK!
// ExecuteLuaFile("core_gestures_detection.lua"); // OK!
// ExecuteLuaFile("core_3d_mode.lua"); // OK!
// ExecuteLuaFile("core_3d_picking.lua"); // OK!
// ExecuteLuaFile("core_3d_camera_free.lua"); // OK!
// ExecuteLuaFile("core_3d_camera_first_person.lua"); // OK!
// ExecuteLuaFile("core_2d_camera.lua"); // OK!
// ExecuteLuaFile("core_world_screen.lua"); // OK!
// ExecuteLuaFile("core_oculus_rift.lua"); // OK!
// 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: LoadImageEx()
// ExecuteLuaFile("textures_formats_loading.lua"); // OK!
// ExecuteLuaFile("textures_particles_trail_blending.lua"); // OK!
// 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"); // OK!
// 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"); // OK!
// ExecuteLuaFile("text_ttf_loading.lua"); // ISSUE: Attempt to index a SpriteFont value (local 'font')
// ExecuteLuaFile("text_bmfont_unordered.lua"); // OK!
// ExecuteLuaFile("models_geometric_shapes.lua"); // OK!
// ExecuteLuaFile("models_box_collisions.lua"); // OK!
// ExecuteLuaFile("models_billboard.lua"); // OK!
// ExecuteLuaFile("models_obj_loading.lua"); // OK!
// ExecuteLuaFile("models_heightmap.lua"); // OK!
// ExecuteLuaFile("models_cubicmap.lua"); // OK!
// ExecuteLuaFile("shaders_model_shader.lua"); // OK!
// ExecuteLuaFile("shaders_shapes_textures.lua"); // OK!
// ExecuteLuaFile("shaders_custom_uniform.lua"); // OK!
// ExecuteLuaFile("shaders_postprocessing.lua"); // OK!
// ExecuteLuaFile("shaders_standard_lighting.lua"); // OK!
// ExecuteLuaFile("audio_sound_loading.lua"); // OK!
// ExecuteLuaFile("audio_music_stream.lua"); // OK!
// ExecuteLuaFile("audio_module_playing.lua"); // OK!
// ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream()
// De-Initialization
//--------------------------------------------------------------------------------------
CloseLuaDevice(); // Close Lua device and free resources
//--------------------------------------------------------------------------------------
return 0;
}

113
examples/shaders_custom_uniform.lua
View File

@ -1,113 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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[1] = mousePosition.x
swirlCenter[2] = screenHeight - mousePosition.y
-- Send new value to the shader to be used on drawing
SetShaderValue(shader, swirlCenterLoc, swirlCenter)
camera = UpdateCamera(camera) -- Update 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
-------------------------------------------------------------------------------------------

83
examples/shaders_model_shader.lua
View File

@ -1,83 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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 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
-------------------------------------------------------------------------------------------

99
examples/shaders_postprocessing.lua
View File

@ -1,99 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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, CameraMode.ORBITAL) -- Set an orbital camera mode
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 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()
---------------------------------------------------------------------------------------
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
-------------------------------------------------------------------------------------------

101
examples/shaders_shapes_textures.lua
View File

@ -1,101 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadShader(shader) -- Unload shader
UnloadTexture(sonic) -- Unload texture
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

112
examples/shaders_standard_lighting.lua
View File

@ -1,112 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model
local position = Vector3(0.0, 0.0, 0.0) -- Set model position
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.0
dwarf.material = material -- Apply material to model
local spotLight = CreateLight(LightType.SPOT, Vector3(3.0, 5.0, 2.0), Color(255, 255, 255, 255))
spotLight.target = Vector3(0.0, 0.0, 0.0)
spotLight.intensity = 2.0
spotLight.diffuse = Color(255, 100, 100, 255)
spotLight.coneAngle = 60.0
local dirLight = CreateLight(LightType.DIRECTIONAL, Vector3(0.0, -3.0, -3.0), Color(255, 255, 255, 255))
dirLight.target = Vector3(1.0, -2.0, -2.0)
dirLight.intensity = 2.0
dirLight.diffuse = Color(100, 255, 100, 255)
local pointLight = CreateLight(LightType.POINT, Vector3(0.0, 4.0, 5.0), Color(255, 255, 255, 255))
pointLight.intensity = 2.0
pointLight.diffuse = Color(100, 100, 255, 255)
pointLight.radius = 3.0
-- Setup orbital camera
SetCameraMode(camera, CameraMode.ORBITAL) -- Set an orbital camera mode
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 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()
---------------------------------------------------------------------------------------
end
-- 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
-------------------------------------------------------------------------------------------

64
examples/shapes_basic_shapes.lua
View File

@ -1,64 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

89
examples/shapes_colors_palette.lua
View File

@ -1,89 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

48
examples/shapes_logo_raylib.lua
View File

@ -1,48 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

127
examples/shapes_logo_raylib_anim.lua
View File

@ -1,127 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

59
examples/text_bmfont_ttf.lua
View File

@ -1,59 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

57
examples/text_bmfont_unordered.lua
View File

@ -1,57 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - BMFont unordered chars 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 [text] example - bmfont unordered loading and drawing")
-- NOTE: Using chars outside the [32..127] limits!
-- NOTE: If a character is not found in the font, it just renders a space
local msg = "ASCII extended characters:\n¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆ\nÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæ\nçèéêëìíîïðñòóôõö÷øùúûüýþÿ"
-- NOTE: Loaded font has an unordered list of characters (chars in the range 32..255)
local font = LoadSpriteFont("resources/fonts/pixantiqua.fnt") -- BMFont (AngelCode)
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update variables here...
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("Font name: PixAntiqua", 40, 50, 20, GRAY)
DrawText(string.format("Font base size: %i", font.size), 40, 80, 20, GRAY)
DrawText(string.format("Font chars number: %i", font.numChars), 40, 110, 20, GRAY)
DrawTextEx(font, msg, Vector2(40, 180), font.size, 0, MAROON)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadSpriteFont(font) -- AngelCode SpriteFont unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

143
examples/text_font_select.lua
View File

@ -1,143 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

54
examples/text_format_text.lua
View File

@ -1,54 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

87
examples/text_rbmf_fonts.lua
View File

@ -1,87 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 + 45*(i - 1)
end
local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, BLACK }
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
-------------------------------------------------------------------------------------------

72
examples/text_sprite_fonts.lua
View File

@ -1,72 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

118
examples/text_ttf_loading.lua
View File

@ -1,118 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - TTF 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 - ttf loading")
local msg = "TTF SpriteFont"
-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
-- TTF SpriteFont loading with custom generation parameters
local font = LoadSpriteFontTTF("resources/fonts/KAISG.ttf", 96, 0, 0)
-- Generate mipmap levels to use trilinear filtering
-- NOTE: On 2D drawing it won't be noticeable, it looks like FILTER_BILINEAR
--font.texture = GenTextureMipmaps(font.texture) -- ISSUE: attempt to index a SpriteFont value (local 'font')
local fontSize = font.size
local fontPosition = Vector2(40, screenHeight/2 + 50)
local textSize
SetTextureFilter(font.texture, TextureFilter.POINT)
local currentFontFilter = 0 -- Default: FILTER_POINT
local count = 0
local droppedFiles
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
fontSize = fontSize + GetMouseWheelMove()*4.0
-- Choose font texture filter method
if (IsKeyPressed(KEY.ONE)) then
SetTextureFilter(font.texture, TextureFilter.POINT)
currentFontFilter = 0
elseif (IsKeyPressed(KEY.TWO)) then
SetTextureFilter(font.texture, TextureFilter.BILINEAR)
currentFontFilter = 1
elseif (IsKeyPressed(KEY.THREE)) then
-- NOTE: Trilinear filter won't be noticed on 2D drawing
SetTextureFilter(font.texture, TextureFilter.TRILINEAR)
currentFontFilter = 2
end
textSize = MeasureTextEx(font, msg, fontSize, 0)
if (IsKeyDown(KEY.LEFT)) then fontPosition.x = fontPosition.x - 10
elseif (IsKeyDown(KEY.RIGHT)) then fontPosition.x = fontPosition.x + 10
end
-- Load a dropped TTF file dynamically (at current fontSize)
if (IsFileDropped()) then
droppedFiles = GetDroppedFiles()
count = #droppedFiles
if (count == 1) then -- Only support one ttf file dropped
UnloadSpriteFont(font)
font = LoadSpriteFontTTF(droppedFiles[1], fontSize, 0, 0)
ClearDroppedFiles()
end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("Use mouse wheel to change font size", 20, 20, 10, GRAY)
DrawText("Use KEY_RIGHT and KEY_LEFT to move text", 20, 40, 10, GRAY)
DrawText("Use 1, 2, 3 to change texture filter", 20, 60, 10, GRAY)
DrawText("Drop a new TTF font for dynamic loading", 20, 80, 10, DARKGRAY)
DrawTextEx(font, msg, fontPosition, fontSize, 0, BLACK)
-- TODO: It seems texSize measurement is not accurate due to chars offsets...
--DrawRectangleLines(fontPosition.x, fontPosition.y, textSize.x, textSize.y, RED)
DrawRectangle(0, screenHeight - 80, screenWidth, 80, LIGHTGRAY)
DrawText(string.format("Font size: %02.02f", fontSize), 20, screenHeight - 50, 10, DARKGRAY)
DrawText(string.format("Text size: [%02.02f, %02.02f]", textSize.x, textSize.y), 20, screenHeight - 30, 10, DARKGRAY)
DrawText("CURRENT TEXTURE FILTER:", 250, 400, 20, GRAY)
if (currentFontFilter == 0) then DrawText("POINT", 570, 400, 20, BLACK)
elseif (currentFontFilter == 1) then DrawText("BILINEAR", 570, 400, 20, BLACK)
elseif (currentFontFilter == 2) then DrawText("TRILINEAR", 570, 400, 20, BLACK)
end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadSpriteFont(font) -- SpriteFont unloading
ClearDroppedFiles() -- Clear internal buffers
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

52
examples/text_writing_anim.lua
View File

@ -1,52 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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(string.sub(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
-------------------------------------------------------------------------------------------

217
examples/textures_formats_loading.lua
View File

@ -1,217 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

70
examples/textures_image_drawing.lua
View File

@ -1,70 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

55
examples/textures_image_loading.lua
View File

@ -1,55 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

134
examples/textures_image_processing.lua
View File

@ -1,134 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 <stdlib.h> -- 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
-------------------------------------------------------------------------------------------

49
examples/textures_logo_raylib.lua
View File

@ -1,49 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

113
examples/textures_particles_trail_blending.lua
View File

@ -1,113 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-- 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] = {}
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 = BlendMode.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()
break
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 == BlendMode.ALPHA) then blending = BlendMode.ADDITIVE
else blending = BlendMode.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//1, smoke.height*mouseTail[i].size//1),
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 == BlendMode.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
-------------------------------------------------------------------------------------------

83
examples/textures_raw_data.lua
View File

@ -1,83 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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 <stdlib.h> -- 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 - 1)/32+(y - 1)//32)//1)%2 == 0) then pixels[(y - 1)*height + x] = DARKBLUE
else pixels[(y - 1)*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
-------------------------------------------------------------------------------------------

69
examples/textures_rectangle.lua
View File

@ -1,69 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

71
examples/textures_srcrec_dstrec.lua
View File

@ -1,71 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

60
examples/textures_to_image.lua
View File

@ -1,60 +0,0 @@
-------------------------------------------------------------------------------------------
--
-- 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
-------------------------------------------------------------------------------------------

4333
src/rlua.h
View File

File diff suppressed because it is too large Load Diff