mirrors/raylib
1
0
Fork 0
mirror of https://github.com/raysan5/raylib.git synced 2026-01-05 21:08:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #189 from raysan5/develop

Browse Source 
Develop branch integration
This commit is contained in:
Ray
2016-10-16 18:24:13 +02:00
committed by GitHub
parent 53056f3e7e 1c05017548
commit a9315fc422
181 changed files with 30983 additions and 5542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.gitignore vendored
View File

@@ -49,7 +49,7 @@ ipch/
# Ignore compiled binaries
*.o
*.exe
!tools/rrem.exe
!tools/rREM/rrem.exe
# Ignore files build by xcode
*.mode*v*
@@ -75,4 +75,16 @@ src/libraylib.bc
!src/external/glfw3/lib/win32/glfw3.dll
!src/external/openal_soft/lib/win32/OpenAL32.dll
!src/external/OculusSDK/LibOVR/LibOVRRT32_1.dll
!src/external/pthread/pthreadGC2.dll
!src/external/pthread/lib/pthreadGC2.dll
# Visual Studio project
project/vs2015/*.db
project/vs2015/*.opendb
!project/vs2015/raylib.sln
!project/vs2015/raylib/*.vcxproj
!project/vs2015/examples/*.vcxproj
!project/vs2015/external/glfw3/lib/win32/glfw3.dll
!project/vs2015/external/openal_soft/lib/win32/OpenAL32.dll
!project/vs2015/external/openal_soft/lib/win64/OpenAL32.dll
!project/vs2015/external/lua/lib/win32/lua53.dll

1
README.md
View File

@@ -249,6 +249,7 @@ contributing (in some way or another) to make raylib project better. Huge thanks
- [Chris Hemingway](https://github.com/cHemingway) for improving raylib on OSX build system.
- [Emanuele Petriglia](https://github.com/LelixSuper) for working on multiple GNU/Linux improvements and developing [TicTacToe](https://github.com/LelixSuper/TicTacToe) raylib game.
- [Joshua Reisenauer](https://github.com/kd7tck) for adding audio modules support (XM, MOD) and reviewing audio system.
- Marcelo Paez (paezao) for his help on OSX to solve High DPI display issue. Thanks Marcelo!
[raysan5]: mailto:raysan5@gmail.com "Ramon Santamaria - Ray San"

32
examples/Makefile
View File

@@ -77,8 +77,27 @@ endif
#CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes
# define raylib release directory for compiled library
ifeq ($(PLATFORM),PLATFORM_DESKTOP)
ifeq ($(PLATFORM_OS),WINDOWS)
RAYLIB_PATH = ../release/win32/mingw32
endif
ifeq ($(PLATFORM_OS),LINUX)
RAYLIB_PATH = ../release/linux
endif
ifeq ($(PLATFORM_OS),OSX)
RAYLIB_PATH = ../release/osx
endif
endif
ifeq ($(PLATFORM),PLATFORM_WEB)
RAYLIB_PATH = ../release/html5
endif
ifeq ($(PLATFORM),PLATFORM_RPI)
RAYLIB_PATH = ../release/rpi
endif
# define any directories containing required header files
INCLUDES = -I. -I../src -I../src/external
INCLUDES = -I. -I../src -I../src/external -I$(RAYLIB_PATH)
ifeq ($(PLATFORM),PLATFORM_RPI)
INCLUDES += -I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads
@@ -97,7 +116,7 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
endif
# define library paths containing required libs
LFLAGS = -L. -L../src
LFLAGS = -L. -L../src -L$(RAYLIB_PATH)
ifeq ($(PLATFORM),PLATFORM_RPI)
LFLAGS += -L/opt/vc/lib
@@ -120,7 +139,7 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
# libraries for Debian GNU/Linux desktop compiling
# requires the following packages:
# libglfw3-dev libopenal-dev libegl1-mesa-dev
LIBS = -lraylib -lglfw3 -lGL -lopenal -lm -pthread -ldl
LIBS = -lraylib -lglfw3 -lGL -lopenal -lm -lpthread -ldl
# on XWindow could require also below libraries, just uncomment
#LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
else
@@ -210,6 +229,7 @@ EXAMPLES = \
audio_sound_loading \
audio_music_stream \
audio_module_playing \
audio_raw_stream \
fix_dylib \
@@ -436,10 +456,14 @@ audio_sound_loading: audio_sound_loading.c
audio_music_stream: audio_music_stream.c
$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
# compile [audio] example - module playing (OGG)
# compile [audio] example - module playing (XM)
audio_module_playing: audio_module_playing.c
$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
# compile [audio] example - raw audio streaming
audio_raw_stream: audio_raw_stream.c
$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
# fix dylib install path name for each executable (MAC)
fix_dylib:
ifeq ($(PLATFORM_OS),OSX)

36
examples/audio_module_playing.c
View File

@@ -57,9 +57,12 @@ int main()
// Create a RenderTexture2D to be used for render to texture
RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
PlayMusicStream(0, "resources/audio/2t2m_spa.xm"); // Play module stream
Music xm = LoadMusicStream("resources/audio/mini1111.xm");
PlayMusicStream(xm);
float timePlayed = 0.0f;
bool pause = false;
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -69,7 +72,29 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
for (int i = MAX_CIRCLES - 1; i >= 0; i--)
UpdateMusicStream(xm); // Update music buffer with new stream data
// Restart music playing (stop and play)
if (IsKeyPressed(KEY_SPACE))
{
StopMusicStream(xm);
PlayMusicStream(xm);
}
// Pause/Resume music playing
if (IsKeyPressed(KEY_P))
{
pause = !pause;
if (pause) PauseMusicStream(xm);
else ResumeMusicStream(xm);
}
// Get timePlayed scaled to bar dimensions
timePlayed = (GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40))*2;
// Color circles animation
for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--)
{
circles[i].alpha += circles[i].speed;
circles[i].radius += circles[i].speed*10.0f;
@@ -86,11 +111,6 @@ int main()
circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
}
}
// Get timePlayed scaled to bar dimensions
timePlayed = (GetMusicTimePlayed(0)/GetMusicTimeLength(0)*(screenWidth - 40))*2;
UpdateMusicStream(0); // Update music buffer with new stream data
//----------------------------------------------------------------------------------
// Draw
@@ -129,6 +149,8 @@ int main()
UnloadShader(shader); // Unload shader
UnloadRenderTexture(target); // Unload render texture
UnloadMusicStream(xm); // Unload music stream buffers from RAM
CloseAudioDevice(); // Close audio device (music streaming is automatically stopped)
CloseWindow(); // Close window and OpenGL context

122
examples/audio_module_playing.lua Normal file
View File

@@ -0,0 +1,122 @@
-------------------------------------------------------------------------------------------
--
-- 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
-- Load postprocessing bloom shader
local shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/bloom.fs")
-- Create a RenderTexture2D to be used for render to texture
local target = LoadRenderTexture(screenWidth, screenHeight)
local xm = LoadMusicStream("resources/audio/mini1111.xm")
PlayMusicStream(xm)
local timePlayed = 0.0
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
for i = MAX_CIRCLES, 1, -1 do
circles[i].alpha = circles[i].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(BLACK)
BeginTextureMode(target) -- Enable drawing to texture
for i = MAX_CIRCLES, 1, -1 do
DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha))
end
EndTextureMode() -- End drawing to texture (now we have a texture available for next passes)
BeginShaderMode(shader)
-- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
EndShaderMode()
-- Draw time bar
DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY)
DrawRectangle(20, screenHeight - 20 - 12, timePlayed//1, 12, MAROON)
DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadShader(shader) -- Unload shader
UnloadRenderTexture(target) -- Unload render texture
UnloadMusicStream(xm) -- Unload music stream buffers from RAM
CloseAudioDevice() -- Close audio device (music streaming is automatically stopped)
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

67
examples/audio_music_stream.c
View File

@@ -24,11 +24,12 @@ int main()
InitAudioDevice(); // Initialize audio device
PlayMusicStream(0, "resources/audio/guitar_noodling.ogg"); // Play music stream
Music music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
PlayMusicStream(music);
int framesCounter = 0;
float timePlayed = 0.0f;
//float volume = 1.0;
bool pause = false;
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -38,32 +39,26 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
framesCounter++;
// Testing music fading from one file to another
/*
if (framesCounter > 600) // Wait for 10 seconds (600 frames)
{
volume -= 0.01; // Decrement music volume level
// When music volume level equal or lower than 0,
// restore volume level and init another music file
if (volume <= 0)
{
volume = 1.0;
framesCounter = 0;
PlayMusicStream(1, "resources/audio/another_file.ogg");
}
SetMusicVolume(volume);
}
*/
if (IsWindowMinimized()) PauseMusicStream(0);
else ResumeMusicStream(0);
timePlayed = GetMusicTimePlayed(0)/GetMusicTimeLength(0)*100*4; // We scale by 4 to fit 400 pixels
UpdateMusicStream(music); // Update music buffer with new stream data
UpdateMusicStream(0); // Update music buffer with new stream data
// Restart music playing (stop and play)
if (IsKeyPressed(KEY_SPACE))
{
StopMusicStream(music);
PlayMusicStream(music);
}
// Pause/Resume music playing
if (IsKeyPressed(KEY_P))
{
pause = !pause;
if (pause) PauseMusicStream(music);
else ResumeMusicStream(music);
}
// Get timePlayed scaled to bar dimensions (400 pixels)
timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4;
//----------------------------------------------------------------------------------
// Draw
@@ -72,10 +67,14 @@ int main()
ClearBackground(RAYWHITE);
DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY);
DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
DrawRectangle(200, 250, 400, 12, LIGHTGRAY);
DrawRectangle(200, 250, (int)timePlayed, 12, MAROON);
DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
DrawRectangleLines(200, 200, 400, 12, GRAY);
DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
EndDrawing();
//----------------------------------------------------------------------------------
@@ -83,9 +82,11 @@ int main()
// De-Initialization
//--------------------------------------------------------------------------------------
CloseAudioDevice(); // Close audio device (music streaming is automatically stopped)
UnloadMusicStream(music); // Unload music stream buffers from RAM
CloseWindow(); // Close window and OpenGL context
CloseAudioDevice(); // Close audio device (music streaming is automatically stopped)
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;

66
examples/audio_music_stream.lua Normal file
View File

@@ -0,0 +1,66 @@
-------------------------------------------------------------------------------------------
--
-- raylib [audio] example - Music playing (streaming)
--
-- NOTE: This example requires OpenAL Soft library installed
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)")
InitAudioDevice() -- Initialize audio device
local music = LoadMusicStream("resources/audio/guitar_noodling.ogg")
PlayMusicStream(music)
local framesCounter = 0
local timePlayed = 0.0
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
framesCounter = framesCounter + 1
timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4 -- We scale by 4 to fit 400 pixels
UpdateMusicStream(music) -- Update music buffer with new stream data
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY)
DrawRectangle(200, 250, 400, 12, LIGHTGRAY)
DrawRectangle(200, 250, timePlayed//1, 12, MAROON)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadMusicStream(music) -- Unload music stream buffers from RAM
CloseAudioDevice() -- Close audio device (music streaming is automatically stopped)
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

111
examples/audio_raw_stream.c Normal file
View File

@@ -0,0 +1,111 @@
/*******************************************************************************************
*
* 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) 2015 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#include <stdlib.h> // Required for: malloc(), free()
#include <math.h> // Required for: sinf()
#define MAX_SAMPLES 20000
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int 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)
AudioStream stream = InitAudioStream(22050, 32, 1);
// Fill audio stream with some samples (sine wave)
float *data = (float *)malloc(sizeof(float)*MAX_SAMPLES);
for (int i = 0; i < MAX_SAMPLES; i++)
{
data[i] = sinf(((2*PI*(float)i)/2)*DEG2RAD);
}
// 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);
int totalSamples = MAX_SAMPLES;
int samplesLeft = totalSamples;
Vector2 position = { 0, 0 };
SetTargetFPS(30); // Set our game to run at 30 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// Refill audio stream if required
if (IsAudioBufferProcessed(stream))
{
int numSamples = 0;
if (samplesLeft >= 4096) numSamples = 4096;
else numSamples = samplesLeft;
UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples);
samplesLeft -= numSamples;
// Reset samples feeding (loop audio)
if (samplesLeft <= 0) samplesLeft = totalSamples;
}
//----------------------------------------------------------------------------------
// 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 (int i = 0; i < GetScreenWidth(); i++)
{
position.x = i;
position.y = 250 + 50*data[i];
DrawPixelV(position, RED);
}
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
free(data); // Unload sine wave data
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
//--------------------------------------------------------------------------------------
return 0;
}

97
examples/audio_raw_stream.lua Normal file
View File

@@ -0,0 +1,97 @@
-------------------------------------------------------------------------------------------
--
-- raylib [audio] example - Raw audio streaming
--
-- NOTE: This example requires OpenAL Soft library installed
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
MAX_SAMPLES = 20000
DEG2RAD = math.pi/180.0
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming")
InitAudioDevice() -- Initialize audio device
-- Init raw audio stream (sample rate: 22050, sample size: 32bit-float, channels: 1-mono)
local stream = InitAudioStream(22050, 32, 1)
-- Fill audio stream with some samples (sine wave)
local data = {}
for i = 1, MAX_SAMPLES do
data[i] = math.sin(((2*math.pi*i)/2)*DEG2RAD)
end
-- NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop
-- for that reason, there is a clip everytime audio stream is looped
PlayAudioStream(stream)
local totalSamples = MAX_SAMPLES
local samplesLeft = totalSamples
local position = Vector2(0, 0)
SetTargetFPS(30) -- Set our game to run at 30 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- Refill audio stream if required
if (IsAudioBufferProcessed(stream)) then
local numSamples = 0
if (samplesLeft >= 4096) then numSamples = 4096
else numSamples = samplesLeft end
UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples)
samplesLeft = samplesLeft - numSamples
-- Reset samples feeding (loop audio)
if (samplesLeft <= 0) then samplesLeft = totalSamples end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY)
-- NOTE: Draw a part of the sine wave (only screen width)
for i = 1, GetScreenWidth() do
position.x = (i - 1)
position.y = 250 + 50*data[i]
DrawPixelV(position, RED)
end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseAudioStream(stream) -- Close raw audio stream and delete buffers from RAM
CloseAudioDevice() -- Close audio device (music streaming is automatically stopped)
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

1
examples/audio_sound_loading.c
View File

@@ -36,7 +36,6 @@ int main()
// Update
//----------------------------------------------------------------------------------
if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav); // Play WAV sound
if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg); // Play OGG sound
//----------------------------------------------------------------------------------

59
examples/audio_sound_loading.lua Normal file
View File

@@ -0,0 +1,59 @@
-------------------------------------------------------------------------------------------
--
-- raylib [audio] example - Sound loading and playing
--
-- NOTE: This example requires OpenAL Soft library installed
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing")
InitAudioDevice() -- Initialize audio device
local fxWav = LoadSound("resources/audio/weird.wav") -- Load WAV audio file
local fxOgg = LoadSound("resources/audio/tanatana.ogg") -- Load OGG audio file
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyPressed(KEY.SPACE)) then PlaySound(fxWav) end -- Play WAV sound
if (IsKeyPressed(KEY.ENTER)) then PlaySound(fxOgg) end -- Play OGG sound
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY)
DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadSound(fxWav) -- Unload sound data
UnloadSound(fxOgg) -- Unload sound data
CloseAudioDevice() -- Close audio device
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

11
examples/audio_standalone.c
View File

@@ -39,7 +39,8 @@ int main()
Sound fxWav = LoadSound("resources/audio/weird.wav"); // Load WAV audio file
Sound fxOgg = LoadSound("resources/audio/tanatana.ogg"); // Load OGG audio file
PlayMusicStream(0, "resources/audio/guitar_noodling.ogg");
Music music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
PlayMusicStream(music);
printf("\nPress s or d to play sounds...\n");
@@ -59,11 +60,13 @@ int main()
key = 0;
}
UpdateMusicStream(0);
UpdateMusicStream(music);
}
UnloadSound(fxWav); // Unload sound data
UnloadSound(fxOgg); // Unload sound data
UnloadSound(fxWav); // Unload sound data
UnloadSound(fxOgg); // Unload sound data
UnloadMusicStream(music); // Unload music stream data
CloseAudioDevice();

130
examples/core_2d_camera.lua Normal file
View File

@@ -0,0 +1,130 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - 2d camera
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
MAX_BUILDINGS = 100
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera")
local player = Rectangle(400, 280, 40, 40)
local buildings = {}
local buildColors = {}
local spacing = 0;
for i = 1, MAX_BUILDINGS do
buildings[i] = Rectangle(0, 0, 0, 0)
buildings[i].width = GetRandomValue(50, 200)
buildings[i].height = GetRandomValue(100, 800)
buildings[i].y = screenHeight - 130 - buildings[i].height
buildings[i].x = -6000 + spacing
spacing = spacing + buildings[i].width
buildColors[i] = Color(GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255)
end
local camera = Camera2D(Vector2(0, 0), Vector2(0, 0), 0.0, 1.0)
camera.target = Vector2(player.x + 20, player.y + 20)
camera.offset = Vector2(0, 0)
camera.rotation = 0.0
camera.zoom = 1.0
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyDown(KEY.RIGHT)) then
player.x = player.x + 2 -- Player movement
camera.offset.x = camera.offset.x - 2 -- Camera displacement with player movement
elseif (IsKeyDown(KEY.LEFT)) then
player.x = player.x - 2 -- Player movement
camera.offset.x = camera.offset.x + 2 -- Camera displacement with player movement
end
-- Camera target follows player
camera.target = Vector2(player.x + 20, player.y + 20)
-- Camera rotation controls
if (IsKeyDown(KEY.A)) then camera.rotation = camera.rotation - 1
elseif (IsKeyDown(KEY.S)) then camera.rotation = camera.rotation + 1
end
-- Limit camera rotation to 80 degrees (-40 to 40)
if (camera.rotation > 40) then camera.rotation = 40
elseif (camera.rotation < -40) then camera.rotation = -40
end
-- Camera zoom controls
camera.zoom = camera.zoom + (GetMouseWheelMove()*0.05)
if (camera.zoom > 3.0) then camera.zoom = 3.0
elseif (camera.zoom < 0.1) then camera.zoom = 0.1
end
-- Camera reset (zoom and rotation)
if (IsKeyPressed(KEY.R)) then
camera.zoom = 1.0
camera.rotation = 0.0
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin2dMode(camera)
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
-------------------------------------------------------------------------------------------

9
examples/core_3d_camera_first_person.c
View File

@@ -23,7 +23,7 @@ int main()
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
// Define the camera to look into our 3d world (position, target, up vector)
Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 60.0f };
Camera camera = {{ 4.0f, 2.0f, 4.0f }, { 0.0f, 1.8f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 60.0f };
// Generates some random columns
float heights[MAX_COLUMNS];
@@ -37,10 +37,7 @@ int main()
colors[i] = (Color){ GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 };
}
Vector3 playerPosition = { 4.0f, 2.0f, 4.0f }; // Define player position
SetCameraMode(CAMERA_FIRST_PERSON); // Set a first person camera mode
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set a first person camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -50,7 +47,7 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCameraPlayer(&camera, &playerPosition); // Update camera and player position
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

85
examples/core_3d_camera_first_person.lua Normal file
View File

@@ -0,0 +1,85 @@
--------------------------------------------------------------------------------------------
--
-- raylib [core] example - 3d camera first person
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
--------------------------------------------------------------------------------------------
MAX_COLUMNS = 20
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person")
-- Define the camera to look into our 3d world (position, target, up vector)
local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 60.0)
-- Generates some random columns
local heights = {}
local positions = {}
local colors = {}
for i = 1, MAX_COLUMNS do
heights[i] = GetRandomValue(1, 12)
positions[i] = Vector3(GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15))
colors[i] = Color(GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255)
end
local playerPosition = Vector3(4.0, 2.0, 4.0) -- Define player position
SetCameraMode(CameraMode.FIRST_PERSON) -- Set a first person camera mode
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera, playerPosition = UpdateCameraPlayer(camera, playerPosition) -- Update camera and player position
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawPlane(Vector3(0.0, 0.0, 0.0), Vector2(32.0, 32.0), LIGHTGRAY) -- Draw ground
DrawCube(Vector3(-16.0, 2.5, 0.0), 1.0, 5.0, 32.0, BLUE) -- Draw a blue wall
DrawCube(Vector3(16.0, 2.5, 0.0), 1.0, 5.0, 32.0, LIME) -- Draw a green wall
DrawCube(Vector3(0.0, 2.5, 16.0), 32.0, 5.0, 1.0, GOLD) -- Draw a yellow wall
-- Draw some cubes around
for i = 1, MAX_COLUMNS do
DrawCube(positions[i], 2.0, heights[i], 2.0, colors[i])
DrawCubeWires(positions[i], 2.0, heights[i], 2.0, MAROON)
end
End3dMode()
DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5))
DrawRectangleLines( 10, 10, 220, 70, BLUE)
DrawText("First person camera default controls:", 20, 20, 10, BLACK)
DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY)
DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

11
examples/core_3d_camera_free.c
View File

@@ -22,17 +22,14 @@ int main()
// Define the camera to look into our 3d world
Camera camera;
camera.position = (Vector3){ 0.0f, 10.0f, 10.0f }; // Camera position
camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target)
camera.fovy = 45.0f; // Camera field-of-view Y
Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
SetCameraMode(CAMERA_FREE); // Set a free camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -42,7 +39,9 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
//----------------------------------------------------------------------------------
// Draw

75
examples/core_3d_camera_free.lua Normal file
View File

@@ -0,0 +1,75 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Initialize 3d camera free
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
--------------------------------------------------------------------------------------------
-- Initialization
----------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free")
-- Define the camera to look into our 3d world
local camera = {}
camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position
camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point
camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target)
camera.fovy = 45.0 -- Camera field-of-view Y
local cubePosition = Vector3(0.0, 0.0, 0.0)
SetCameraMode(CameraMode.FREE) -- Set a free camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
DrawGrid(10, 1.0)
End3dMode()
DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5))
DrawRectangleLines( 10, 10, 320, 133, BLUE)
DrawText("Free camera default controls:", 20, 20, 10, BLACK)
DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY)
DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY)
DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY)
DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY)
DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

64
examples/core_3d_mode.lua Normal file
View File

@@ -0,0 +1,64 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Initialize 3d mode
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode")
-- Define the camera to look into our 3d world
local camera = {}
camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position
camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point
camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target)
camera.fovy = 45.0 -- Camera field-of-view Y
local cubePosition = Vector3(0.0, 0.0, 0.0)
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera) -- ERROR: Lua Error: attempt to index a number value (?)
DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
DrawGrid(10, 1.0)
End3dMode()
DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

8
examples/core_3d_picking.c
View File

@@ -22,7 +22,7 @@ int main()
// Define the camera to look into our 3d world
Camera camera;
camera.position = (Vector3){ 0.0f, 10.0f, 10.0f }; // Camera position
camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target)
camera.fovy = 45.0f; // Camera field-of-view Y
@@ -34,9 +34,7 @@ int main()
bool collision = false;
SetCameraMode(CAMERA_FREE); // Set a free camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -46,7 +44,7 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
{

98
examples/core_3d_picking.lua Normal file
View File

@@ -0,0 +1,98 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Picking in 3d mode
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking")
-- Define the camera to look into our 3d world
local camera = {}
camera.position = Vector3(0.0, 10.0, 10.0) -- Camera position
camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point
camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target)
camera.fovy = 45.0 -- Camera field-of-view Y
local cubePosition = Vector3(0.0, 1.0, 0.0)
local cubeSize = Vector3(2.0, 2.0, 2.0)
local ray = Ray(Vector3(0, 0, 0), Vector3(0, 0, 0)) -- Picking line ray
local collision = false
SetCameraMode(CameraMode.FREE) -- Set a free camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then
-- NOTE: This function is NOT WORKING properly!
ray = GetMouseRay(GetMousePosition(), camera)
-- Check collision between ray and box
collision = CheckCollisionRayBox(ray,
BoundingBox(Vector3(cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2),
Vector3(cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2)))
--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
-------------------------------------------------------------------------------------------

62
examples/core_basic_window.cpp Normal file
View File

@@ -0,0 +1,62 @@
/*******************************************************************************************
*
* raylib [core] example - Basic window
*
* Welcome to raylib!
*
* To test examples, just press F6 and execute raylib_compile_execute script
* Note that compiled executable is placed in the same folder as .c file
*
* You can find all basic examples on C:\raylib\raylib\examples folder or
* raylib official webpage: www.raylib.com
*
* Enjoy using raylib. :)
*
* This example has been created using raylib 1.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2014 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
int main(int argc, char* argv[])
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // 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();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}

44
examples/core_basic_window.lua Normal file
View File

@@ -0,0 +1,44 @@
-------------------------------------------------------------------------------------------
--
-- 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 Normal file
View File

@@ -0,0 +1,82 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Color selection by mouse (collision detection)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
NUM_RECTANGLES = 21
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)")
local colors = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
GREEN, SKYBLUE, PURPLE, BEIGE }
local colorsRecs = {} -- Rectangles array
local selected = {}
-- Fills colorsRecs data (for every rectangle)
for i = 1, NUM_RECTANGLES do
colorsRecs[i] = Rectangle(0, 0, 0, 0)
colorsRecs[i].x = 20 + 100*((i-1)%7) + 10*((i-1)%7)
colorsRecs[i].y = 60 + 100*((i-1)//7) + 10*((i-1)//7) -- Using floor division: //
colorsRecs[i].width = 100
colorsRecs[i].height = 100
selected[i] = false
end
local mousePoint = Vector2(0, 0)
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
mousePoint = GetMousePosition()
for i = 1, NUM_RECTANGLES do -- Iterate along all the rectangles
if (CheckCollisionPointRec(mousePoint, colorsRecs[i])) then
colors[i].a = 120
if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then selected[i] = not selected[i] end
else colors[i].a = 255 end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
for i = 1, NUM_RECTANGLES do -- Draw all rectangles
DrawRectangleRec(colorsRecs[i], colors[i])
-- Draw four rectangles around selected rectangle
if (selected[i]) then
DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 100, 10, RAYWHITE) -- Square top rectangle
DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 10, 100, RAYWHITE) -- Square left rectangle
DrawRectangle(colorsRecs[i].x + 90, colorsRecs[i].y, 10, 100, RAYWHITE) -- Square right rectangle
DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + 90, 100, 10, RAYWHITE) -- Square bottom rectangle
end
end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

66
examples/core_drop_files.lua Normal file
View File

@@ -0,0 +1,66 @@
-------------------------------------------------------------------------------------------
--
-- 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 Normal file
View File

@@ -0,0 +1,102 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Gestures Detection
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
MAX_GESTURE_STRINGS = 20
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - gestures detection")
local touchPosition = Vector2(0, 0)
local touchArea = Rectangle(220, 10, screenWidth - 230, screenHeight - 20)
local gesturesCount = 0
local gestureStrings = {}
for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "" end
local currentGesture = Gestures.NONE
local lastGesture = Gestures.NONE
--SetGesturesEnabled(0b0000000000001001) -- Enable only some gestures to be detected
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
lastGesture = currentGesture
currentGesture = GetGestureDetected()
touchPosition = GetTouchPosition(0)
if (CheckCollisionPointRec(touchPosition, touchArea) and (currentGesture ~= Gestures.NONE)) then
if (currentGesture ~= lastGesture) then
-- Store gesture string
if (currentGesture == Gestures.TAP) then gestureStrings[gesturesCount] = "GESTURE TAP"
elseif (currentGesture == Gestures.DOUBLETAP) then gestureStrings[gesturesCount] = "GESTURE DOUBLETAP"
elseif (currentGesture == Gestures.HOLD) then gestureStrings[gesturesCount] = "GESTURE HOLD"
elseif (currentGesture == Gestures.DRAG) then gestureStrings[gesturesCount] = "GESTURE DRAG"
elseif (currentGesture == Gestures.SWIPE_RIGHT) then gestureStrings[gesturesCount] = "GESTURE SWIPE RIGHT"
elseif (currentGesture == Gestures.SWIPE_LEFT) then gestureStrings[gesturesCount] = "GESTURE SWIPE LEFT"
elseif (currentGesture == Gestures.SWIPE_UP) then gestureStrings[gesturesCount] = "GESTURE SWIPE UP"
elseif (currentGesture == Gestures.SWIPE_DOWN) then gestureStrings[gesturesCount] = "GESTURE SWIPE DOWN"
elseif (currentGesture == Gestures.PINCH_IN) then gestureStrings[gesturesCount] = "GESTURE PINCH IN"
elseif (currentGesture == Gestures.PINCH_OUT) then gestureStrings[gesturesCount] = "GESTURE PINCH OUT"
end
gesturesCount = gesturesCount + 1
-- Reset gestures strings
if (gesturesCount >= MAX_GESTURE_STRINGS) then
for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "\0" end
gesturesCount = 0
end
end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawRectangleRec(touchArea, GRAY)
DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE)
DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5))
for i = 1, gesturesCount do
if ((i - 1)%2 == 0) then DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.5))
else DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.3)) end
if (i < gesturesCount) then DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, DARKGRAY)
else DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, MAROON) end
end
DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY)
DrawText("DETECTED GESTURES", 50, 15, 10, GRAY)
if (currentGesture ~= GESTURE_NONE) then DrawCircleV(touchPosition, 30, MAROON) end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

63
examples/core_input_gamepad.lua Normal file
View File

@@ -0,0 +1,63 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Gamepad input
--
-- NOTE: This example requires a Gamepad connected to the system
-- raylib is configured to work with Xbox 360 gamepad, check raylib.h for buttons configuration
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input")
local ballPosition = Vector2(screenWidth/2, screenHeight/2)
local gamepadMovement = Vector2(0, 0)
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsGamepadAvailable(GAMEPAD.PLAYER1)) then
gamepadMovement.x = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_X)
gamepadMovement.y = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_Y)
ballPosition.x = ballPosition.x + gamepadMovement.x
ballPosition.y = ballPosition.y - gamepadMovement.y
if (IsGamepadButtonPressed(GAMEPAD.PLAYER1, GAMEPAD.BUTTON_A)) then
ballPosition.x = screenWidth/2
ballPosition.y = screenHeight/2
end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY)
DrawCircleV(ballPosition, 50, MAROON)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

51
examples/core_input_keys.lua Normal file
View File

@@ -0,0 +1,51 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Keyboard input
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window")
local ballPosition = Vector2(screenWidth/2, screenHeight/2)
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyDown(KEY.RIGHT)) then ballPosition.x = ballPosition.x + 0.8 end
if (IsKeyDown(KEY.LEFT)) then ballPosition.x = ballPosition.x - 0.8 end
if (IsKeyDown(KEY.UP)) then ballPosition.y = ballPosition.y - 0.8 end
if (IsKeyDown(KEY.DOWN)) then ballPosition.y = ballPosition.y + 0.8 end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY)
DrawCircleV(ballPosition, 50, MAROON)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

54
examples/core_input_mouse.lua Normal file
View File

@@ -0,0 +1,54 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Mouse input
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input")
local ballPosition = Vector2(-100.0, -100.0)
local ballColor = DARKBLUE
SetTargetFPS(60) -- Set target frames-per-second
-----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
------------------------------------------------------------------------------------
ballPosition = GetMousePosition()
if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then ballColor = MAROON
elseif (IsMouseButtonPressed(MOUSE.MIDDLE_BUTTON)) then ballColor = LIME
elseif (IsMouseButtonPressed(MOUSE.RIGHT_BUTTON)) then ballColor = DARKBLUE
end
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawCircleV(ballPosition, 40, ballColor)
DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY)
EndDrawing()
------------------------------------------------------------------------------------
end
-- De-Initialization
----------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
----------------------------------------------------------------------------------------

50
examples/core_mouse_wheel.lua Normal file
View File

@@ -0,0 +1,50 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] examples - Mouse wheel
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel")
local boxPositionY = screenHeight/2 - 40
local scrollSpeed = 4 -- Scrolling speed in pixels
SetTargetFPS(60) -- Set target frames-per-second
----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
------------------------------------------------------------------------------------
boxPositionY = boxPositionY - (GetMouseWheelMove()*scrollSpeed)
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON)
DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY)
DrawText(string.format("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY)
EndDrawing()
------------------------------------------------------------------------------------
end
-- De-Initialization
----------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
----------------------------------------------------------------------------------------

13
examples/core_oculus_rift.c
View File

@@ -30,13 +30,15 @@ int main()
// Define the camera to look into our 3d world
Camera camera;
camera.position = (Vector3){ 5.0f, 5.0f, 5.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point
camera.position = (Vector3){ 5.0f, 2.0f, 5.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 2.0f, 0.0f }; // Camera looking at point
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target)
camera.fovy = 60.0f; // Camera field-of-view Y
Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set first person camera mode
SetTargetFPS(90); // Set our game to run at 90 frames-per-second
//--------------------------------------------------------------------------------------
@@ -45,9 +47,10 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateVrTracking();
if (IsVrSimulator()) UpdateCamera(&camera); // Update camera (simulator mode)
else UpdateVrTracking(&camera); // Update camera with device tracking data
if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();
if (IsKeyPressed(KEY_SPACE)) ToggleVrMode(); // Toggle VR mode
//----------------------------------------------------------------------------------
// Draw
@@ -61,7 +64,7 @@ int main()
DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
DrawGrid(10, 1.0f);
DrawGrid(40, 1.0f);
End3dMode();

73
examples/core_oculus_rift.lua Normal file
View File

@@ -0,0 +1,73 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Oculus Rift CV1
--
-- NOTE: Example requires linkage with LibOVR
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 1080
local screenHeight = 600
-- NOTE: screenWidth/screenHeight should match VR device aspect ratio
InitWindow(screenWidth, screenHeight, "raylib [core] example - oculus rift")
-- NOTE: If device is not available, it fallbacks to default device (simulator)
InitVrDevice(VrDevice.OCULUS_RIFT_CV1) -- Init VR device (Oculus Rift CV1)
-- Define the camera to look into our 3d world
local camera = {}
camera.position = Vector3(5.0, 5.0, 5.0) -- Camera position
camera.target = Vector3(0.0, 0.0, 0.0) -- Camera looking at point
camera.up = Vector3(0.0, 1.0, 0.0) -- Camera up vector (rotation towards target)
camera.fovy = 60.0 -- Camera field-of-view Y
local cubePosition = Vector3(0.0, 0.0, 0.0)
SetTargetFPS(90) -- Set our game to run at 90 frames-per-second
----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
------------------------------------------------------------------------------------
UpdateVrTracking()
if (IsKeyPressed(KEY.SPACE)) then ToggleVrMode() end
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
DrawGrid(10, 1.0)
End3dMode()
DrawFPS(10, 10)
EndDrawing()
------------------------------------------------------------------------------------
end
-- De-Initialization
----------------------------------------------------------------------------------------
CloseVrDevice() -- Close VR device
CloseWindow() -- Close window and OpenGL context
----------------------------------------------------------------------------------------

56
examples/core_random_values.lua Normal file
View File

@@ -0,0 +1,56 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Generate random values
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values")
local framesCounter = 0 -- Variable used to count frames
local randValue = GetRandomValue(-8, 5) -- Get a random integer number between -8 and 5 (both included)
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
------------------------------------------------------------------------------------
framesCounter = framesCounter + 1
-- Every two seconds (120 frames) a new random value is generated
if (((framesCounter/120)%2) == 1) then
randValue = GetRandomValue(-8, 5)
framesCounter = 0
end
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON)
DrawText(string.format("%i", randValue), 360, 180, 80, LIGHTGRAY)
EndDrawing()
------------------------------------------------------------------------------------
end
-- De-Initialization
----------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
----------------------------------------------------------------------------------------

74
examples/core_storage_values.lua Normal file
View File

@@ -0,0 +1,74 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - Storage save/load values
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- NOTE: Storage positions must start with 0, directly related to file memory layout
STORAGE_SCORE = 0
STORAGE_HISCORE = 1
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values")
local score = 0
local hiscore = 0
local framesCounter = 0
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyPressed(KEY.R)) then
score = GetRandomValue(1000, 2000)
hiscore = GetRandomValue(2000, 4000)
end
if (IsKeyPressed(KEY.ENTER)) then
StorageSaveValue(STORAGE_SCORE, score)
StorageSaveValue(STORAGE_HISCORE, hiscore)
elseif (IsKeyPressed(KEY.SPACE)) then
-- NOTE: If requested position could not be found, value 0 is returned
score = StorageLoadValue(STORAGE_SCORE)
hiscore = StorageLoadValue(STORAGE_HISCORE)
end
framesCounter = framesCounter + 1
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(string.format("SCORE: %i", score), 280, 130, 40, MAROON)
DrawText(string.format("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK)
DrawText(string.format("frames: %i", framesCounter), 10, 10, 20, LIME)
DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY)
DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY)
DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

9
examples/core_world_screen.c
View File

@@ -21,16 +21,13 @@ int main()
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
// Define the camera to look into our 3d world
Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Camera camera = {{ 10.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
Vector2 cubeScreenPosition;
SetCameraMode(CAMERA_FREE); // Set a free camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -40,7 +37,7 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our 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.5f, cubePosition.z}, camera);

69
examples/core_world_screen.lua Normal file
View File

@@ -0,0 +1,69 @@
-------------------------------------------------------------------------------------------
--
-- raylib [core] example - World to screen
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local cubePosition = Vector3(0.0, 0.0, 0.0)
local cubeScreenPosition = Vector2(0, 0)
SetCameraMode(CameraMode.FREE) -- Set a free camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
-- Calculate cube screen space position (with a little offset to be in top)
cubeScreenPosition = GetWorldToScreen(Vector3(cubePosition.x, cubePosition.y + 2.5, cubePosition.z), camera)
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
DrawGrid(10, 1.0)
End3dMode()
DrawText("Enemy: 100 / 100", cubeScreenPosition.x//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
----------------------------------------------------------------------------------------

11
examples/models_billboard.c
View File

@@ -26,20 +26,17 @@ int main()
Texture2D bill = LoadTexture("resources/billboard.png"); // Our texture billboard
Vector3 billPosition = { 0.0f, 2.0f, 0.0f }; // Position where draw billboard
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

65
examples/models_billboard.lua Normal file
View File

@@ -0,0 +1,65 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Drawing billboards
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(5.0, 4.0, 5.0), Vector3(0.0, 2.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local bill = LoadTexture("resources/billboard.png") -- Our texture billboard
local billPosition = Vector3(0.0, 2.0, 0.0) -- Position where draw billboard
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our 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 Normal file
View File

@@ -0,0 +1,115 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Detect basic 3d collisions (box vs sphere vs box)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local playerPosition = Vector3(0.0, 1.0, 2.0)
local playerSize = Vector3(1.0, 2.0, 1.0)
local playerColor = GREEN
local enemyBoxPos = Vector3(-4.0, 1.0, 0.0)
local enemyBoxSize = Vector3(2.0, 2.0, 2.0)
local enemySpherePos = Vector3(4.0, 0.0, 0.0)
local enemySphereSize = 1.5
local collision = false
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- Move player
if (IsKeyDown(KEY.RIGHT)) then playerPosition.x = playerPosition.x + 0.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
-------------------------------------------------------------------------------------------

10
examples/models_cubicmap.c
View File

@@ -35,19 +35,17 @@ int main()
UnloadImage(image); // Unload cubesmap image from RAM, already uploaded to VRAM
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our custom camera position
SetCameraFovy(camera.fovy); // Set internal camera field-of-view Y
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

79
examples/models_cubicmap.lua Normal file
View File

@@ -0,0 +1,79 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Cubicmap loading and drawing
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(16.0, 14.0, 16.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local image = LoadImage("resources/cubicmap.png") -- Load cubicmap image (RAM)
local cubicmap = LoadTextureFromImage(image) -- Convert image to texture to display (VRAM)
local map = LoadCubicmap(image) -- Load cubicmap model (generate model from image)
-- NOTE: By default each cube is mapped to one part of texture atlas
local texture = LoadTexture("resources/cubicmap_atlas.png") -- Load map texture
map.material.texDiffuse = texture -- Set map diffuse texture
local mapPosition = Vector3(-16.0, 0.0, -8.0) -- Set model position
UnloadImage(image) -- Unload cubesmap image from RAM, already uploaded to VRAM
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position
SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawModel(map, mapPosition, 1.0, WHITE)
End3dMode()
DrawTextureEx(cubicmap, (Vector2)(screenWidth - cubicmap.width*4 - 20, 20), 0.0, 4.0, WHITE)
DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN)
DrawText("cubicmap image used to", 658, 90, 10, GRAY)
DrawText("generate map 3d model", 658, 104, 10, GRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(cubicmap) -- Unload cubicmap texture
UnloadTexture(texture) -- Unload map texture
UnloadModel(map) -- Unload map model
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

67
examples/models_geometric_shapes.lua Normal file
View File

@@ -0,0 +1,67 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera) -- ERROR: Lua Error: attempt to index a number value
DrawCube(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, RED)
DrawCubeWires(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, GOLD)
DrawCubeWires(Vector3(-4.0, 0.0, -2.0), 3.0, 6.0, 2.0, MAROON)
DrawSphere(Vector3(-1.0, 0.0, -2.0), 1.0, GREEN)
DrawSphereWires(Vector3(1.0, 0.0, 2.0), 2.0, 16, 16, LIME)
DrawCylinder(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, SKYBLUE)
DrawCylinderWires(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, DARKBLUE)
DrawCylinderWires(Vector3(4.5, -1.0, 2.0), 1.0, 1.0, 2.0, 6, BROWN)
DrawCylinder(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, GOLD)
DrawCylinderWires(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, PINK)
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

11
examples/models_heightmap.c
View File

@@ -29,20 +29,19 @@ int main()
map.material.texDiffuse = texture; // Set map diffuse texture
Vector3 mapPosition = { -8.0f, 0.0f, -8.0f }; // Set model position (depends on model scaling!)
UnloadImage(image); // Unload heightmap image from RAM, already uploaded to VRAM
UnloadImage(image); // Unload heightmap image from RAM, already uploaded to VRAM
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our custom camera position
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

73
examples/models_heightmap.lua Normal file
View File

@@ -0,0 +1,73 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Heightmap loading and drawing
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing")
-- Define our custom camera to look into our 3d world
local camera = Camera(Vector3(18.0, 16.0, 18.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local image = LoadImage("resources/heightmap.png") -- Load heightmap image (RAM)
local texture = LoadTextureFromImage(image) -- Convert image to texture (VRAM)
local map = LoadHeightmap(image, Vector3(16, 8, 16)) -- Load heightmap model with defined size
map.material.texDiffuse = texture -- Set map diffuse texture
local mapPosition = Vector3(-8.0, 0.0, -8.0) -- Set model position (depends on model scaling!)
UnloadImage(image) -- Unload heightmap image from RAM, already uploaded to VRAM
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
----------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
-- NOTE: Model is scaled to 1/4 of its original size (128x128 units)
DrawModel(map, mapPosition, 1.0, RED)
DrawGrid(20, 1.0)
End3dMode()
DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE)
DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texture) -- Unload texture
UnloadModel(map) -- Unload model
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

67
examples/models_obj_loading.lua Normal file
View File

@@ -0,0 +1,67 @@
-------------------------------------------------------------------------------------------
--
-- raylib [models] example - Load and draw a 3d model (OBJ)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model
local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture
dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture
local position = Vector3(0.0, 0.0, 0.0) -- Set model position
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- ...
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawModel(dwarf, position, 2.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
-------------------------------------------------------------------------------------------

11
examples/physics_basic_rigidbody.c
View File

@@ -5,9 +5,16 @@
* This example has been created using raylib 1.5 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* NOTE:
* Physac requires multi-threading, when InitPhysics() a second thread is created to manage
* physics calculations. To accomplish that, physac uses pthread Win32 library that can be
* found inside raylib/src/external/pthread directory.
*
* Compile example using:
* cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
* Add pthread library when compiling physac example:
* gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
* -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
*
* Note that pthreadGC2.dll must be also copied to project directory!
*
* Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
*

12
examples/physics_forces.c
View File

@@ -5,10 +5,16 @@
* This example has been created using raylib 1.5 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* NOTE: This example requires raylib module [rlgl]
* NOTE:
* Physac requires multi-threading, when InitPhysics() a second thread is created to manage
* physics calculations. To accomplish that, physac uses pthread Win32 library that can be
* found inside raylib/src/external/pthread directory.
*
* Compile example using:
* cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
* Add pthread library when compiling physac example:
* gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
* -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
*
* Note that pthreadGC2.dll must be also copied to project directory!
*
* Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
*

BIN
examples/resources/audio/2t2m_spa.xm
View File

Binary file not shown.

BIN
examples/resources/audio/chiptun1.mod Normal file
View File

Binary file not shown.

BIN
examples/resources/audio/mini1111.xm Normal file
View File

Binary file not shown.

30
examples/resources/shaders/glsl100/bloom.fs
View File

@@ -8,30 +8,32 @@ varying vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 fragTintColor;
uniform vec4 colDiffuse;
// NOTE: Add here your custom variables
const vec2 size = vec2(800, 450); // render size
const float samples = 5.0; // pixels per axis; higher = bigger glow, worse performance
const float quality = 2.5; // lower = smaller glow, better quality
void main()
{
vec4 sum = vec4(0);
vec4 tc = vec4(0);
vec2 sizeFactor = vec2(1)/size*quality;
for (int i = -4; i < 4; i++)
// Texel color fetching from texture sampler
vec4 source = texture2D(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int j = -3; j < 3; j++)
for (int y = -range; y <= range; y++)
{
sum += texture2D(texture0, fragTexCoord + vec2(j, i)*0.004) * 0.25;
sum += texture2D(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// Texel color fetching from texture sampler
vec4 texelColor = texture2D(texture0, fragTexCoord);
// Calculate final fragment color
if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
else tc = sum*sum*0.0075 + texelColor;
gl_FragColor = tc;
gl_FragColor = ((sum/(samples*samples)) + source)*colDiffuse;
}

152
examples/resources/shaders/glsl100/standard.fs Normal file
View File

@@ -0,0 +1,152 @@
#version 100
precision mediump float;
varying vec3 fragPosition;
varying vec2 fragTexCoord;
varying vec4 fragColor;
varying vec3 fragNormal;
uniform sampler2D texture0;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform vec4 colAmbient;
uniform vec4 colDiffuse;
uniform vec4 colSpecular;
uniform float glossiness;
uniform int useNormal;
uniform int useSpecular;
uniform mat4 modelMatrix;
uniform vec3 viewDir;
struct Light {
int enabled;
int type;
vec3 position;
vec3 direction;
vec4 diffuse;
float intensity;
float radius;
float coneAngle;
};
const int maxLights = 8;
uniform Light lights[maxLights];
vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1.0));
vec3 surfaceToLight = l.position - surfacePos;
// Diffuse shading
float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(-l.direction + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
{
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
// Combine results
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 lightToSurface = normalize(surfacePos - l.position);
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Spot attenuation
float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
attenuation = dot(lightToSurface, -lightDir);
float lightToSurfaceAngle = degrees(acos(attenuation));
if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
// Combine diffuse and attenuation
float diffAttenuation = diff*attenuation;
// Specular shading
float spec = 0.0;
if (diffAttenuation > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
}
void main()
{
// Calculate fragment normal in screen space
// NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
mat3 normalMatrix = mat3(modelMatrix);
vec3 normal = normalize(normalMatrix*fragNormal);
// Normalize normal and view direction vectors
vec3 n = normalize(normal);
vec3 v = normalize(viewDir);
// Calculate diffuse texture color fetching
vec4 texelColor = texture2D(texture0, fragTexCoord);
vec3 lighting = colAmbient.rgb;
// Calculate normal texture color fetching or set to maximum normal value by default
if (useNormal == 1)
{
n *= texture2D(texture1, fragTexCoord).rgb;
n = normalize(n);
}
// Calculate specular texture color fetching or set to maximum specular value by default
float spec = 1.0;
if (useSpecular == 1) spec = texture2D(texture2, fragTexCoord).r;
for (int i = 0; i < maxLights; i++)
{
// Check if light is enabled
if (lights[i].enabled == 1)
{
// Calculate lighting based on light type
if(lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
else if(lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
else if(lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
// NOTE: It seems that too many ComputeLight*() operations inside for loop breaks the shader on RPI
}
}
// Calculate final fragment color
gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
}

23
examples/resources/shaders/glsl100/standard.vs Normal file
View File

@@ -0,0 +1,23 @@
#version 100
attribute vec3 vertexPosition;
attribute vec3 vertexNormal;
attribute vec2 vertexTexCoord;
attribute vec4 vertexColor;
varying vec3 fragPosition;
varying vec2 fragTexCoord;
varying vec4 fragColor;
varying vec3 fragNormal;
uniform mat4 mvpMatrix;
void main()
{
fragPosition = vertexPosition;
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
fragNormal = vertexNormal;
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

30
examples/resources/shaders/glsl330/bloom.fs
View File

@@ -6,33 +6,35 @@ in vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 fragTintColor;
uniform vec4 colDiffuse;
// Output fragment color
out vec4 finalColor;
// NOTE: Add here your custom variables
const vec2 size = vec2(800, 450); // render size
const float samples = 5.0; // pixels per axis; higher = bigger glow, worse performance
const float quality = 2.5; // lower = smaller glow, better quality
void main()
{
vec4 sum = vec4(0);
vec4 tc = vec4(0);
vec2 sizeFactor = vec2(1)/size*quality;
for (int i = -4; i < 4; i++)
// Texel color fetching from texture sampler
vec4 source = texture(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int j = -3; j < 3; j++)
for (int y = -range; y <= range; y++)
{
sum += texture(texture0, fragTexCoord + vec2(j, i)*0.004)*0.25;
sum += texture(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// Texel color fetching from texture sampler
vec4 texelColor = texture(texture0, fragTexCoord);
// Calculate final fragment color
if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
else tc = sum*sum*0.0075 + texelColor;
finalColor = tc;
// Calculate final fragment color
finalColor = ((sum/(samples*samples)) + source)*colDiffuse;
}

150
examples/resources/shaders/glsl330/standard.fs Normal file
View File

@@ -0,0 +1,150 @@
#version 330
in vec3 fragPosition;
in vec2 fragTexCoord;
in vec4 fragColor;
in vec3 fragNormal;
out vec4 finalColor;
uniform sampler2D texture0;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform vec4 colAmbient;
uniform vec4 colDiffuse;
uniform vec4 colSpecular;
uniform float glossiness;
uniform int useNormal;
uniform int useSpecular;
uniform mat4 modelMatrix;
uniform vec3 viewDir;
struct Light {
int enabled;
int type;
vec3 position;
vec3 direction;
vec4 diffuse;
float intensity;
float radius;
float coneAngle;
};
const int maxLights = 8;
uniform Light lights[maxLights];
vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 surfaceToLight = l.position - surfacePos;
// Diffuse shading
float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(-l.direction + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
{
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
// Combine results
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 lightToSurface = normalize(surfacePos - l.position);
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Spot attenuation
float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
attenuation = dot(lightToSurface, -lightDir);
float lightToSurfaceAngle = degrees(acos(attenuation));
if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
// Combine diffuse and attenuation
float diffAttenuation = diff*attenuation;
// Specular shading
float spec = 0.0;
if (diffAttenuation > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
}
void main()
{
// Calculate fragment normal in screen space
// NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
mat3 normalMatrix = mat3(modelMatrix);
vec3 normal = normalize(normalMatrix*fragNormal);
// Normalize normal and view direction vectors
vec3 n = normalize(normal);
vec3 v = normalize(viewDir);
// Calculate diffuse texture color fetching
vec4 texelColor = texture(texture0, fragTexCoord);
vec3 lighting = colAmbient.rgb;
// Calculate normal texture color fetching or set to maximum normal value by default
if (useNormal == 1)
{
n *= texture(texture1, fragTexCoord).rgb;
n = normalize(n);
}
// Calculate specular texture color fetching or set to maximum specular value by default
float spec = 1.0;
if (useSpecular == 1) spec = texture(texture2, fragTexCoord).r;
for (int i = 0; i < maxLights; i++)
{
// Check if light is enabled
if (lights[i].enabled == 1)
{
// Calculate lighting based on light type
if (lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
else if (lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
else if (lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
}
}
// Calculate final fragment color
finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
}

23
examples/resources/shaders/glsl330/standard.vs Normal file
View File

@@ -0,0 +1,23 @@
#version 330
in vec3 vertexPosition;
in vec3 vertexNormal;
in vec2 vertexTexCoord;
in vec4 vertexColor;
out vec3 fragPosition;
out vec2 fragTexCoord;
out vec4 fragColor;
out vec3 fragNormal;
uniform mat4 mvpMatrix;
void main()
{
fragPosition = vertexPosition;
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
fragNormal = vertexNormal;
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

90
examples/rlua_execute_file.c Normal file
View File

@@ -0,0 +1,90 @@
/*******************************************************************************************
*
* 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 -lopenal32 -llua53 -lgdi32 -std=c99
*
* 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("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;
}

6
examples/shaders_custom_uniform.c
View File

@@ -51,9 +51,7 @@ int main()
RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
// Setup orbital camera
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -71,7 +69,7 @@ int main()
// Send new value to the shader to be used on drawing
SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2);
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

115
examples/shaders_custom_uniform.lua Normal file
View File

@@ -0,0 +1,115 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shaders] example - Apply a postprocessing shader and connect a custom uniform variable
--
-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
--
-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-- raylib comes with shaders ready for both versions, check raylib/shaders install folder
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model
local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map)
dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture
local position = Vector3(0.0, 0.0, 0.0) -- Set model position
local shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/swirl.fs") -- Load postpro shader
-- Get variable (uniform) location on the shader to connect with the program
-- NOTE: If uniform variable could not be found in the shader, function returns -1
local swirlCenterLoc = GetShaderLocation(shader, "center")
local swirlCenter = { screenWidth/2, screenHeight/2 }
-- Create a RenderTexture2D to be used for render to texture
local target = LoadRenderTexture(screenWidth, screenHeight)
-- Setup orbital camera
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
local mousePosition = GetMousePosition()
swirlCenter[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 internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
BeginTextureMode(target) -- Enable drawing to texture
Begin3dMode(camera)
DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawText("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED)
EndTextureMode() -- End drawing to texture (now we have a texture available for next passes)
BeginShaderMode(shader)
-- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
EndShaderMode()
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadShader(shader) -- Unload shader
UnloadTexture(texture) -- Unload texture
UnloadModel(dwarf) -- Unload model
UnloadRenderTexture(target) -- Unload render texture
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

20
examples/shaders_model_shader.c
View File

@@ -37,25 +37,22 @@ int main()
Shader 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
dwarf.material.shader = shader; // Set shader effect to 3d model
dwarf.material.texDiffuse = texture; // Bind texture to model
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
// Setup orbital camera
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraMode(camera, CAMERA_FREE); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update internal camera and our camera
//----------------------------------------------------------------------------------
// Draw
@@ -73,6 +70,9 @@ int main()
End3dMode();
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
DrawText(FormatText("Camera position: (%.2f, %.2f, %.2f)", camera.position.x, camera.position.y, camera.position.z), 600, 20, 10, BLACK);
DrawText(FormatText("Camera target: (%.2f, %.2f, %.2f)", camera.target.x, camera.target.y, camera.target.z), 600, 40, 10, GRAY);
DrawFPS(10, 10);

85
examples/shaders_model_shader.lua Normal file
View File

@@ -0,0 +1,85 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shaders] example - Apply a shader to a 3d model
--
-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
--
-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-- raylib comes with shaders ready for both versions, check raylib/shaders install folder
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model
local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture
local shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/grayscale.fs") -- Load model shader
dwarf.material.shader = shader -- Set shader effect to 3d model
dwarf.material.texDiffuse = texture -- Bind texture to model
local position = Vector3(0.0, 0.0, 0.0) -- Set model position
-- Setup orbital camera
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadShader(shader) -- Unload shader
UnloadTexture(texture) -- Unload texture
UnloadModel(dwarf) -- Unload model
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

8
examples/shaders_postprocessing.c
View File

@@ -45,9 +45,7 @@ int main()
RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
// Setup orbital camera
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -57,7 +55,7 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw
@@ -67,7 +65,7 @@ int main()
ClearBackground(RAYWHITE);
BeginTextureMode(target); // Enable drawing to texture
Begin3dMode(camera);
DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture

101
examples/shaders_postprocessing.lua Normal file
View File

@@ -0,0 +1,101 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shaders] example - Apply a postprocessing shader to a scene
--
-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
--
-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-- raylib comes with shaders ready for both versions, check raylib/shaders install folder
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model
local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map)
dwarf.material.texDiffuse = texture -- Set dwarf model diffuse texture
local position = Vector3(0.0, 0.0, 0.0) -- Set model position
local shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/bloom.fs") -- Load postpro shader
-- Create a RenderTexture2D to be used for render to texture
local target = LoadRenderTexture(screenWidth, screenHeight)
-- Setup orbital camera
SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
BeginTextureMode(target) -- Enable drawing to texture
Begin3dMode(camera)
DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawText("HELLO POSTPROCESSING!", 70, 190, 50, RED)
EndTextureMode() -- End drawing to texture (now we have a texture available for next passes)
BeginShaderMode(shader)
-- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
EndShaderMode()
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, DARKGRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
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 Normal file
View File

@@ -0,0 +1,101 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shaders] example - Apply a shader to some shape or texture
--
-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
--
-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-- raylib comes with shaders ready for both versions, check raylib/shaders install folder
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders")
local sonic = LoadTexture("resources/texture_formats/sonic.png")
-- NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version
local shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/grayscale.fs")
-- Shader usage is also different than models/postprocessing, shader is just activated when required
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
-- Start drawing with default shader
DrawText("USING DEFAULT SHADER", 20, 40, 10, RED)
DrawCircle(80, 120, 35, DARKBLUE)
DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE)
DrawCircleLines(80, 340, 80, DARKBLUE)
-- Activate our custom shader to be applied on next shapes/textures drawings
BeginShaderMode(shader)
DrawText("USING CUSTOM SHADER", 190, 40, 10, RED)
DrawRectangle(250 - 60, 90, 120, 60, RED)
DrawRectangleGradient(250 - 90, 170, 180, 130, MAROON, GOLD)
DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE)
-- Activate our default shader for next drawings
EndShaderMode()
DrawText("USING DEFAULT SHADER", 370, 40, 10, RED)
DrawTriangle(Vector2(430, 80),
Vector2(430 - 60, 150),
Vector2(430 + 60, 150), VIOLET)
DrawTriangleLines(Vector2(430, 160),
Vector2(430 - 20, 230),
Vector2(430 + 20, 230), DARKBLUE)
DrawPoly(Vector2(430, 320), 6, 80, 0, BROWN)
-- Activate our custom shader to be applied on next shapes/textures drawings
BeginShaderMode(shader)
DrawTexture(sonic, 380, -10, WHITE) -- Using custom shader
-- Activate our default shader for next drawings
EndShaderMode()
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadShader(shader) -- Unload shader
UnloadTexture(sonic) -- Unload texture
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

6
examples/shaders_standard_lighting.c
View File

@@ -64,9 +64,7 @@ int main()
pointLight->radius = 3.0f;
// Setup orbital camera
SetCameraMode(CAMERA_ORBITAL); // Set an orbital camera mode
SetCameraPosition(camera.position); // Set internal camera position to match our camera position
SetCameraTarget(camera.target); // Set internal camera target to match our camera target
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
@@ -76,7 +74,7 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw

114
examples/shaders_standard_lighting.lua Normal file
View File

@@ -0,0 +1,114 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shaders] example - Standard lighting (materials and lights)
--
-- NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
-- OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
--
-- NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
-- on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
-- raylib comes with shaders ready for both versions, check raylib/shaders install folder
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader")
-- Define the camera to look into our 3d world
local camera = Camera(Vector3(4.0, 4.0, 4.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
local 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(CameraMode.ORBITAL) -- Set an orbital camera mode
SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
SetCameraTarget(camera.target) -- Set internal camera target to match our camera target
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
camera = UpdateCamera(camera) -- Update internal camera and our camera
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
Begin3dMode(camera)
DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture
DrawLight(spotLight) -- Draw spot light
DrawLight(dirLight) -- Draw directional light
DrawLight(pointLight) -- Draw point light
DrawGrid(10, 1.0) -- Draw a grid
End3dMode()
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
DrawFPS(10, 10)
EndDrawing()
---------------------------------------------------------------------------------------
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 Normal file
View File

@@ -0,0 +1,64 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shapes] example - Draw basic shapes 2d (rectangle, circle, line...)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing")
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY)
DrawLine(18, 42, screenWidth - 18, 42, BLACK)
DrawCircle(screenWidth/4, 120, 35, DARKBLUE)
DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE)
DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE)
DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED)
DrawRectangleGradient(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD)
DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE)
DrawTriangle(Vector2(screenWidth/4*3, 80),
Vector2(screenWidth/4*3 - 60, 150),
Vector2(screenWidth/4*3 + 60, 150), VIOLET)
DrawTriangleLines(Vector2(screenWidth/4*3, 160),
Vector2(screenWidth/4*3 - 20, 230),
Vector2(screenWidth/4*3 + 20, 230), DARKBLUE)
DrawPoly(Vector2(screenWidth/4*3, 320), 6, 80, 0, BROWN)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

89
examples/shapes_colors_palette.lua Normal file
View File

@@ -0,0 +1,89 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shapes] example - Draw raylib custom color palette
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette")
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("raylib color palette", 28, 42, 20, BLACK)
DrawRectangle(26, 80, 100, 100, DARKGRAY)
DrawRectangle(26, 188, 100, 100, GRAY)
DrawRectangle(26, 296, 100, 100, LIGHTGRAY)
DrawRectangle(134, 80, 100, 100, MAROON)
DrawRectangle(134, 188, 100, 100, RED)
DrawRectangle(134, 296, 100, 100, PINK)
DrawRectangle(242, 80, 100, 100, ORANGE)
DrawRectangle(242, 188, 100, 100, GOLD)
DrawRectangle(242, 296, 100, 100, YELLOW)
DrawRectangle(350, 80, 100, 100, DARKGREEN)
DrawRectangle(350, 188, 100, 100, LIME)
DrawRectangle(350, 296, 100, 100, GREEN)
DrawRectangle(458, 80, 100, 100, DARKBLUE)
DrawRectangle(458, 188, 100, 100, BLUE)
DrawRectangle(458, 296, 100, 100, SKYBLUE)
DrawRectangle(566, 80, 100, 100, DARKPURPLE)
DrawRectangle(566, 188, 100, 100, VIOLET)
DrawRectangle(566, 296, 100, 100, PURPLE)
DrawRectangle(674, 80, 100, 100, DARKBROWN)
DrawRectangle(674, 188, 100, 100, BROWN)
DrawRectangle(674, 296, 100, 100, BEIGE)
DrawText("DARKGRAY", 65, 166, 10, BLACK)
DrawText("GRAY", 93, 274, 10, BLACK)
DrawText("LIGHTGRAY", 61, 382, 10, BLACK)
DrawText("MAROON", 186, 166, 10, BLACK)
DrawText("RED", 208, 274, 10, BLACK)
DrawText("PINK", 204, 382, 10, BLACK)
DrawText("ORANGE", 295, 166, 10, BLACK)
DrawText("GOLD", 310, 274, 10, BLACK)
DrawText("YELLOW", 300, 382, 10, BLACK)
DrawText("DARKGREEN", 382, 166, 10, BLACK)
DrawText("LIME", 420, 274, 10, BLACK)
DrawText("GREEN", 410, 382, 10, BLACK)
DrawText("DARKBLUE", 498, 166, 10, BLACK)
DrawText("BLUE", 526, 274, 10, BLACK)
DrawText("SKYBLUE", 505, 382, 10, BLACK)
DrawText("DARKPURPLE", 592, 166, 10, BLACK)
DrawText("VIOLET", 621, 274, 10, BLACK)
DrawText("PURPLE", 620, 382, 10, BLACK)
DrawText("DARKBROWN", 705, 166, 10, BLACK)
DrawText("BROWN", 733, 274, 10, BLACK)
DrawText("BEIGE", 737, 382, 10, BLACK)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

48
examples/shapes_logo_raylib.lua Normal file
View File

@@ -0,0 +1,48 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shapes] example - Draw raylib logo using basic shapes
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes")
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK)
DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE)
DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK)
DrawText("this is NOT a texture!", 350, 370, 10, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

127
examples/shapes_logo_raylib_anim.lua Normal file
View File

@@ -0,0 +1,127 @@
-------------------------------------------------------------------------------------------
--
-- raylib [shapes] example - raylib logo animation
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation")
local logoPositionX = screenWidth/2 - 128
local logoPositionY = screenHeight/2 - 128
local framesCounter = 0
local lettersCount = 0
local topSideRecWidth = 16
local leftSideRecHeight = 16
local bottomSideRecWidth = 16
local rightSideRecHeight = 16
local state = 0 -- Tracking animation states (State Machine)
local alpha = 1.0 -- Useful for fading
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (state == 0) then -- State 0: Small box blinking
framesCounter = framesCounter + 1
if (framesCounter == 120) then
state = 1
framesCounter = 0 -- Reset counter... will be used later...
end
elseif (state == 1) then -- State 1: Top and left bars growing
topSideRecWidth = topSideRecWidth + 4
leftSideRecHeight = leftSideRecHeight + 4
if (topSideRecWidth == 256) then state = 2 end
elseif (state == 2) then -- State 2: Bottom and right bars growing
bottomSideRecWidth = bottomSideRecWidth + 4
rightSideRecHeight = rightSideRecHeight + 4
if (bottomSideRecWidth == 256) then state = 3 end
elseif (state == 3) then -- State 3: Letters appearing (one by one)
framesCounter = framesCounter + 1
if (framesCounter//12 == 1) then -- Every 12 frames, one more letter!
lettersCount = lettersCount + 1
framesCounter = 0
end
if (lettersCount >= 10) then -- When all letters have appeared, just fade out everything
alpha = alpha - 0.02
if (alpha <= 0.0) then
alpha = 0.0
state = 4
end
end
elseif (state == 4) then -- State 4: Reset and Replay
if (IsKeyPressed(KEY.R)) then
framesCounter = 0
lettersCount = 0
topSideRecWidth = 16
leftSideRecHeight = 16
bottomSideRecWidth = 16
rightSideRecHeight = 16
alpha = 1.0
state = 0 -- Return to State 0
end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
if (state == 0) then
if ((framesCounter//15)%2 == 1) then DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK) end
elseif (state == 1) then
DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK)
DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK)
elseif (state == 2) then
DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK)
DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK)
DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK)
DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK)
elseif (state == 3) then
DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, Fade(BLACK, alpha))
DrawRectangle(logoPositionX, logoPositionY + 16, 16, leftSideRecHeight - 32, Fade(BLACK, alpha))
DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha))
DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha))
DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha))
DrawText(string.sub("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha))
elseif (state == 4) then DrawText("[R] REPLAY", 340, 200, 20, GRAY) end
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

59
examples/text_bmfont_ttf.lua Normal file
View File

@@ -0,0 +1,59 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - BMFont and TTF SpriteFonts loading
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading")
local msgBm = "THIS IS AN AngelCode SPRITE FONT"
local msgTtf = "THIS FONT has been GENERATED from TTF"
-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
local fontBm = LoadSpriteFont("resources/fonts/bmfont.fnt") -- BMFont (AngelCode)
local fontTtf = LoadSpriteFont("resources/fonts/pixantiqua.ttf") -- TTF font
local fontPosition = Vector2(0, 0)
fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.size, 0).x/2
fontPosition.y = screenHeight/2 - fontBm.size/2 - 80
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update variables here...
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTextEx(fontBm, msgBm, fontPosition, fontBm.size, 0, MAROON)
DrawTextEx(fontTtf, msgTtf, Vector2(60.0, 240.0), fontTtf.size, 2, LIME)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadSpriteFont(fontBm) -- AngelCode SpriteFont unloading
UnloadSpriteFont(fontTtf) -- TTF SpriteFont unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

143
examples/text_font_select.lua Normal file
View File

@@ -0,0 +1,143 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - Font selector
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - font selector")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local fonts = {} -- SpriteFont array
fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf") -- SpriteFont loading
fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf") -- SpriteFont loading
fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf") -- SpriteFont loading
fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf") -- SpriteFont loading
fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf") -- SpriteFont loading
fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf") -- SpriteFont loading
fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf") -- SpriteFont loading
fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- SpriteFont loading
local currentFont = 1 -- Selected font
local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED }
local fontNames = { "[1] Alagard", "[2] PixelPlay", "[3] MECHA", "[4] Setback",
"[5] Romulus", "[6] PixAntiqua", "[7] Alpha Beta", "[8] Jupiter Crash" }
local text = "THIS is THE FONT you SELECTED!" -- Main text
local textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1)
local mousePoint
local btnNextOutColor = DARKBLUE -- Button color (outside line)
local btnNextInColor = SKYBLUE -- Button color (inside)
local framesCounter = 0 -- Useful to count frames button is 'active' = clicked
local positionY = 180 -- Text selector and button Y position
local btnNextRec = Rectangle(673, positionY, 109, 44) -- Button rectangle (useful for collision)
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- Keyboard-based font selection (easy)
if (IsKeyPressed(KEY.RIGHT)) then
if (currentFont < 8) then currentFont = currentFont + 1 end
end
if (IsKeyPressed(KEY.LEFT)) then
if (currentFont > 1) then currentFont = currentFont - 1 end
end
if (IsKeyPressed(KEY.ZERO)) then currentFont = 0
elseif (IsKeyPressed(KEY.ONE)) then currentFont = 1
elseif (IsKeyPressed(KEY.TWO)) then currentFont = 2
elseif (IsKeyPressed(KEY.THREE)) then currentFont = 3
elseif (IsKeyPressed(KEY.FOUR)) then currentFont = 4
elseif (IsKeyPressed(KEY.FIVE)) then currentFont = 5
elseif (IsKeyPressed(KEY.SIX)) then currentFont = 6
elseif (IsKeyPressed(KEY.SEVEN)) then currentFont = 7
end
-- Mouse-based font selection (NEXT button logic)
mousePoint = GetMousePosition()
if (CheckCollisionPointRec(mousePoint, btnNextRec)) then
-- Mouse hover button logic
if (framesCounter == 0) then
btnNextOutColor = DARKPURPLE
btnNextInColor = PURPLE
end
if (IsMouseButtonDown(MOUSE.LEFT_BUTTON)) then
framesCounter = 20 -- Frames button is 'active'
btnNextOutColor = MAROON
btnNextInColor = RED
end
else
-- Mouse not hover button
btnNextOutColor = DARKBLUE
btnNextInColor = SKYBLUE
end
if (framesCounter > 0) then framesCounter = framesCounter - 1 end
if (framesCounter == 1) then -- We change font on frame 1
currentFont = currentFont + 1
if (currentFont > 7) then currentFont = 0 end
end
-- Text measurement for better positioning on screen
textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1)
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText("font selector - use arroys, button or numbers", 160, 80, 20, DARKGRAY)
DrawLine(120, 120, 680, 120, DARKGRAY)
DrawRectangle(18, positionY, 644, 44, DARKGRAY)
DrawRectangle(20, positionY + 2, 640, 40, LIGHTGRAY)
DrawText(fontNames[currentFont], 30, positionY + 13, 20, BLACK)
DrawText("< >", 610, positionY + 8, 30, BLACK)
DrawRectangleRec(btnNextRec, btnNextOutColor)
DrawRectangle(675, positionY + 2, 105, 40, btnNextInColor)
DrawText("NEXT", 700, positionY + 13, 20, btnNextOutColor)
DrawTextEx(fonts[currentFont], text, Vector2(screenWidth/2 - textSize.x/2,
260 + (70 - textSize.y)/2), fonts[currentFont].size*3,
1, colors[currentFont])
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
for i = 1, 8 do UnloadSpriteFont(fonts[i]) end -- SpriteFont(s) unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

54
examples/text_format_text.lua Normal file
View File

@@ -0,0 +1,54 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - Text formatting
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting")
local score = 100020
local hiscore = 200450
local lives = 5
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(string.format("Score: %08i", score), 200, 80, 20, RED)
DrawText(string.format("HiScore: %08i", hiscore), 200, 120, 20, GREEN)
DrawText(string.format("Lives: %02i", lives), 200, 160, 40, BLUE)
DrawText(string.format("Elapsed Time: %02.02f ms", GetFrameTime()*1000), 200, 220, 20, BLACK)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

87
examples/text_rbmf_fonts.lua Normal file
View File

@@ -0,0 +1,87 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - raylib bitmap font (rbmf) loading and usage
--
-- NOTE: raylib is distributed with some free to use fonts (even for commercial pourposes!)
-- To view details and credits for those fonts, check raylib license file
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - rBMF fonts")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local fonts = {}
fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf") -- rBMF font loading
fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf") -- rBMF font loading
fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf") -- rBMF font loading
fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf") -- rBMF font loading
fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf") -- rBMF font loading
fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf") -- rBMF font loading
fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf") -- rBMF font loading
fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- rBMF font loading
local messages = { "ALAGARD FONT designed by Hewett Tsoi",
"PIXELPLAY FONT designed by Aleksander Shevchuk",
"MECHA FONT designed by Captain Falcon",
"SETBACK FONT designed by Brian Kent (AEnigma)",
"ROMULUS FONT designed by Hewett Tsoi",
"PIXANTIQUA FONT designed by Gerhard Grossmann",
"ALPHA_BETA FONT designed by Brian Kent (AEnigma)",
"JUPITER_CRASH FONT designed by Brian Kent (AEnigma)" }
local spacings = { 2, 4, 8, 4, 3, 4, 4, 1 }
local positions = {}
for i = 1, 8 do
positions[i] = Vector2(0, 0)
positions[i].x = screenWidth/2 - MeasureTextEx(fonts[i], messages[i], fonts[i].size*2, spacings[i]).x/2
positions[i].y = 60 + fonts[i].size + 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 Normal file
View File

@@ -0,0 +1,72 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - SpriteFont loading and usage
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage")
local msg1 = "THIS IS A custom SPRITE FONT..."
local msg2 = "...and this is ANOTHER CUSTOM font..."
local msg3 = "...and a THIRD one! GREAT! :D"
-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
local font1 = LoadSpriteFont("resources/fonts/custom_mecha.png") -- SpriteFont loading
local font2 = LoadSpriteFont("resources/fonts/custom_alagard.png") -- SpriteFont loading
local font3 = LoadSpriteFont("resources/fonts/custom_jupiter_crash.png") -- SpriteFont loading
local fontPosition1 = Vector2(0, 0)
local fontPosition2 = Vector2(0, 0)
local fontPosition3 = Vector2(0, 0)
fontPosition1.x = screenWidth/2 - MeasureTextEx(font1, msg1, font1.size, -3).x/2
fontPosition1.y = screenHeight/2 - font1.size/2 - 80
fontPosition2.x = screenWidth/2 - MeasureTextEx(font2, msg2, font2.size, -2).x/2
fontPosition2.y = screenHeight/2 - font2.size/2 - 10
fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.size, 2).x/2
fontPosition3.y = screenHeight/2 - font3.size/2 + 50
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update variables here...
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTextEx(font1, msg1, fontPosition1, font1.size, -3, WHITE)
DrawTextEx(font2, msg2, fontPosition2, font2.size, -2, WHITE)
DrawTextEx(font3, msg3, fontPosition3, font3.size, 2, WHITE)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadSpriteFont(font1) -- SpriteFont unloading
UnloadSpriteFont(font2) -- SpriteFont unloading
UnloadSpriteFont(font3) -- SpriteFont unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

52
examples/text_writing_anim.lua Normal file
View File

@@ -0,0 +1,52 @@
-------------------------------------------------------------------------------------------
--
-- raylib [text] example - Text Writing Animation
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim")
local message = "This sample illustrates a text writing\nanimation effect! Check it out! )"
local framesCounter = 0
SetTargetFPS(60) -- Set target frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
framesCounter = framesCounter + 1
if (IsKeyPressed(KEY.ENTER)) then framesCounter = 0 end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(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 Normal file
View File

@@ -0,0 +1,217 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - texture formats loading (compressed and uncompressed)
--
-- NOTE: This example requires raylib OpenGL 3.3+ or ES2 versions for compressed textures,
-- OpenGL 1.1 does not support compressed textures, only uncompressed ones.
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
NUM_TEXTURES = 24
PNG_R8G8B8A8 = 1
PVR_GRAYSCALE = 2
PVR_GRAY_ALPHA = 3
PVR_R5G6B5 = 4
PVR_R5G5B5A1 = 5
PVR_R4G4B4A4 = 6
DDS_R5G6B5 = 7
DDS_R5G5B5A1 = 8
DDS_R4G4B4A4 = 9
DDS_R8G8B8A8 = 10
DDS_DXT1_RGB = 11
DDS_DXT1_RGBA = 12
DDS_DXT3_RGBA = 13
DDS_DXT5_RGBA = 14
PKM_ETC1_RGB = 15
PKM_ETC2_RGB = 16
PKM_ETC2_EAC_RGBA = 17
KTX_ETC1_RGB = 18
KTX_ETC2_RGB = 19
KTX_ETC2_EAC_RGBA = 20
ASTC_4x4_LDR = 21
ASTC_8x8_LDR = 22
PVR_PVRT_RGB = 23
PVR_PVRT_RGBA = 24
local formatText = {
"PNG_R8G8B8A8",
"PVR_GRAYSCALE",
"PVR_GRAY_ALPHA",
"PVR_R5G6B5",
"PVR_R5G5B5A1",
"PVR_R4G4B4A4",
"DDS_R5G6B5",
"DDS_R5G5B5A1",
"DDS_R4G4B4A4",
"DDS_R8G8B8A8",
"DDS_DXT1_RGB",
"DDS_DXT1_RGBA",
"DDS_DXT3_RGBA",
"DDS_DXT5_RGBA",
"PKM_ETC1_RGB",
"PKM_ETC2_RGB",
"PKM_ETC2_EAC_RGBA",
"KTX_ETC1_RGB",
"KTX_ETC2_RGB",
"KTX_ETC2_EAC_RGBA",
"ASTC_4x4_LDR",
"ASTC_8x8_LDR",
"PVR_PVRT_RGB",
"PVR_PVRT_RGBA"
}
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture formats loading")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local sonic = {}
sonic[PNG_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic.png")
-- Load UNCOMPRESSED PVR texture data
sonic[PVR_GRAYSCALE] = LoadTexture("resources/texture_formats/sonic_GRAYSCALE.pvr")
sonic[PVR_GRAY_ALPHA] = LoadTexture("resources/texture_formats/sonic_L8A8.pvr")
sonic[PVR_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.pvr")
sonic[PVR_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_R5G5B5A1.pvr")
sonic[PVR_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_R4G4B4A4.pvr")
-- Load UNCOMPRESSED DDS texture data
sonic[DDS_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.dds")
sonic[DDS_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_A1R5G5B5.dds")
sonic[DDS_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_A4R4G4B4.dds")
sonic[DDS_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic_A8R8G8B8.dds")
-- Load COMPRESSED DXT DDS texture data (if supported)
sonic[DDS_DXT1_RGB] = LoadTexture("resources/texture_formats/sonic_DXT1_RGB.dds")
sonic[DDS_DXT1_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT1_RGBA.dds")
sonic[DDS_DXT3_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT3_RGBA.dds")
sonic[DDS_DXT5_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT5_RGBA.dds")
-- Load COMPRESSED ETC texture data (if supported)
sonic[PKM_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.pkm")
sonic[PKM_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.pkm")
sonic[PKM_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.pkm")
sonic[KTX_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.ktx")
sonic[KTX_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.ktx")
sonic[KTX_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.ktx")
-- Load COMPRESSED ASTC texture data (if supported)
sonic[ASTC_4x4_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_4x4_ldr.astc")
sonic[ASTC_8x8_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_8x8_ldr.astc")
-- Load COMPRESSED PVR texture data (if supported)
sonic[PVR_PVRT_RGB] = LoadTexture("resources/texture_formats/sonic_PVRT_RGB.pvr")
sonic[PVR_PVRT_RGBA] = LoadTexture("resources/texture_formats/sonic_PVRT_RGBA.pvr")
local selectedFormat = PNG_R8G8B8A8
local selectRecs = {}
for i = 1, NUM_TEXTURES do
if ((i - 1) < NUM_TEXTURES//2) then selectRecs[i] = Rectangle(40, 30 + 32*(i - 1), 150, 30)
else selectRecs[i] = Rectangle(40 + 152, 30 + 32*((i - 1) - NUM_TEXTURES//2), 150, 30) end
end
-- Texture sizes in KB
local textureSizes = {
512*512*32/8/1024, --PNG_R8G8B8A8 (32 bpp)
512*512*8/8/1024, --PVR_GRAYSCALE (8 bpp)
512*512*16/8/1024, --PVR_GRAY_ALPHA (16 bpp)
512*512*16/8/1024, --PVR_R5G6B5 (16 bpp)
512*512*16/8/1024, --PVR_R5G5B5A1 (16 bpp)
512*512*16/8/1024, --PVR_R4G4B4A4 (16 bpp)
512*512*16/8/1024, --DDS_R5G6B5 (16 bpp)
512*512*16/8/1024, --DDS_R5G5B5A1 (16 bpp)
512*512*16/8/1024, --DDS_R4G4B4A4 (16 bpp)
512*512*32/8/1024, --DDS_R8G8B8A8 (32 bpp)
512*512*4/8/1024, --DDS_DXT1_RGB (4 bpp) -Compressed-
512*512*4/8/1024, --DDS_DXT1_RGBA (4 bpp) -Compressed-
512*512*8/8/1024, --DDS_DXT3_RGBA (8 bpp) -Compressed-
512*512*8/8/1024, --DDS_DXT5_RGBA (8 bpp) -Compressed-
512*512*4/8/1024, --PKM_ETC1_RGB (4 bpp) -Compressed-
512*512*4/8/1024, --PKM_ETC2_RGB (4 bpp) -Compressed-
512*512*8/8/1024, --PKM_ETC2_EAC_RGBA (8 bpp) -Compressed-
512*512*4/8/1024, --KTX_ETC1_RGB (4 bpp) -Compressed-
512*512*4/8/1024, --KTX_ETC2_RGB (4 bpp) -Compressed-
512*512*8/8/1024, --KTX_ETC2_EAC_RGBA (8 bpp) -Compressed-
512*512*8/8/1024, --ASTC_4x4_LDR (8 bpp) -Compressed-
512*512*2/8/1024, --ASTC_8x8_LDR (2 bpp) -Compressed-
512*512*4/8/1024, --PVR_PVRT_RGB (4 bpp) -Compressed-
512*512*4/8/1024, --PVR_PVRT_RGBA (4 bpp) -Compressed-
}
SetTargetFPS(60) -- Set our game to run at 60 frames-per-second
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyPressed(KEY.DOWN)) then
selectedFormat = selectedFormat + 1
if (selectedFormat > NUM_TEXTURES) then selectedFormat = 1 end
elseif (IsKeyPressed(KEY.UP)) then
selectedFormat = selectedFormat - 1
if (selectedFormat < 1) then selectedFormat = NUM_TEXTURES end
elseif (IsKeyPressed(KEY.RIGHT)) then
if (selectedFormat < NUM_TEXTURES//2) then selectedFormat = selectedFormat + NUM_TEXTURES//2 end
elseif (IsKeyPressed(KEY.LEFT)) then
if (selectedFormat > NUM_TEXTURES//2) then selectedFormat = selectedFormat - NUM_TEXTURES//2 end
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
-- Draw rectangles
for i = 1, NUM_TEXTURES do
if (i == selectedFormat) then
DrawRectangleRec(selectRecs[i], SKYBLUE)
DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE)
DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKBLUE)
else
DrawRectangleRec(selectRecs[i], LIGHTGRAY)
DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY)
DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKGRAY)
end
end
-- Draw selected texture
if (sonic[selectedFormat].id ~= 0) then DrawTexture(sonic[selectedFormat], 350, -10, WHITE)
else
DrawRectangleLines(488, 165, 200, 110, DARKGRAY)
DrawText("FORMAT", 550, 180, 20, MAROON)
DrawText("NOT SUPPORTED", 500, 210, 20, MAROON)
DrawText("ON YOUR GPU", 520, 240, 20, MAROON)
end
DrawText("Select texture format (use cursor keys):", 40, 10, 10, DARKGRAY)
DrawText("Required GPU memory size (VRAM):", 40, 427, 10, DARKGRAY)
DrawText(string.format("%4.0f KB", textureSizes[selectedFormat]), 240, 420, 20, DARKBLUE)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
for i = 1, NUM_TEXTURES do UnloadTexture(sonic[i]) end
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

70
examples/textures_image_drawing.lua Normal file
View File

@@ -0,0 +1,70 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Image loading and drawing on it
--
-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] example - image drawing")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local cat = LoadImage("resources/cat.png") -- Load image in CPU memory (RAM)
cat = ImageCrop(cat, Rectangle(100, 10, 280, 380)) -- Crop an image piece
cat = ImageFlipHorizontal(cat) -- Flip cropped image horizontally
cat = ImageResize(cat, 150, 200) -- Resize flipped-cropped image
local parrots = LoadImage("resources/parrots.png") -- Load image in CPU memory (RAM)
-- Draw one image over the other with a scaling of 1.5f
parrots = ImageDraw(parrots, cat, Rectangle(0, 0, cat.width, cat.height), Rectangle(30, 40, cat.width*1.5, cat.height*1.5))
parrots = ImageCrop(parrots, Rectangle(0, 50, parrots.width, parrots.height - 100)) -- Crop resulting image
UnloadImage(cat) -- Unload image from RAM
local texture = LoadTextureFromImage(parrots) -- Image converted to texture, uploaded to GPU memory (VRAM)
UnloadImage(parrots) -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, WHITE)
DrawRectangleLines(screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, texture.width, texture.height, DARKGRAY)
DrawText("We are drawing only one texture from various images composed!", 240, 350, 10, DARKGRAY)
DrawText("Source images have been cropped, scaled, flipped and copied one over the other.", 190, 370, 10, DARKGRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texture) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

55
examples/textures_image_loading.lua Normal file
View File

@@ -0,0 +1,55 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Image loading and texture creation
--
-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local image = LoadImage("resources/raylib_logo.png") -- Loaded in CPU memory (RAM)
local texture = LoadTextureFromImage(image) -- Image converted to texture, GPU memory (VRAM)
UnloadImage(image) -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texture) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

134
examples/textures_image_processing.lua Normal file
View File

@@ -0,0 +1,134 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Image processing
--
-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
--#include <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 Normal file
View File

@@ -0,0 +1,49 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Texture loading and drawing
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture loading and drawing")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local texture = LoadTexture("resources/raylib_logo.png") -- Texture loading
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
DrawText("this IS a texture!", 360, 370, 10, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texture) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

113
examples/textures_particles_trail_blending.lua Normal file
View File

@@ -0,0 +1,113 @@
-------------------------------------------------------------------------------------------
--
-- 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 Normal file
View File

@@ -0,0 +1,83 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Load textures from raw data
--
-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
--#include <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 Normal file
View File

@@ -0,0 +1,69 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Texture loading and drawing a part defined by a rectangle
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local guybrush = LoadTexture("resources/guybrush.png") -- Texture loading
local position = Vector2(350.0, 240.0)
local frameRec = Rectangle(0, 0, guybrush.width/7, guybrush.height)
local currentFrame = 0
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
if (IsKeyPressed(KEY.RIGHT)) then
currentFrame = currentFrame + 1
if (currentFrame > 6) then currentFrame = 0 end
frameRec.x = currentFrame*guybrush.width/7
end
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTexture(guybrush, 35, 40, WHITE)
DrawRectangleLines(35, 40, guybrush.width, guybrush.height, LIME)
DrawTextureRec(guybrush, frameRec, position, WHITE) -- Draw part of the texture
DrawRectangleLines(35 + frameRec.x, 40 + frameRec.y, frameRec.width, frameRec.height, RED)
DrawText("PRESS RIGHT KEY to", 540, 310, 10, GRAY)
DrawText("CHANGE DRAWING RECTANGLE", 520, 330, 10, GRAY)
DrawText("Guybrush Ulysses Threepwood,", 100, 300, 10, GRAY)
DrawText("main character of the Monkey Island series", 80, 320, 10, GRAY)
DrawText("of computer adventure games by LucasArts.", 80, 340, 10, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(guybrush) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

71
examples/textures_srcrec_dstrec.lua Normal file
View File

@@ -0,0 +1,71 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Texture source and destination rectangles
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] examples - texture source and destination rectangles")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local guybrush = LoadTexture("resources/guybrush.png") -- Texture loading
local frameWidth = guybrush.width/7
local frameHeight = guybrush.height
-- NOTE: Source rectangle (part of the texture to use for drawing)
local sourceRec = Rectangle(0, 0, frameWidth, frameHeight)
-- NOTE: Destination rectangle (screen rectangle where drawing part of texture)
local destRec = Rectangle(screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2)
-- NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size
local origin = Vector2(frameWidth, frameHeight)
local rotation = 0
SetTargetFPS(60)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
rotation = rotation + 1
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
-- NOTE: Using DrawTexturePro() we can easily rotate and scale the part of the texture we draw
-- sourceRec defines the part of the texture we use for drawing
-- destRec defines the rectangle where our texture part will fit (scaling it to fit)
-- origin defines the point of the texture used as reference for rotation and scaling
-- rotation defines the texture rotation (using origin as rotation point)
DrawTexturePro(guybrush, sourceRec, destRec, origin, rotation, WHITE)
DrawLine(destRec.x, 0, destRec.x, screenHeight, GRAY)
DrawLine(0, destRec.y, screenWidth, destRec.y, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(guybrush) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

60
examples/textures_to_image.lua Normal file
View File

@@ -0,0 +1,60 @@
-------------------------------------------------------------------------------------------
--
-- raylib [textures] example - Retrieve image data from texture: GetTextureData()
--
-- NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
--
-- This example has been created using raylib 1.6 (www.raylib.com)
-- raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
--
-- Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
--
-------------------------------------------------------------------------------------------
-- Initialization
-------------------------------------------------------------------------------------------
local screenWidth = 800
local screenHeight = 450
InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image")
-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
local image = LoadImage("resources/raylib_logo.png") -- Load image data into CPU memory (RAM)
local texture = LoadTextureFromImage(image) -- Image converted to texture, GPU memory (RAM -> VRAM)
UnloadImage(image) -- Unload image data from CPU memory (RAM)
image = GetTextureData(texture) -- Retrieve image data from GPU memory (VRAM -> RAM)
UnloadTexture(texture) -- Unload texture from GPU memory (VRAM)
texture = LoadTextureFromImage(image) -- Recreate texture from retrieved image data (RAM -> VRAM)
UnloadImage(image) -- Unload retrieved image data from CPU memory (RAM)
-------------------------------------------------------------------------------------------
-- Main game loop
while not WindowShouldClose() do -- Detect window close button or ESC key
-- Update
---------------------------------------------------------------------------------------
-- TODO: Update your variables here
---------------------------------------------------------------------------------------
-- Draw
---------------------------------------------------------------------------------------
BeginDrawing()
ClearBackground(RAYWHITE)
DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY)
EndDrawing()
---------------------------------------------------------------------------------------
end
-- De-Initialization
-------------------------------------------------------------------------------------------
UnloadTexture(texture) -- Texture unloading
CloseWindow() -- Close window and OpenGL context
-------------------------------------------------------------------------------------------

297
games/arkanoid.lua Normal file
View File

@@ -0,0 +1,297 @@
--[[
raylib - sample game: arkanoid
Sample game Marc Palau and Ramon Santamaria
This game has been created using raylib v1.3 (www.raylib.com)
raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
Copyright (c) 2015 Ramon Santamaria (@raysan5)
Translated to Lua by Ghassan Al-Mashareqa (ghassan@ghassan.pl)
--]]
------------------------------------------------------------------------------------
-- Some Defines
------------------------------------------------------------------------------------
PLAYER_MAX_LIFE = 5
LINES_OF_BRICKS = 5
BRICKS_PER_LINE = 20
------------------------------------------------------------------------------------
-- Types and Structures Definition
------------------------------------------------------------------------------------
GameScreen = { LOGO = 0, TITLE = 1, GAMEPLAY = 2, ENDING = 3 }
function Player()
return { position = Vector2(0,0), size = Vector2(0,0), life = 0 }
end
function Ball()
return { position = Vector2(0,0), speed = Vector2(0,0), radius = 0, active = false }
end
function Brick()
return { position = Vector2(0,0), active = false }
end
--------------------------------------------------------------------------------------
-- Global Variables Declaration
--------------------------------------------------------------------------------------
screenWidth = 800;
screenHeight = 450;
framesCounter = 0;
gameOver = false;
pause = false;
player = Player()
ball = Ball()
brick = {}--[LINES_OF_BRICKS][BRICKS_PER_LINE];
for i = 0, LINES_OF_BRICKS-1 do
brick[i] = {}
for j = 0, BRICKS_PER_LINE-1 do
brick[i][j] = Brick()
end
end
brickSize = Vector2(0,0)
--------------------------------------------------------------------------------------
-- Module Functions Definitions (local)
--------------------------------------------------------------------------------------
-- Initialize game variables
function InitGame()
brickSize = Vector2(GetScreenWidth()/BRICKS_PER_LINE, 40)
-- Initialize player
player.position = Vector2(screenWidth/2, screenHeight*7/8)
player.size = Vector2(screenWidth/10, 20)
player.life = PLAYER_MAX_LIFE;
-- Initialize ball
ball.position = Vector2(screenWidth/2, screenHeight*7/8 - 30)
ball.speed = Vector2(0, 0)
ball.radius = 7;
ball.active = false;
-- Initialize bricks
local initialDownPosition = 50;
for i = 0, LINES_OF_BRICKS-1 do
for j = 0, BRICKS_PER_LINE-1 do
brick[i][j].position = Vector2(j*brickSize.x + brickSize.x/2, i*brickSize.y + initialDownPosition)
brick[i][j].active = true;
end
end
end
-- Update game (one frame)
function UpdateGame()
if (not gameOver) then
if (IsKeyPressed(KEY.P)) then pause = not pause; end
if (not pause) then
-- Player movement
if (IsKeyDown(KEY.LEFT)) then player.position.x = player.position.x - 5; end
if ((player.position.x - player.size.x/2) <= 0) then player.position.x = player.size.x/2; end
if (IsKeyDown(KEY.RIGHT)) then player.position.x = player.position.x + 5; end
if ((player.position.x + player.size.x/2) >= screenWidth) then player.position.x = screenWidth - player.size.x/2; end
-- Launch ball
if (not ball.active) then
if (IsKeyPressed(KEY.SPACE)) then
ball.active = true;
ball.speed = Vector2(0, -5)
end
end
UpdateBall();
-- Game over logic
if (player.life <= 0) then
gameOver = true;
else
gameOver = true;
for i = 0, LINES_OF_BRICKS-1 do
for j = 0, BRICKS_PER_LINE-1 do
if (brick[i][j].active) then gameOver = false; end
end
end
end
end
else
if (IsKeyPressed(KEY.ENTER)) then
InitGame();
gameOver = false;
end
end
end
-- Draw game (one frame)
function DrawGame()
BeginDrawing();
ClearBackground(RAYWHITE);
if (not gameOver) then
-- Draw player bar
DrawRectangle(player.position.x - player.size.x/2, player.position.y - player.size.y/2, player.size.x, player.size.y, BLACK);
-- Draw player lives
for i = 0, player.life-1 do
DrawRectangle(20 + 40*i, screenHeight - 30, 35, 10, LIGHTGRAY);
end
-- Draw ball
DrawCircleV(ball.position, ball.radius, MAROON);
-- Draw bricks
for i = 0, LINES_OF_BRICKS-1 do
for j = 0, BRICKS_PER_LINE-1 do
if (brick[i][j].active) then
if ((i + j) % 2 == 0) then
DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, GRAY);
else
DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, DARKGRAY);
end
end
end
end
if (pause) then
DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
end
else
DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
end
EndDrawing();
end
-- Unload game variables
function UnloadGame()
-- TODO: Unload all dynamic loaded data (textures, sounds, models...)
end
-- Update and Draw (one frame)
function UpdateDrawFrame()
UpdateGame();
DrawGame();
end
----------------------------------------------------------------------------------------
-- Additional module functions
----------------------------------------------------------------------------------------
function UpdateBall()
-- Update position
if (ball.active) then
ball.position.x = ball.position.x + ball.speed.x;
ball.position.y = ball.position.y + ball.speed.y;
else
ball.position = Vector2(player.position.x, screenHeight*7/8 - 30);
end
-- Bounce in x
if (((ball.position.x + ball.radius) >= screenWidth) or ((ball.position.x - ball.radius) <= 0))
then
ball.speed.x = ball.speed.x * -1;
end
-- Bounce in y
if ((ball.position.y - ball.radius) <= 0) then
ball.speed.y = ball.speed.y * -1;
end
-- Ball reaches bottom of the screen
if ((ball.position.y + ball.radius) >= screenHeight) then
ball.speed = Vector2(0, 0);
ball.active = false;
player.life = player.life - 1;
end
-- Collision logic: ball vs player
if CheckCollisionCircleRec(ball.position, ball.radius,
Rectangle(
player.position.x - player.size.x/2,
player.position.y - player.size.y/2,
player.size.x,
player.size.y)) then
if (ball.speed.y > 0) then
ball.speed.y = ball.speed.y * -1;
ball.speed.x = (ball.position.x - player.position.x)/(player.size.x/2)*5;
end
end
-- Collision logic: ball vs bricks
for i = 0,LINES_OF_BRICKS-1 do
for j = 0,BRICKS_PER_LINE-1 do
if (brick[i][j].active) then
-- Hit below
if (((ball.position.y - ball.radius) <= (brick[i][j].position.y + brickSize.y/2)) and
((ball.position.y - ball.radius) > (brick[i][j].position.y + brickSize.y/2 + ball.speed.y)) and
((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y < 0))
then
brick[i][j].active = false;
ball.speed.y = ball.speed.y * -1;
-- Hit above
elseif (((ball.position.y + ball.radius) >= (brick[i][j].position.y - brickSize.y/2)) and
((ball.position.y + ball.radius) < (brick[i][j].position.y - brickSize.y/2 + ball.speed.y)) and
((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y > 0))
then
brick[i][j].active = false;
ball.speed.y = ball.speed.y * -1;
-- Hit left
elseif (((ball.position.x + ball.radius) >= (brick[i][j].position.x - brickSize.x/2)) and
((ball.position.x + ball.radius) < (brick[i][j].position.x - brickSize.x/2 + ball.speed.x)) and
((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x > 0))
then
brick[i][j].active = false;
ball.speed.x = ball.speed.x * -1;
-- Hit right
elseif (((ball.position.x - ball.radius) <= (brick[i][j].position.x + brickSize.x/2)) and
((ball.position.x - ball.radius) > (brick[i][j].position.x + brickSize.x/2 + ball.speed.x)) and
((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x < 0))
then
brick[i][j].active = false;
ball.speed.x = ball.speed.x * -1;
end
end
end
end
end
InitWindow(screenWidth, screenHeight, "sample game: arkanoid");
InitGame();
SetTargetFPS(60);
----------------------------------------------------------------------------------------
-- Main game loop
while (not WindowShouldClose()) -- Detect window close button or ESC key
do
-- Update
------------------------------------------------------------------------------------
UpdateGame();
------------------------------------------------------------------------------------
-- Draw
------------------------------------------------------------------------------------
DrawGame();
------------------------------------------------------------------------------------
end
UnloadGame(); -- Unload loaded data (textures, sounds, models...)
CloseWindow(); -- Close window and OpenGL context

15
games/drturtle/05_drturtle_audio.c
View File

@@ -12,7 +12,7 @@
*
* Enjoy using raylib. :)
*
* This game has been created using raylib 1.1 (www.raylib.com)
* This game 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 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -59,8 +59,9 @@ int main()
Sound die = LoadSound("resources/die.wav");
Sound growl = LoadSound("resources/gamera.wav");
// Start playing streaming music
PlayMusicStream("resources/speeding.ogg");
// Load music stream and start playing music
Music music = LoadMusicStream("resources/speeding.ogg");
PlayMusicStream(music);
// Define scrolling variables
int backScrolling = 0;
@@ -118,6 +119,8 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateMusicStream(music); // Refill music stream buffers (if required)
framesCounter++;
// Game screens management
@@ -458,10 +461,10 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
CloseAudioDevice(); // Close audio device
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;

17
games/drturtle/06_drturtle_final.c
View File

@@ -12,7 +12,7 @@
*
* Enjoy using raylib. :)
*
* This game has been created using raylib 1.1 (www.raylib.com)
* This game 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 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -39,7 +39,7 @@ int main()
InitWindow(screenWidth, screenHeight, "Dr. Turtle & Mr. GAMERA");
// Initialize audio device
InitAudioDevice();
InitAudioDevice();
// Load game resources: textures
Texture2D sky = LoadTexture("resources/sky.png");
@@ -62,8 +62,9 @@ int main()
Sound die = LoadSound("resources/die.wav");
Sound growl = LoadSound("resources/gamera.wav");
// Start playing streaming music
PlayMusicStream("resources/speeding.ogg");
// Load music stream and start playing music
Music music = LoadMusicStream("resources/speeding.ogg");
PlayMusicStream(music);
// Define scrolling variables
int backScrolling = 0;
@@ -127,6 +128,8 @@ int main()
{
// Update
//----------------------------------------------------------------------------------
UpdateMusicStream(music); // Refill music stream buffers (if required)
framesCounter++;
// Sea color tint effect
@@ -483,10 +486,10 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
CloseAudioDevice(); // Close audio device
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;

19
games/drturtle/drturtle_final_web.c
View File

@@ -12,7 +12,7 @@
*
* Enjoy using raylib. :)
*
* This game has been created using raylib 1.1 (www.raylib.com)
* This game 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 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -54,6 +54,8 @@ Sound eat;
Sound die;
Sound growl;
Music music;
// Define scrolling variables
int backScrolling = 0;
int seaScrolling = 0;
@@ -124,8 +126,9 @@ int main()
die = LoadSound("resources/die.wav");
growl = LoadSound("resources/gamera.wav");
// Start playing streaming music
PlayMusicStream("resources/speeding.ogg");
// Load music stream and start playing music
music = LoadMusicStream("resources/speeding.ogg");
PlayMusicStream(music);
playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 };
@@ -190,10 +193,10 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
CloseAudioDevice(); // Close audio device
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
@@ -206,8 +209,8 @@ void UpdateDrawFrame(void)
{
// Update
//----------------------------------------------------------------------------------
UpdateMusicStream();
UpdateMusicStream(music); // Refill music stream buffers (if required)
framesCounter++;
// Sea color tint effect

17
games/just_do/just_do.c
View File

@@ -6,7 +6,7 @@
*
* Developed by: Ramon Santamaria (Ray San)
*
* This game has been created using raylib (www.raylib.com)
* This game has been created using raylib 1.6 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* raylib - Copyright (c) 2015 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -23,7 +23,7 @@
//----------------------------------------------------------------------------------
// Global Variables Definition (local to this module)
//----------------------------------------------------------------------------------
const int screenWidth = 1280; // Moved to screens.h
const int screenWidth = 1280; // Moved to screens.h
const int screenHeight = 720; // Moved to screens.h
// Required variables to manage screen transitions (fade-in, fade-out)
@@ -35,6 +35,7 @@ int transToScreen = -1;
int framesCounter = 0;
//static Sound levelWin;
Music music;
//----------------------------------------------------------------------------------
// Local Functions Declaration
@@ -57,10 +58,11 @@ int main(void)
//SetupFlags(FLAG_FULLSCREEN_MODE);
InitWindow(screenWidth, screenHeight, windowTitle);
// TODO: Load global data here (assets that must be available in all screens, i.e. fonts)
// Load global data here (assets that must be available in all screens, i.e. fonts)
InitAudioDevice();
levelWin = LoadSound("resources/win.wav");
music = LoadMusicStream("resources/ambient.ogg");
// Setup and Init first screen
currentScreen = LOGO;
@@ -85,8 +87,9 @@ int main(void)
// De-Initialization
//--------------------------------------------------------------------------------------
// TODO: Unload all global loaded data (i.e. fonts) here!
// Unload all global loaded data (i.e. fonts) here!
UnloadSound(levelWin);
UnloadMusicStream(music);
CloseAudioDevice();
@@ -197,6 +200,8 @@ void UpdateDrawFrame(void)
InitLevel08Screen();
}
UpdateMusicStream(music);
switch(currentScreen)
{
case LOGO:
@@ -209,8 +214,8 @@ void UpdateDrawFrame(void)
TransitionToScreen(LEVEL00);
InitLevel00Screen();
PlayMusicStream("resources/ambient.ogg");
SetMusicVolume(0.6f);
PlayMusicStream(music);
SetMusicVolume(music, 0.6f);
}
} break;
case LEVEL00:

20
games/light_my_ritual/light_my_ritual.c
View File

@@ -35,6 +35,8 @@ bool onTransition = false;
bool transFadeOut = false;
int transFromScreen = -1;
int transToScreen = -1;
static Music music;
//----------------------------------------------------------------------------------
// Local Functions Declaration
@@ -66,11 +68,13 @@ int main(void)
UnloadImage(image); // Unload image from CPU memory (RAM)
//PlayMusicStream("resources/audio/come_play_with_me.ogg");
font = LoadSpriteFont("resources/font_arcadian.png");
//doors = LoadTexture("resources/textures/doors.png");
//sndDoor = LoadSound("resources/audio/door.ogg");
music = LoadMusicStream("resources/audio/ambient.ogg");
PlayMusicStream(music);
SetMusicVolume(music, 1.0f);
// Setup and Init first screen
currentScreen = LOGO_RL;
@@ -105,6 +109,8 @@ int main(void)
UnloadSpriteFont(font);
//UnloadSound(sndDoor);
UnloadMusicStream(music);
free(lightsMap);
CloseAudioDevice();
@@ -218,13 +224,17 @@ void UpdateDrawFrame(void)
rlUpdateLogoScreen();
if (rlFinishLogoScreen()) TransitionToScreen(TITLE);
} break;
case TITLE:
{
UpdateTitleScreen();
if (FinishTitleScreen() == 1) TransitionToScreen(GAMEPLAY);
if (FinishTitleScreen() == 1)
{
StopMusicStream(music);
TransitionToScreen(GAMEPLAY);
}
} break;
case GAMEPLAY:
@@ -244,7 +254,7 @@ void UpdateDrawFrame(void)
UpdateTransition();
}
UpdateMusicStream();
if (currentScreen != GAMEPLAY) UpdateMusicStream(music);
//----------------------------------------------------------------------------------
// Draw

21
games/light_my_ritual/screens/screen_gameplay.c
View File

@@ -64,7 +64,7 @@ typedef struct Enemy {
Color color;
} Enemy;
typedef struct Light {
typedef struct LightSpot {
Vector2 position;
int radius;
int requiredEnergy;
@@ -74,7 +74,7 @@ typedef struct Light {
int framesCounter;
int currentFrame;
Rectangle frameRec;
} Light;
} LightSpot;
typedef enum { LEVEL_I, LEVEL_II, LEVEL_III, LEVEL_FINISHED } LightedLevel;
@@ -92,9 +92,9 @@ static bool pause;
static Player player;
static Light lightsI[MAX_LIGHTS_I];
static Light lightsII[MAX_LIGHTS_II];
static Light lightsIII[MAX_LIGHTS_III];
static LightSpot lightsI[MAX_LIGHTS_I];
static LightSpot lightsII[MAX_LIGHTS_II];
static LightSpot lightsIII[MAX_LIGHTS_III];
static Enemy enemies[MAX_ENEMIES];
@@ -133,6 +133,8 @@ static Rectangle lightOff, lightOn;
static Sound fxLightOn, fxLightOff;
static Music music;
// Debug variables
static bool enemiesStopped;
@@ -286,7 +288,8 @@ void InitGameplayScreen(void)
enemiesStopped = false;
PlayMusicStream("resources/audio/ritual.ogg");
music = LoadMusicStream("resources/audio/ritual.ogg");
PlayMusicStream(music);
}
// Gameplay Screen Update logic
@@ -549,10 +552,12 @@ void UpdateGameplayScreen(void)
{
alphaRitual += 0.02f;
SetMusicVolume(1.0f - alphaRitual);
SetMusicVolume(music, 1.0f - alphaRitual);
if (alphaRitual > 1.0f) finishScreen = 1;
}
UpdateMusicStream(music);
}
// Gameplay Screen Draw logic
@@ -757,6 +762,8 @@ void UnloadGameplayScreen(void)
// Unload sounds
UnloadSound(fxLightOn);
UnloadSound(fxLightOff);
UnloadMusicStream(music);
}
// Gameplay Screen should finish?

5
games/light_my_ritual/screens/screen_logo_raylib.c
View File

@@ -75,9 +75,6 @@ void rlInitLogoScreen(void)
state = 0;
alpha = 1.0f;
PlayMusicStream("resources/audio/ambient.ogg");
SetMusicVolume(1.0f);
}
// Logo Screen Update logic
@@ -204,7 +201,7 @@ void rlDrawLogoScreen(void)
// Logo Screen Unload logic
void rlUnloadLogoScreen(void)
{
// TODO: Unload LOGO screen variables here!
// Unload LOGO screen variables here!
}
// Logo Screen should finish?

10
games/makefile
View File

@@ -86,8 +86,6 @@ else
# external libraries headers
# GLFW3
INCLUDES += -I../external/glfw3/include
# GLEW - Not required any more, replaced by GLAD
#INCLUDES += -I../external/glew/include
# OpenAL Soft
INCLUDES += -I../external/openal_soft/include
endif
@@ -103,8 +101,6 @@ else
ifneq ($(PLATFORM_OS),OSX)
# OpenAL Soft
LFLAGS += -L../external/openal_soft/lib/$(LIBPATH)
# GLEW: Not used, replaced by GLAD
#LFLAGS += -L../../external/glew/lib/$(LIBPATH)
endif
endif
@@ -115,9 +111,9 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
# libraries for Debian GNU/Linux desktop compiling
# requires the following packages:
# libglfw3-dev libopenal-dev libglew-dev libegl1-mesa-dev
LIBS = -lraylib -lglfw3 -lGLEW -lGL -lopenal -lm -pthread
# on XWindow could require also below libraries, just uncomment
#LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
LIBS = -lraylib -lglfw3 -lGLEW -lGL -lopenal -lm -lpthread -ldl
# on XWindow could require also below libraries:
LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
else
ifeq ($(PLATFORM_OS),OSX)
# libraries for OS X 10.9 desktop compiling

20
games/raylib_demo/raylib_demo.c
View File

@@ -123,6 +123,8 @@ Model cat;
Sound fxWav;
Sound fxOgg;
Music music;
Vector2 soundBallsPosition[MAX_BALLS];
Color soundBallsColor[MAX_BALLS];
bool soundBallsActive[MAX_BALLS];
@@ -203,11 +205,13 @@ int main()
catTexture = LoadTexture("resources/catsham.png"); // Load model texture
cat = LoadModel("resources/cat.obj"); // Load OBJ model
cat.material.texDiffuse = texture; // Set cat model diffuse texture
cat.material.texDiffuse = catTexture; // Set cat model diffuse texture
fxWav = LoadSound("resources/audio/weird.wav"); // Load WAV audio file
fxOgg = LoadSound("resources/audio/tanatana.ogg"); // Load OGG audio file
music = LoadMusicStream("resources/audio/guitar_noodling.ogg"); // Load music
for (int i = 0; i < MAX_BALLS; i++)
{
soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) };
@@ -267,6 +271,8 @@ int main()
UnloadSound(fxWav);
UnloadSound(fxOgg);
UnloadMusicStream(music);
CloseAudioDevice();
@@ -464,11 +470,11 @@ void UpdateDrawOneFrame(void)
if (selectedModule == AUDIO)
{
if (IsKeyPressed(KEY_SPACE) && !MusicIsPlaying()) PlayMusicStream("resources/audio/guitar_noodling.ogg"); // Play music stream
if (IsKeyPressed(KEY_SPACE) && !IsMusicPlaying(music)) PlayMusicStream(music); // Play music stream
if (IsKeyPressed('S'))
{
StopMusicStream();
StopMusicStream(music);
timePlayed = 0.0f;
for (int i = 0; i < MAX_BALLS; i++)
@@ -482,9 +488,11 @@ void UpdateDrawOneFrame(void)
}
}
if (MusicIsPlaying())
if (IsMusicPlaying(music))
{
timePlayed = GetMusicTimePlayed() / GetMusicTimeLength() * 100 * 4;
UpdateMusicStream(music);
timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4;
if ((framesCounter%10) == 0)
{
@@ -842,7 +850,7 @@ void UpdateDrawOneFrame(void)
DrawRectangle(150, 390, 400, 12, LIGHTGRAY);
DrawRectangle(150, 390, (int)timePlayed, 12, MAROON);
if (MusicIsPlaying())
if (IsMusicPlaying(music))
{
DrawText("PRESS 'S' to STOP PLAYING MUSIC", 165, 425, 20, GRAY);

11
games/skully_escape/skully_escape.c
View File

@@ -2,7 +2,7 @@
*
* SKULLY ESCAPE [KING GAME JAM 2015]
*
* This game has been created using raylib (www.raylib.com)
* This game 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 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -32,6 +32,8 @@ int transFromScreen = -1;
int transToScreen = -1;
static int framesCounter = 0;
Music music;
//----------------------------------------------------------------------------------
// Local Functions Declaration
@@ -57,7 +59,8 @@ int main(void)
// Global data loading (assets that must be available in all screens, i.e. fonts)
InitAudioDevice();
PlayMusicStream("resources/audio/come_play_with_me.ogg");
music = LoadMusicStream("resources/audio/come_play_with_me.ogg");
PlayMusicStream(music);
font = LoadSpriteFont("resources/textures/alagard.png");
doors = LoadTexture("resources/textures/doors.png");
@@ -93,6 +96,8 @@ int main(void)
UnloadSound(sndDoor);
UnloadSound(sndScream);
UnloadMusicStream(music);
CloseAudioDevice();
CloseWindow(); // Close window and OpenGL context
@@ -368,7 +373,7 @@ void UpdateDrawFrame(void)
UpdateTransition();
}
UpdateMusicStream();
UpdateMusicStream(music);
//----------------------------------------------------------------------------------
// Draw

97
project/vs2015/examples/core_basic_window.vcxproj Normal file
View File

@@ -0,0 +1,97 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{0981CA98-E4A5-4DF1-987F-A41D09131EFC}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>core_basic_window</RootNamespace>
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
<ProjectName>core_basic_window</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;PLATFORM_DESKTOP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<CompileAs>CompileAsC</CompileAs>
<AdditionalIncludeDirectories>$(SolutionDir)..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>$(SolutionDir)external\glfw3\lib\win32;$(SolutionDir)external\openal_soft\lib\win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\..\..\examples\core_basic_window.c" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\raylib\raylib.vcxproj">
<Project>{e89d61ac-55de-4482-afd4-df7242ebc859}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

97
project/vs2015/examples/core_basic_window_cpp.vcxproj Normal file
View File

@@ -0,0 +1,97 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{B655E850-3322-42F7-941D-6AC18FD66CA1}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>raylib_example_cpp</RootNamespace>
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
<ProjectName>core_basic_window_cpp</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(SolutionDir)..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
<AdditionalLibraryDirectories>$(SolutionDir)external\glfw3\lib\win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ProjectReference Include="..\raylib\raylib.vcxproj">
<Project>{e89d61ac-55de-4482-afd4-df7242ebc859}</Project>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\examples\core_basic_window.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

22
project/vs2015/external/glfw3/COPYING.txt vendored Normal file
View File

@@ -0,0 +1,22 @@
Copyright (c) 2002-2006 Marcus Geelnard
Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would
be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not
be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.

4235
project/vs2015/external/glfw3/include/GLFW/glfw3.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More