Merge remote-tracking branch 'refs/remotes/raysan5/develop' into develop

This commit is contained in:
victorfisac 2016-10-06 20:57:31 +02:00
commit 2a158c4795
201 changed files with 26449 additions and 5592 deletions

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

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"

View File

Before

Width:  |  Height:  |  Size: 371 KiB

After

Width:  |  Height:  |  Size: 371 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.2 MiB

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)

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

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
-------------------------------------------------------------------------------------------

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++;
UpdateMusicStream(music); // Update music buffer with new stream data
// Testing music fading from one file to another
/*
if (framesCounter > 600) // Wait for 10 seconds (600 frames)
// Restart music playing (stop and play)
if (IsKeyPressed(KEY_SPACE))
{
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");
StopMusicStream(music);
PlayMusicStream(music);
}
SetMusicVolume(volume);
// Pause/Resume music playing
if (IsKeyPressed(KEY_P))
{
pause = !pause;
if (pause) PauseMusicStream(music);
else ResumeMusicStream(music);
}
*/
if (IsWindowMinimized()) PauseMusicStream(0);
else ResumeMusicStream(0);
timePlayed = GetMusicTimePlayed(0)/GetMusicTimeLength(0)*100*4; // We scale by 4 to fit 400 pixels
UpdateMusicStream(0); // Update music buffer with new stream data
// 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,6 +82,8 @@ int main()
// 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

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;
}

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
-------------------------------------------------------------------------------------------

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
//----------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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,12 +60,14 @@ int main()
key = 0;
}
UpdateMusicStream(0);
UpdateMusicStream(music);
}
UnloadSound(fxWav); // Unload sound data
UnloadSound(fxOgg); // Unload sound data
UnloadMusicStream(music); // Unload music stream data
CloseAudioDevice();
printf("\n\nPress ENTER to close...");

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
-------------------------------------------------------------------------------------------

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 and player position
//----------------------------------------------------------------------------------
// Draw

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
-------------------------------------------------------------------------------------------

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
//--------------------------------------------------------------------------------------
@ -43,6 +40,8 @@ int main()
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update internal camera and our camera
if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
//----------------------------------------------------------------------------------
// Draw

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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;
}

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
----------------------------------------------------------------------------------------

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
----------------------------------------------------------------------------------------

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
----------------------------------------------------------------------------------------

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
----------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
----------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

View File

@ -35,9 +35,7 @@ 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
//--------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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)
*

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)
*

Binary file not shown.

Binary file not shown.

Binary file not shown.

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);
for (int i = -4; i < 4; i++)
{
for (int j = -3; j < 3; j++)
{
sum += texture2D(texture0, fragTexCoord + vec2(j, i)*0.004) * 0.25;
}
}
vec2 sizeFactor = vec2(1)/size*quality;
// Texel color fetching from texture sampler
vec4 texelColor = texture2D(texture0, fragTexCoord);
vec4 source = texture2D(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
sum += texture2D(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// 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;
}

View File

@ -0,0 +1,161 @@
#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(dot(n, h), 3.0 + glossiness)*s;
}
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
*/
return vec3(0.5);
}
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(dot(n, h), 3.0 + glossiness)*s;
}
// Combine results
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
*/
return vec3(0.5);
}
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(dot(n, h), 3.0 + glossiness)*s;
}
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
*/
return vec3(0.5);
}
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 *= normalize(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);
}

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);
}

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);
for (int i = -4; i < 4; i++)
{
for (int j = -3; j < 3; j++)
{
sum += texture(texture0, fragTexCoord + vec2(j, i)*0.004)*0.25;
}
}
vec2 sizeFactor = vec2(1)/size*quality;
// Texel color fetching from texture sampler
vec4 texelColor = texture(texture0, fragTexCoord);
vec4 source = texture(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
sum += texture(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// 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;
finalColor = ((sum/(samples*samples)) + source)*colDiffuse;
}

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(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(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(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 *= normalize(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);
}

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);
}

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;
}

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
-------------------------------------------------------------------------------------------

View File

@ -42,10 +42,7 @@ int main()
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_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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
-------------------------------------------------------------------------------------------

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

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,7 +461,7 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context

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)
@ -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,7 +486,7 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context

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,7 +193,7 @@ int main()
UnloadSound(die);
UnloadSound(growl);
StopMusicStream(); // Stop music
UnloadMusicStream(music); // Unload music
CloseAudioDevice(); // Close audio device
CloseWindow(); // Close window and OpenGL context
@ -206,7 +209,7 @@ void UpdateDrawFrame(void)
{
// Update
//----------------------------------------------------------------------------------
UpdateMusicStream();
UpdateMusicStream(music); // Refill music stream buffers (if required)
framesCounter++;

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)
@ -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:

View File

@ -36,6 +36,8 @@ bool transFadeOut = false;
int transFromScreen = -1;
int transToScreen = -1;
static Music music;
//----------------------------------------------------------------------------------
// Local Functions Declaration
//----------------------------------------------------------------------------------
@ -66,12 +68,14 @@ 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;
//InitTitleScreen();
@ -105,6 +109,8 @@ int main(void)
UnloadSpriteFont(font);
//UnloadSound(sndDoor);
UnloadMusicStream(music);
free(lightsMap);
CloseAudioDevice();
@ -224,7 +230,11 @@ void UpdateDrawFrame(void)
{
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

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?

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?

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

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) };
@ -268,6 +272,8 @@ int main()
UnloadSound(fxWav);
UnloadSound(fxOgg);
UnloadMusicStream(music);
CloseAudioDevice();
CloseWindow(); // Close window and OpenGL context
@ -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);

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)
@ -33,6 +33,8 @@ 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

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>

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>

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.

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,456 @@
/*************************************************************************
* GLFW 3.2 - www.glfw.org
* A library for OpenGL, window and input
*------------------------------------------------------------------------
* 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.
*
*************************************************************************/
#ifndef _glfw3_native_h_
#define _glfw3_native_h_
#ifdef __cplusplus
extern "C" {
#endif
/*************************************************************************
* Doxygen documentation
*************************************************************************/
/*! @file glfw3native.h
* @brief The header of the native access functions.
*
* This is the header file of the native access functions. See @ref native for
* more information.
*/
/*! @defgroup native Native access
*
* **By using the native access functions you assert that you know what you're
* doing and how to fix problems caused by using them. If you don't, you
* shouldn't be using them.**
*
* Before the inclusion of @ref glfw3native.h, you may define exactly one
* window system API macro and zero or more context creation API macros.
*
* The chosen backends must match those the library was compiled for. Failure
* to do this will cause a link-time error.
*
* The available window API macros are:
* * `GLFW_EXPOSE_NATIVE_WIN32`
* * `GLFW_EXPOSE_NATIVE_COCOA`
* * `GLFW_EXPOSE_NATIVE_X11`
* * `GLFW_EXPOSE_NATIVE_WAYLAND`
* * `GLFW_EXPOSE_NATIVE_MIR`
*
* The available context API macros are:
* * `GLFW_EXPOSE_NATIVE_WGL`
* * `GLFW_EXPOSE_NATIVE_NSGL`
* * `GLFW_EXPOSE_NATIVE_GLX`
* * `GLFW_EXPOSE_NATIVE_EGL`
*
* These macros select which of the native access functions that are declared
* and which platform-specific headers to include. It is then up your (by
* definition platform-specific) code to handle which of these should be
* defined.
*/
/*************************************************************************
* System headers and types
*************************************************************************/
#if defined(GLFW_EXPOSE_NATIVE_WIN32)
// This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
// example to allow applications to correctly declare a GL_ARB_debug_output
// callback) but windows.h assumes no one will define APIENTRY before it does
#undef APIENTRY
#include <windows.h>
#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
#include <ApplicationServices/ApplicationServices.h>
#if defined(__OBJC__)
#import <Cocoa/Cocoa.h>
#else
typedef void* id;
#endif
#elif defined(GLFW_EXPOSE_NATIVE_X11)
#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#elif defined(GLFW_EXPOSE_NATIVE_WAYLAND)
#include <wayland-client.h>
#elif defined(GLFW_EXPOSE_NATIVE_MIR)
#include <mir_toolkit/mir_client_library.h>
#endif
#if defined(GLFW_EXPOSE_NATIVE_WGL)
/* WGL is declared by windows.h */
#endif
#if defined(GLFW_EXPOSE_NATIVE_NSGL)
/* NSGL is declared by Cocoa.h */
#endif
#if defined(GLFW_EXPOSE_NATIVE_GLX)
#include <GL/glx.h>
#endif
#if defined(GLFW_EXPOSE_NATIVE_EGL)
#include <EGL/egl.h>
#endif
/*************************************************************************
* Functions
*************************************************************************/
#if defined(GLFW_EXPOSE_NATIVE_WIN32)
/*! @brief Returns the adapter device name of the specified monitor.
*
* @return The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`)
* of the specified monitor, or `NULL` if an [error](@ref error_handling)
* occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.1.
*
* @ingroup native
*/
GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor);
/*! @brief Returns the display device name of the specified monitor.
*
* @return The UTF-8 encoded display device name (for example
* `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.1.
*
* @ingroup native
*/
GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor);
/*! @brief Returns the `HWND` of the specified window.
*
* @return The `HWND` of the specified window, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_WGL)
/*! @brief Returns the `HGLRC` of the specified window.
*
* @return The `HGLRC` of the specified window, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_COCOA)
/*! @brief Returns the `CGDirectDisplayID` of the specified monitor.
*
* @return The `CGDirectDisplayID` of the specified monitor, or
* `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.1.
*
* @ingroup native
*/
GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
/*! @brief Returns the `NSWindow` of the specified window.
*
* @return The `NSWindow` of the specified window, or `nil` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_NSGL)
/*! @brief Returns the `NSOpenGLContext` of the specified window.
*
* @return The `NSOpenGLContext` of the specified window, or `nil` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_X11)
/*! @brief Returns the `Display` used by GLFW.
*
* @return The `Display` used by GLFW, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI Display* glfwGetX11Display(void);
/*! @brief Returns the `RRCrtc` of the specified monitor.
*
* @return The `RRCrtc` of the specified monitor, or `None` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.1.
*
* @ingroup native
*/
GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
/*! @brief Returns the `RROutput` of the specified monitor.
*
* @return The `RROutput` of the specified monitor, or `None` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.1.
*
* @ingroup native
*/
GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
/*! @brief Returns the `Window` of the specified window.
*
* @return The `Window` of the specified window, or `None` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_GLX)
/*! @brief Returns the `GLXContext` of the specified window.
*
* @return The `GLXContext` of the specified window, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
/*! @brief Returns the `GLXWindow` of the specified window.
*
* @return The `GLXWindow` of the specified window, or `None` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
/*! @brief Returns the `struct wl_display*` used by GLFW.
*
* @return The `struct wl_display*` used by GLFW, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI struct wl_display* glfwGetWaylandDisplay(void);
/*! @brief Returns the `struct wl_output*` of the specified monitor.
*
* @return The `struct wl_output*` of the specified monitor, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
/*! @brief Returns the main `struct wl_surface*` of the specified window.
*
* @return The main `struct wl_surface*` of the specified window, or `NULL` if
* an [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_MIR)
/*! @brief Returns the `MirConnection*` used by GLFW.
*
* @return The `MirConnection*` used by GLFW, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI MirConnection* glfwGetMirDisplay(void);
/*! @brief Returns the Mir output ID of the specified monitor.
*
* @return The Mir output ID of the specified monitor, or zero if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
/*! @brief Returns the `MirSurface*` of the specified window.
*
* @return The `MirSurface*` of the specified window, or `NULL` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.2.
*
* @ingroup native
*/
GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* window);
#endif
#if defined(GLFW_EXPOSE_NATIVE_EGL)
/*! @brief Returns the `EGLDisplay` used by GLFW.
*
* @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
/*! @brief Returns the `EGLContext` of the specified window.
*
* @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
/*! @brief Returns the `EGLSurface` of the specified window.
*
* @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an
* [error](@ref error_handling) occurred.
*
* @thread_safety This function may be called from any thread. Access is not
* synchronized.
*
* @since Added in version 3.0.
*
* @ingroup native
*/
GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
#endif
#ifdef __cplusplus
}
#endif
#endif /* _glfw3_native_h_ */

Binary file not shown.

Binary file not shown.

Binary file not shown.

View File

@ -0,0 +1,256 @@
/*
** $Id: lauxlib.h,v 1.129 2015/11/23 11:29:43 roberto Exp $
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/
#ifndef lauxlib_h
#define lauxlib_h
#include <stddef.h>
#include <stdio.h>
#include "lua.h"
/* extra error code for 'luaL_load' */
#define LUA_ERRFILE (LUA_ERRERR+1)
typedef struct luaL_Reg {
const char *name;
lua_CFunction func;
} luaL_Reg;
#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
#define luaL_checkversion(L) \
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
size_t *l);
LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
const char *def, size_t *l);
LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
lua_Integer def);
LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
LUALIB_API void (luaL_where) (lua_State *L, int lvl);
LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
const char *const lst[]);
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
/* predefined references */
#define LUA_NOREF (-2)
#define LUA_REFNIL (-1)
LUALIB_API int (luaL_ref) (lua_State *L, int t);
LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
const char *mode);
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
const char *name, const char *mode);
LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
LUALIB_API lua_State *(luaL_newstate) (void);
LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
const char *r);
LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
const char *msg, int level);
LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
lua_CFunction openf, int glb);
/*
** ===============================================================
** some useful macros
** ===============================================================
*/
#define luaL_newlibtable(L,l) \
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
#define luaL_newlib(L,l) \
(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
#define luaL_argcheck(L, cond,arg,extramsg) \
((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
#define luaL_dofile(L, fn) \
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_dostring(L, s) \
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
/*
** {======================================================
** Generic Buffer manipulation
** =======================================================
*/
typedef struct luaL_Buffer {
char *b; /* buffer address */
size_t size; /* buffer size */
size_t n; /* number of characters in buffer */
lua_State *L;
char initb[LUAL_BUFFERSIZE]; /* initial buffer */
} luaL_Buffer;
#define luaL_addchar(B,c) \
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
((B)->b[(B)->n++] = (c)))
#define luaL_addsize(B,s) ((B)->n += (s))
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
/* }====================================================== */
/*
** {======================================================
** File handles for IO library
** =======================================================
*/
/*
** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
** initial structure 'luaL_Stream' (it may contain other fields
** after that initial structure).
*/
#define LUA_FILEHANDLE "FILE*"
typedef struct luaL_Stream {
FILE *f; /* stream (NULL for incompletely created streams) */
lua_CFunction closef; /* to close stream (NULL for closed streams) */
} luaL_Stream;
/* }====================================================== */
/* compatibility with old module system */
#if defined(LUA_COMPAT_MODULE)
LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
int sizehint);
LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
const luaL_Reg *l, int nup);
#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0))
#endif
/*
** {==================================================================
** "Abstraction Layer" for basic report of messages and errors
** ===================================================================
*/
/* print a string */
#if !defined(lua_writestring)
#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
#endif
/* print a newline and flush the output */
#if !defined(lua_writeline)
#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout))
#endif
/* print an error message */
#if !defined(lua_writestringerror)
#define lua_writestringerror(s,p) \
(fprintf(stderr, (s), (p)), fflush(stderr))
#endif
/* }================================================================== */
/*
** {============================================================
** Compatibility with deprecated conversions
** =============================================================
*/
#if defined(LUA_COMPAT_APIINTCASTS)
#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a))
#define luaL_optunsigned(L,a,d) \
((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
#endif
/* }============================================================ */
#endif

View File

@ -0,0 +1,486 @@
/*
** $Id: lua.h,v 1.331 2016/05/30 15:53:28 roberto Exp $
** Lua - A Scripting Language
** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
** See Copyright Notice at the end of this file
*/
#ifndef lua_h
#define lua_h
#include <stdarg.h>
#include <stddef.h>
#include "luaconf.h"
#define LUA_VERSION_MAJOR "5"
#define LUA_VERSION_MINOR "3"
#define LUA_VERSION_NUM 503
#define LUA_VERSION_RELEASE "3"
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2016 Lua.org, PUC-Rio"
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
/* mark for precompiled code ('<esc>Lua') */
#define LUA_SIGNATURE "\x1bLua"
/* option for multiple returns in 'lua_pcall' and 'lua_call' */
#define LUA_MULTRET (-1)
/*
** Pseudo-indices
** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
** space after that to help overflow detection)
*/
#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000)
#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
/* thread status */
#define LUA_OK 0
#define LUA_YIELD 1
#define LUA_ERRRUN 2
#define LUA_ERRSYNTAX 3
#define LUA_ERRMEM 4
#define LUA_ERRGCMM 5
#define LUA_ERRERR 6
typedef struct lua_State lua_State;
/*
** basic types
*/
#define LUA_TNONE (-1)
#define LUA_TNIL 0
#define LUA_TBOOLEAN 1
#define LUA_TLIGHTUSERDATA 2
#define LUA_TNUMBER 3
#define LUA_TSTRING 4
#define LUA_TTABLE 5
#define LUA_TFUNCTION 6
#define LUA_TUSERDATA 7
#define LUA_TTHREAD 8
#define LUA_NUMTAGS 9
/* minimum Lua stack available to a C function */
#define LUA_MINSTACK 20
/* predefined values in the registry */
#define LUA_RIDX_MAINTHREAD 1
#define LUA_RIDX_GLOBALS 2
#define LUA_RIDX_LAST LUA_RIDX_GLOBALS
/* type of numbers in Lua */
typedef LUA_NUMBER lua_Number;
/* type for integer functions */
typedef LUA_INTEGER lua_Integer;
/* unsigned integer type */
typedef LUA_UNSIGNED lua_Unsigned;
/* type for continuation-function contexts */
typedef LUA_KCONTEXT lua_KContext;
/*
** Type for C functions registered with Lua
*/
typedef int (*lua_CFunction) (lua_State *L);
/*
** Type for continuation functions
*/
typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
/*
** Type for functions that read/write blocks when loading/dumping Lua chunks
*/
typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
/*
** Type for memory-allocation functions
*/
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
/*
** generic extra include file
*/
#if defined(LUA_USER_H)
#include LUA_USER_H
#endif
/*
** RCS ident string
*/
extern const char lua_ident[];
/*
** state manipulation
*/
LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
LUA_API void (lua_close) (lua_State *L);
LUA_API lua_State *(lua_newthread) (lua_State *L);
LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
LUA_API const lua_Number *(lua_version) (lua_State *L);
/*
** basic stack manipulation
*/
LUA_API int (lua_absindex) (lua_State *L, int idx);
LUA_API int (lua_gettop) (lua_State *L);
LUA_API void (lua_settop) (lua_State *L, int idx);
LUA_API void (lua_pushvalue) (lua_State *L, int idx);
LUA_API void (lua_rotate) (lua_State *L, int idx, int n);
LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);
LUA_API int (lua_checkstack) (lua_State *L, int n);
LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
/*
** access functions (stack -> C)
*/
LUA_API int (lua_isnumber) (lua_State *L, int idx);
LUA_API int (lua_isstring) (lua_State *L, int idx);
LUA_API int (lua_iscfunction) (lua_State *L, int idx);
LUA_API int (lua_isinteger) (lua_State *L, int idx);
LUA_API int (lua_isuserdata) (lua_State *L, int idx);
LUA_API int (lua_type) (lua_State *L, int idx);
LUA_API const char *(lua_typename) (lua_State *L, int tp);
LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum);
LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum);
LUA_API int (lua_toboolean) (lua_State *L, int idx);
LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
LUA_API size_t (lua_rawlen) (lua_State *L, int idx);
LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
LUA_API void *(lua_touserdata) (lua_State *L, int idx);
LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
LUA_API const void *(lua_topointer) (lua_State *L, int idx);
/*
** Comparison and arithmetic functions
*/
#define LUA_OPADD 0 /* ORDER TM, ORDER OP */
#define LUA_OPSUB 1
#define LUA_OPMUL 2
#define LUA_OPMOD 3
#define LUA_OPPOW 4
#define LUA_OPDIV 5
#define LUA_OPIDIV 6
#define LUA_OPBAND 7
#define LUA_OPBOR 8
#define LUA_OPBXOR 9
#define LUA_OPSHL 10
#define LUA_OPSHR 11
#define LUA_OPUNM 12
#define LUA_OPBNOT 13
LUA_API void (lua_arith) (lua_State *L, int op);
#define LUA_OPEQ 0
#define LUA_OPLT 1
#define LUA_OPLE 2
LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);
/*
** push functions (C -> stack)
*/
LUA_API void (lua_pushnil) (lua_State *L);
LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
va_list argp);
LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
LUA_API void (lua_pushboolean) (lua_State *L, int b);
LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
LUA_API int (lua_pushthread) (lua_State *L);
/*
** get functions (Lua -> stack)
*/
LUA_API int (lua_getglobal) (lua_State *L, const char *name);
LUA_API int (lua_gettable) (lua_State *L, int idx);
LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
LUA_API int (lua_rawget) (lua_State *L, int idx);
LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
LUA_API int (lua_getuservalue) (lua_State *L, int idx);
/*
** set functions (stack -> Lua)
*/
LUA_API void (lua_setglobal) (lua_State *L, const char *name);
LUA_API void (lua_settable) (lua_State *L, int idx);
LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n);
LUA_API void (lua_rawset) (lua_State *L, int idx);
LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p);
LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
LUA_API void (lua_setuservalue) (lua_State *L, int idx);
/*
** 'load' and 'call' functions (load and run Lua code)
*/
LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults,
lua_KContext ctx, lua_KFunction k);
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
lua_KContext ctx, lua_KFunction k);
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
const char *chunkname, const char *mode);
LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
/*
** coroutine functions
*/
LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx,
lua_KFunction k);
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg);
LUA_API int (lua_status) (lua_State *L);
LUA_API int (lua_isyieldable) (lua_State *L);
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
/*
** garbage-collection function and options
*/
#define LUA_GCSTOP 0
#define LUA_GCRESTART 1
#define LUA_GCCOLLECT 2
#define LUA_GCCOUNT 3
#define LUA_GCCOUNTB 4
#define LUA_GCSTEP 5
#define LUA_GCSETPAUSE 6
#define LUA_GCSETSTEPMUL 7
#define LUA_GCISRUNNING 9
LUA_API int (lua_gc) (lua_State *L, int what, int data);
/*
** miscellaneous functions
*/
LUA_API int (lua_error) (lua_State *L);
LUA_API int (lua_next) (lua_State *L, int idx);
LUA_API void (lua_concat) (lua_State *L, int n);
LUA_API void (lua_len) (lua_State *L, int idx);
LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s);
LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
/*
** {==============================================================
** some useful macros
** ===============================================================
*/
#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE))
#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)
#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL)
#define lua_pop(L,n) lua_settop(L, -(n)-1)
#define lua_newtable(L) lua_createtable(L, 0, 0)
#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
#define lua_pushliteral(L, s) lua_pushstring(L, "" s)
#define lua_pushglobaltable(L) \
((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
#define lua_insert(L,idx) lua_rotate(L, (idx), 1)
#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1))
#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1))
/* }============================================================== */
/*
** {==============================================================
** compatibility macros for unsigned conversions
** ===============================================================
*/
#if defined(LUA_COMPAT_APIINTCASTS)
#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is))
#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL)
#endif
/* }============================================================== */
/*
** {======================================================================
** Debug API
** =======================================================================
*/
/*
** Event codes
*/
#define LUA_HOOKCALL 0
#define LUA_HOOKRET 1
#define LUA_HOOKLINE 2
#define LUA_HOOKCOUNT 3
#define LUA_HOOKTAILCALL 4
/*
** Event masks
*/
#define LUA_MASKCALL (1 << LUA_HOOKCALL)
#define LUA_MASKRET (1 << LUA_HOOKRET)
#define LUA_MASKLINE (1 << LUA_HOOKLINE)
#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
typedef struct lua_Debug lua_Debug; /* activation record */
/* Functions to be called by the debugger in specific events */
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
int fidx2, int n2);
LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
LUA_API lua_Hook (lua_gethook) (lua_State *L);
LUA_API int (lua_gethookmask) (lua_State *L);
LUA_API int (lua_gethookcount) (lua_State *L);
struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */
const char *source; /* (S) */
int currentline; /* (l) */
int linedefined; /* (S) */
int lastlinedefined; /* (S) */
unsigned char nups; /* (u) number of upvalues */
unsigned char nparams;/* (u) number of parameters */
char isvararg; /* (u) */
char istailcall; /* (t) */
char short_src[LUA_IDSIZE]; /* (S) */
/* private part */
struct CallInfo *i_ci; /* active function */
};
/* }====================================================================== */
/******************************************************************************
* Copyright (C) 1994-2016 Lua.org, PUC-Rio.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
******************************************************************************/
#endif

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