UnrealXR/raylib-go
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add new functions, update C sources

Browse source
This commit is contained in:
Milan Nikolic 2017-03-10 15:01:42 +01:00
parent 1aabddd935
commit 732563d5c2
19 changed files with 541 additions and 647 deletions
Download patch file Download diff file Expand all files Collapse all files

69
raylib/audio.c
View file

@ -3,33 +3,51 @@
* raylib.audio * raylib.audio
* *
* This module provides basic functionality to work with audio: * This module provides basic functionality to work with audio:
* Manage audio device (init/close) * Manage audio device (init/close)
* Load and Unload audio files (WAV, OGG, FLAC, XM, MOD) * Load and Unload audio files (WAV, OGG, FLAC, XM, MOD)
* Play/Stop/Pause/Resume loaded audio * Play/Stop/Pause/Resume loaded audio
* Manage mixing channels * Manage mixing channels
* Manage raw audio context * Manage raw audio context
* *
* External libs: * NOTES:
*
* Only up to two channels supported: MONO and STEREO (for additional channels, use AL_EXT_MCFORMATS)
* Only the following sample sizes supported: 8bit PCM, 16bit PCM, 32-bit float PCM (using AL_EXT_FLOAT32)
*
* CONFIGURATION:
*
* #define AUDIO_STANDALONE
* If defined, the module can be used as standalone library (independently of raylib).
* Required types and functions are defined in the same module.
*
* #define SUPPORT_FILEFORMAT_WAV / SUPPORT_LOAD_WAV / ENABLE_LOAD_WAV
* #define SUPPORT_FILEFORMAT_OGG
* #define SUPPORT_FILEFORMAT_XM
* #define SUPPORT_FILEFORMAT_MOD
* #define SUPPORT_FILEFORMAT_FLAC
* Selected desired fileformats to be supported for loading. Some of those formats are
* supported by default, to remove support, just comment unrequired #define in this module
*
* #define SUPPORT_RAW_AUDIO_BUFFERS
*
* DEPENDENCIES:
* OpenAL Soft - Audio device management (http://kcat.strangesoft.net/openal.html) * OpenAL Soft - Audio device management (http://kcat.strangesoft.net/openal.html)
* stb_vorbis - OGG audio files loading (http://www.nothings.org/stb_vorbis/) * stb_vorbis - OGG audio files loading (http://www.nothings.org/stb_vorbis/)
* jar_xm - XM module file loading * jar_xm - XM module file loading
* jar_mod - MOD audio file loading * jar_mod - MOD audio file loading
* dr_flac - FLAC audio file loading * dr_flac - FLAC audio file loading
* *
* Module Configuration Flags: * CONTRIBUTORS:
* AUDIO_STANDALONE - Use this module as standalone library (independently of raylib)
*
* Some design decisions:
* Support only up to two channels: MONO and STEREO (for additional channels, AL_EXT_MCFORMATS)
* Support only the following sample sizes: 8bit PCM, 16bit PCM, 32-bit float PCM (using AL_EXT_FLOAT32)
* *
* Many thanks to Joshua Reisenauer (github: @kd7tck) for the following additions: * Many thanks to Joshua Reisenauer (github: @kd7tck) for the following additions:
* XM audio module support (jar_xm) * XM audio module support (jar_xm)
* MOD audio module support (jar_mod) * MOD audio module support (jar_mod)
* Mixing channels support * Mixing channels support
* Raw audio context support * Raw audio context support
* *
* *
* LICENSE: zlib/libpng
*
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
* This software is provided "as-is", without any express or implied warranty. In no event * This software is provided "as-is", without any express or implied warranty. In no event
@ -246,11 +264,11 @@ Wave LoadWave(const char *fileName)
else if (strcmp(GetExtension(fileName), "flac") == 0) wave = LoadFLAC(fileName); else if (strcmp(GetExtension(fileName), "flac") == 0) wave = LoadFLAC(fileName);
else if (strcmp(GetExtension(fileName),"rres") == 0) else if (strcmp(GetExtension(fileName),"rres") == 0)
{ {
RRESData rres = LoadResource(fileName); RRES rres = LoadResource(fileName, 0);
// NOTE: Parameters for RRES_WAVE type are: sampleCount, sampleRate, sampleSize, channels // NOTE: Parameters for RRES_TYPE_WAVE are: sampleCount, sampleRate, sampleSize, channels
if (rres.type == RRES_WAVE) wave = LoadWaveEx(rres.data, rres.param1, rres.param2, rres.param3, rres.param4); if (rres[0].type == RRES_TYPE_WAVE) wave = LoadWaveEx(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3, rres[0].param4);
else TraceLog(WARNING, "[%s] Resource file does not contain wave data", fileName); else TraceLog(WARNING, "[%s] Resource file does not contain wave data", fileName);
UnloadResource(rres); UnloadResource(rres);
@ -586,7 +604,7 @@ void WaveCrop(Wave *wave, int initSample, int finalSample)
void *data = malloc(sampleCount*wave->channels*wave->sampleSize/8); void *data = malloc(sampleCount*wave->channels*wave->sampleSize/8);
memcpy(data, wave->data + (initSample*wave->channels*wave->sampleSize/8), sampleCount*wave->channels*wave->sampleSize/8); memcpy(data, (unsigned char*)wave->data + (initSample*wave->channels*wave->sampleSize/8), sampleCount*wave->channels*wave->sampleSize/8);
free(wave->data); free(wave->data);
wave->data = data; wave->data = data;
@ -744,7 +762,18 @@ void ResumeMusicStream(Music music)
void StopMusicStream(Music music) void StopMusicStream(Music music)
{ {
alSourceStop(music->stream.source); alSourceStop(music->stream.source);
// Clear stream buffers
void *pcm = calloc(AUDIO_BUFFER_SIZE*music->stream.sampleSize/8*music->stream.channels, 1);
for (int i = 0; i < MAX_STREAM_BUFFERS; i++)
{
alBufferData(music->stream.buffers[i], music->stream.format, pcm, AUDIO_BUFFER_SIZE*music->stream.sampleSize/8*music->stream.channels, music->stream.sampleRate);
}
free(pcm);
// Restart music context
switch (music->ctxType) switch (music->ctxType)
{ {
case MUSIC_AUDIO_OGG: stb_vorbis_seek_start(music->ctxOgg); break; case MUSIC_AUDIO_OGG: stb_vorbis_seek_start(music->ctxOgg); break;

2
raylib/audio.go
View file

@ -1,6 +1,8 @@
package raylib package raylib
/* /*
#include "external/stb_vorbis.c"
#include "raylib.h" #include "raylib.h"
#include <stdlib.h> #include <stdlib.h>
*/ */

4
raylib/audio.h
View file

@ -9,7 +9,7 @@
* Manage mixing channels * Manage mixing channels
* Manage raw audio context * Manage raw audio context
* *
* External libs: * DEPENDENCIES:
* OpenAL Soft - Audio device management (http://kcat.strangesoft.net/openal.html) * OpenAL Soft - Audio device management (http://kcat.strangesoft.net/openal.html)
* stb_vorbis - OGG audio files loading (http://www.nothings.org/stb_vorbis/) * stb_vorbis - OGG audio files loading (http://www.nothings.org/stb_vorbis/)
* jar_xm - XM module file loading * jar_xm - XM module file loading
@ -23,6 +23,8 @@
* Raw audio context support * Raw audio context support
* *
* *
* LICENSE: zlib/libpng
*
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
* This software is provided "as-is", without any express or implied warranty. In no event * This software is provided "as-is", without any express or implied warranty. In no event

14
raylib/camera.h
View file

@ -2,6 +2,10 @@
* *
* raylib Camera System - Camera Modes Setup and Control Functions * raylib Camera System - Camera Modes Setup and Control Functions
* *
* NOTE: Memory footprint of this library is aproximately 52 bytes (global variables)
*
* CONFIGURATION:
*
* #define CAMERA_IMPLEMENTATION * #define CAMERA_IMPLEMENTATION
* Generates the implementation of the library into the included file. * Generates the implementation of the library into the included file.
* If not defined, the library is in header only mode and can be included in other headers * If not defined, the library is in header only mode and can be included in other headers
@ -11,10 +15,14 @@
* If defined, the library can be used as standalone as a camera system but some * If defined, the library can be used as standalone as a camera system but some
* functions must be redefined to manage inputs accordingly. * functions must be redefined to manage inputs accordingly.
* *
* NOTE: Memory footprint of this library is aproximately 52 bytes (global variables) * CONTRIBUTORS:
* Marc Palau: Initial implementation (2014)
* Ramon Santamaria: Supervision, review, update and maintenance
* *
* Initial design by Marc Palau (2014) *
* Reviewed by Ramon Santamaria (2015-2016) * LICENSE: zlib/libpng
*
* Copyright (c) 2015-2016 Ramon Santamaria (@raysan5)
* *
* This software is provided "as-is", without any express or implied warranty. In no event * 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. * will the authors be held liable for any damages arising from the use of this software.

180
raylib/core.c
View file

@ -1,27 +1,46 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.core * raylib.core - Basic functions to manage windows, OpenGL context and input on multiple platforms
*
* Basic functions to manage windows, OpenGL context and input on multiple platforms
* *
* The following platforms are supported: Windows, Linux, Mac (OSX), Android, Raspberry Pi, HTML5, Oculus Rift CV1 * The following platforms are supported: Windows, Linux, Mac (OSX), Android, Raspberry Pi, HTML5, Oculus Rift CV1
* *
* External libs: * CONFIGURATION:
*
* #define PLATFORM_DESKTOP
* Windowing and input system configured for desktop platforms: Windows, Linux, OSX (managed by GLFW3 library)
* NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for mirror rendering - View [rlgl] module to enable it
*
* #define PLATFORM_ANDROID
* Windowing and input system configured for Android device, app activity managed internally in this module.
* NOTE: OpenGL ES 2.0 is required and graphic device is managed by EGL
*
* #define PLATFORM_RPI
* Windowing and input system configured for Raspberry Pi (tested on Raspbian), graphic device is managed by EGL
* and inputs are processed is raw mode, reading from /dev/input/
*
* #define PLATFORM_WEB
* Windowing and input system configured for HTML5 (run on browser), code converted from C to asm.js
* using emscripten compiler. OpenGL ES 2.0 required for direct translation to WebGL equivalent code.
*
* #define LOAD_DEFAULT_FONT (defined by default)
* Default font is loaded on window initialization to be available for the user to render simple text.
* NOTE: If enabled, uses external module functions to load default raylib font (module: text)
*
* #define INCLUDE_CAMERA_SYSTEM / SUPPORT_CAMERA_SYSTEM
*
* #define INCLUDE_GESTURES_SYSTEM / SUPPORT_GESTURES_SYSTEM
*
* #define SUPPORT_MOUSE_GESTURES
* Mouse gestures are directly mapped like touches and processed by gestures system.
*
* DEPENDENCIES:
* GLFW3 - Manage graphic device, OpenGL context and inputs on PLATFORM_DESKTOP (Windows, Linux, OSX) * GLFW3 - Manage graphic device, OpenGL context and inputs on PLATFORM_DESKTOP (Windows, Linux, OSX)
* raymath - 3D math functionality (Vector3, Matrix, Quaternion) * raymath - 3D math functionality (Vector3, Matrix, Quaternion)
* camera - Multiple 3D camera modes (free, orbital, 1st person, 3rd person) * camera - Multiple 3D camera modes (free, orbital, 1st person, 3rd person)
* gestures - Gestures system for touch-ready devices (or simulated from mouse inputs) * gestures - Gestures system for touch-ready devices (or simulated from mouse inputs)
* *
* Module Configuration Flags:
* PLATFORM_DESKTOP - Windows, Linux, Mac (OSX)
* PLATFORM_ANDROID - Android (only OpenGL ES 2.0 devices), graphic device is managed by EGL and input system by Android activity.
* PLATFORM_RPI - Rapsberry Pi (tested on Raspbian), graphic device is managed by EGL and input system is coded in raw mode.
* PLATFORM_WEB - HTML5 (using emscripten compiler)
*
* RL_LOAD_DEFAULT_FONT - Use external module functions to load default raylib font (module: text)
*
* NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for render mirror - View [rlgl] module to enable it
* *
* LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
@ -69,6 +88,8 @@
#if defined __linux || defined(PLATFORM_WEB) #if defined __linux || defined(PLATFORM_WEB)
#include <sys/time.h> // Required for: timespec, nanosleep(), select() - POSIX #include <sys/time.h> // Required for: timespec, nanosleep(), select() - POSIX
#elif defined __APPLE__
#include <unistd.h> // Required for: usleep()
#endif #endif
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
@ -140,7 +161,7 @@
#define MAX_GAMEPAD_BUTTONS 32 // Max bumber of buttons supported (per gamepad) #define MAX_GAMEPAD_BUTTONS 32 // Max bumber of buttons supported (per gamepad)
#define MAX_GAMEPAD_AXIS 8 // Max number of axis supported (per gamepad) #define MAX_GAMEPAD_AXIS 8 // Max number of axis supported (per gamepad)
#define RL_LOAD_DEFAULT_FONT // Load default font on window initialization (module: text) #define LOAD_DEFAULT_FONT // Load default font on window initialization (module: text)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Types and Structures Definition // Types and Structures Definition
@ -256,7 +277,7 @@ static bool showLogo = false; // Track if showing logo at init is
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Other Modules Functions Declaration (required by core) // Other Modules Functions Declaration (required by core)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#if defined(RL_LOAD_DEFAULT_FONT) #if defined(LOAD_DEFAULT_FONT)
extern void LoadDefaultFont(void); // [Module: text] Loads default font on InitWindow() extern void LoadDefaultFont(void); // [Module: text] Loads default font on InitWindow()
extern void UnloadDefaultFont(void); // [Module: text] Unloads default font from GPU memory extern void UnloadDefaultFont(void); // [Module: text] Unloads default font from GPU memory
#endif #endif
@ -268,7 +289,7 @@ static void InitGraphicsDevice(int width, int height); // Initialize graphics d
static void SetupFramebufferSize(int displayWidth, int displayHeight); static void SetupFramebufferSize(int displayWidth, int displayHeight);
static void InitTimer(void); // Initialize timer static void InitTimer(void); // Initialize timer
static double GetTime(void); // Returns time since InitTimer() was run static double GetTime(void); // Returns time since InitTimer() was run
static void Wait(int ms); // Wait for some milliseconds (stop program execution) static void Wait(float ms); // Wait for some milliseconds (stop program execution)
static bool GetKeyStatus(int key); // Returns if a key has been pressed static bool GetKeyStatus(int key); // Returns if a key has been pressed
static bool GetMouseButtonStatus(int button); // Returns if a mouse button has been pressed static bool GetMouseButtonStatus(int button); // Returns if a mouse button has been pressed
static void PollInputEvents(void); // Register user events static void PollInputEvents(void); // Register user events
@ -320,7 +341,7 @@ static void *GamepadThread(void *arg); // Mouse reading thread
#if defined(_WIN32) #if defined(_WIN32)
// NOTE: We include Sleep() function signature here to avoid windows.h inclusion // NOTE: We include Sleep() function signature here to avoid windows.h inclusion
void __stdcall Sleep(unsigned long msTimeout); // Required for Delay() void __stdcall Sleep(unsigned long msTimeout); // Required for Wait()
#endif #endif
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -338,7 +359,7 @@ void InitWindow(int width, int height, const char *title)
// Init graphics device (display device and OpenGL context) // Init graphics device (display device and OpenGL context)
InitGraphicsDevice(width, height); InitGraphicsDevice(width, height);
#if defined(RL_LOAD_DEFAULT_FONT) #if defined(LOAD_DEFAULT_FONT)
// Load default font // Load default font
// NOTE: External function (defined in module: text) // NOTE: External function (defined in module: text)
LoadDefaultFont(); LoadDefaultFont();
@ -450,7 +471,7 @@ void InitWindow(int width, int height, void *state)
// Close Window and Terminate Context // Close Window and Terminate Context
void CloseWindow(void) void CloseWindow(void)
{ {
#if defined(RL_LOAD_DEFAULT_FONT) #if defined(LOAD_DEFAULT_FONT)
UnloadDefaultFont(); UnloadDefaultFont();
#endif #endif
@ -559,6 +580,30 @@ void SetWindowIcon(Image image)
#endif #endif
} }
// Set window position on screen (windowed mode)
void SetWindowPosition(int x, int y)
{
#if defined(PLATFORM_DESKTOP)
glfwSetWindowPos(window, x, y);
#endif
}
// Set monitor for the current window (fullscreen mode)
void SetWindowMonitor(int monitor)
{
#if defined(PLATFORM_DESKTOP)
int monitorCount;
GLFWmonitor** monitors = glfwGetMonitors(&monitorCount);
if ((monitor >= 0) && (monitor < monitorCount))
{
glfwSetWindowMonitor(window, monitors[monitor], 0, 0, screenWidth, screenHeight, GLFW_DONT_CARE);
TraceLog(INFO, "Selected fullscreen monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
}
else TraceLog(WARNING, "Selected monitor not found");
#endif
}
// Get current screen width // Get current screen width
int GetScreenWidth(void) int GetScreenWidth(void)
{ {
@ -664,19 +709,19 @@ void EndDrawing(void)
currentTime = GetTime(); currentTime = GetTime();
drawTime = currentTime - previousTime; drawTime = currentTime - previousTime;
previousTime = currentTime; previousTime = currentTime;
frameTime = updateTime + drawTime; frameTime = updateTime + drawTime;
// Wait for some milliseconds... // Wait for some milliseconds...
if (frameTime < targetTime) if (frameTime < targetTime)
{ {
Wait((int)((targetTime - frameTime)*1000)); Wait((targetTime - frameTime)*1000.0f);
currentTime = GetTime(); currentTime = GetTime();
double extraTime = currentTime - previousTime; double extraTime = currentTime - previousTime;
previousTime = currentTime; previousTime = currentTime;
frameTime = updateTime + drawTime + extraTime; frameTime += extraTime;
} }
} }
@ -812,14 +857,14 @@ void SetTargetFPS(int fps)
// Returns current FPS // Returns current FPS
int GetFPS(void) int GetFPS(void)
{ {
return (int)floorf(1.0f/GetFrameTime()); return (int)(1.0f/GetFrameTime());
} }
// Returns time in seconds for one frame // Returns time in seconds for one frame
float GetFrameTime(void) float GetFrameTime(void)
{ {
// NOTE: We round value to milliseconds // NOTE: We round value to milliseconds
return (roundf(frameTime*1000.0)/1000.0f); return (float)frameTime;
} }
// Converts Color to float array and normalizes // Converts Color to float array and normalizes
@ -1084,16 +1129,16 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera)
MatrixInvert(&matProjView); MatrixInvert(&matProjView);
// Calculate far and near points // Calculate far and near points
Quaternion near = { deviceCoords.x, deviceCoords.y, 0.0f, 1.0f }; Quaternion qNear = { deviceCoords.x, deviceCoords.y, 0.0f, 1.0f };
Quaternion far = { deviceCoords.x, deviceCoords.y, 1.0f, 1.0f }; Quaternion qFar = { deviceCoords.x, deviceCoords.y, 1.0f, 1.0f };
// Multiply points by unproject matrix // Multiply points by unproject matrix
QuaternionTransform(&near, matProjView); QuaternionTransform(&qNear, matProjView);
QuaternionTransform(&far, matProjView); QuaternionTransform(&qFar, matProjView);
// Calculate normalized world points in vectors // Calculate normalized world points in vectors
Vector3 nearPoint = { near.x/near.w, near.y/near.w, near.z/near.w}; Vector3 nearPoint = { qNear.x/qNear.w, qNear.y/qNear.w, qNear.z/qNear.w};
Vector3 farPoint = { far.x/far.w, far.y/far.w, far.z/far.w}; Vector3 farPoint = { qFar.x/qFar.w, qFar.y/qFar.w, qFar.z/qFar.w};
#endif #endif
// Calculate normalized direction vector // Calculate normalized direction vector
@ -1517,13 +1562,23 @@ static void InitGraphicsDevice(int width, int height)
glfwDefaultWindowHints(); // Set default windows hints glfwDefaultWindowHints(); // Set default windows hints
if (configFlags & FLAG_RESIZABLE_WINDOW) // Check some Window creation flags
{ if (configFlags & FLAG_WINDOW_RESIZABLE) glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); // Resizable window
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); // Resizable window
}
else glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Avoid window being resizable else glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // Avoid window being resizable
//glfwWindowHint(GLFW_DECORATED, GL_TRUE); // Border and buttons on Window if (configFlags & FLAG_WINDOW_DECORATED) glfwWindowHint(GLFW_DECORATED, GL_TRUE); // Border and buttons on Window
if (configFlags & FLAG_WINDOW_TRANSPARENT)
{
// TODO: Enable transparent window (not ready yet on GLFW 3.2)
}
if (configFlags & FLAG_MSAA_4X_HINT)
{
glfwWindowHint(GLFW_SAMPLES, 4); // Enables multisampling x4 (MSAA), default is 0
TraceLog(INFO, "Trying to enable MSAA x4");
}
//glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits //glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits
//glfwWindowHint(GLFW_DEPTH_BITS, 16); // Depthbuffer bits (24 by default) //glfwWindowHint(GLFW_DEPTH_BITS, 16); // Depthbuffer bits (24 by default)
//glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window //glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window
@ -1532,13 +1587,7 @@ static void InitGraphicsDevice(int width, int height)
// NOTE: When asking for an OpenGL context version, most drivers provide highest supported version // NOTE: When asking for an OpenGL context version, most drivers provide highest supported version
// with forward compatibility to older OpenGL versions. // with forward compatibility to older OpenGL versions.
// For example, if using OpenGL 1.1, driver can provide a 3.3 context fordward compatible. // For example, if using OpenGL 1.1, driver can provide a 4.3 context forward compatible.
if (configFlags & FLAG_MSAA_4X_HINT)
{
glfwWindowHint(GLFW_SAMPLES, 4); // Enables multisampling x4 (MSAA), default is 0
TraceLog(INFO, "Trying to enable MSAA x4");
}
// Check selection OpenGL version // Check selection OpenGL version
if (rlGetVersion() == OPENGL_21) if (rlGetVersion() == OPENGL_21)
@ -1645,7 +1694,10 @@ static void InitGraphicsDevice(int width, int height)
#endif #endif
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
glfwSwapInterval(0); // Disable VSync by default
// Try to disable GPU V-Sync by default, set framerate using SetTargetFPS()
// NOTE: V-Sync can be enabled by graphic driver configuration
glfwSwapInterval(0);
#if defined(PLATFORM_DESKTOP) #if defined(PLATFORM_DESKTOP)
// Load OpenGL 3.3 extensions // Load OpenGL 3.3 extensions
@ -1653,9 +1705,8 @@ static void InitGraphicsDevice(int width, int height)
rlglLoadExtensions(glfwGetProcAddress); rlglLoadExtensions(glfwGetProcAddress);
#endif #endif
// Enables GPU v-sync, so frames are not limited to screen refresh rate (60Hz -> 60 FPS) // Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
// If not set, swap interval uses GPU v-sync configuration // NOTE: V-Sync can be enabled by graphic driver configuration
// Framerate can be setup using SetTargetFPS()
if (configFlags & FLAG_VSYNC_HINT) if (configFlags & FLAG_VSYNC_HINT)
{ {
glfwSwapInterval(1); glfwSwapInterval(1);
@ -1958,27 +2009,30 @@ static double GetTime(void)
} }
// Wait for some milliseconds (stop program execution) // Wait for some milliseconds (stop program execution)
static void Wait(int ms) static void Wait(float ms)
{ {
#if defined _WIN32 //#define SUPPORT_BUSY_WAIT_LOOP
Sleep(ms); #if defined(SUPPORT_BUSY_WAIT_LOOP)
#elif defined __linux || defined(PLATFORM_WEB)
struct timespec req = { 0 };
time_t sec = (int)(ms/1000);
ms -= (sec*1000);
req.tv_sec=sec;
req.tv_nsec=ms*1000000L;
// NOTE: Use nanosleep() on Unix platforms... usleep() it's deprecated.
while (nanosleep(&req,&req) == -1) continue;
//#elif defined __APPLE__
// TODO:
#else
double prevTime = GetTime(); double prevTime = GetTime();
double nextTime = 0.0; double nextTime = 0.0;
// Busy wait loop // Busy wait loop
while ((nextTime - prevTime) < (double)ms/1000.0) nextTime = GetTime(); while ((nextTime - prevTime) < ms/1000.0f) nextTime = GetTime();
#else
#if defined _WIN32
Sleep(ms);
#elif defined __linux || defined(PLATFORM_WEB)
struct timespec req = { 0 };
time_t sec = (int)(ms/1000.0f);
ms -= (sec*1000);
req.tv_sec = sec;
req.tv_nsec = ms*1000000L;
// NOTE: Use nanosleep() on Unix platforms... usleep() it's deprecated.
while (nanosleep(&req, &req) == -1) continue;
#elif defined __APPLE__
usleep(ms*1000.0f);
#endif
#endif #endif
} }
@ -2410,7 +2464,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd)
// Init graphics device (display device and OpenGL context) // Init graphics device (display device and OpenGL context)
InitGraphicsDevice(screenWidth, screenHeight); InitGraphicsDevice(screenWidth, screenHeight);
#if defined(RL_LOAD_DEFAULT_FONT) #if defined(LOAD_DEFAULT_FONT)
// Load default font // Load default font
// NOTE: External function (defined in module: text) // NOTE: External function (defined in module: text)
LoadDefaultFont(); LoadDefaultFont();

35
raylib/core.go
View file

@ -19,13 +19,21 @@ const (
Rad2deg = 57.295776 Rad2deg = 57.295776
// Raylib Config Flags // Raylib Config Flags
FlagFullscreenMode = 1
FlagResizableWindow = 2 // Set to show raylib logo at startup
FlagShowLogo = 4 FlagShowLogo = 1
FlagShowMouseCursor = 8 // Set to run program in fullscreen
FlagCenteredMode = 16 FlagFullscreenMode = 2
FlagMsaa4xHint = 32 // Set to allow resizable window
FlagVsyncHint = 64 FlagWindowResizable = 4
// Set to show window decoration (frame and buttons)
FlagWindowDecorated = 8
// Set to allow transparent window
FlagWindowTransparent = 16
// Set to try enabling MSAA 4X
FlagMsaa4xHint = 32
// Set to try enabling V-Sync on GPU
FlagVsyncHint = 64
// Keyboard Function Keys // Keyboard Function Keys
KeySpace = 32 KeySpace = 32
@ -459,6 +467,19 @@ func SetWindowIcon(image Image) {
C.SetWindowIcon(*cimage) C.SetWindowIcon(*cimage)
} }
// SetWindowPosition - Set window position on screen (only PLATFORM_DESKTOP)
func SetWindowPosition(x, y int32) {
cx := (C.int)(x)
cy := (C.int)(y)
C.SetWindowPosition(cx, cy)
}
// SetWindowMonitor - Set monitor for the current window (fullscreen mode)
func SetWindowMonitor(monitor int32) {
cmonitor := (C.int)(monitor)
C.SetWindowMonitor(cmonitor)
}
// GetScreenWidth - Get current screen width // GetScreenWidth - Get current screen width
func GetScreenWidth() int32 { func GetScreenWidth() int32 {
ret := C.GetScreenWidth() ret := C.GetScreenWidth()

0
raylib/stb_vorbis.c → raylib/external/stb_vorbis.c vendored
View file

17
raylib/gestures.h
View file

@ -2,6 +2,10 @@
* *
* raylib Gestures System - Gestures Processing based on input gesture events (touch/mouse) * raylib Gestures System - Gestures Processing based on input gesture events (touch/mouse)
* *
* NOTE: Memory footprint of this library is aproximately 128 bytes (global variables)
*
* CONFIGURATION:
*
* #define GESTURES_IMPLEMENTATION * #define GESTURES_IMPLEMENTATION
* Generates the implementation of the library into the included file. * Generates the implementation of the library into the included file.
* If not defined, the library is in header only mode and can be included in other headers * If not defined, the library is in header only mode and can be included in other headers
@ -11,11 +15,16 @@
* If defined, the library can be used as standalone to process gesture events with * If defined, the library can be used as standalone to process gesture events with
* no external dependencies. * no external dependencies.
* *
* NOTE: Memory footprint of this library is aproximately 128 bytes * CONTRIBUTORS:
* Marc Palau: Initial implementation (2014)
* Albert Martos: Complete redesign and testing (2015)
* Ian Eito: Complete redesign and testing (2015)
* Ramon Santamaria: Supervision, review, update and maintenance
* *
* Initial design by Marc Palau (2014) *
* Redesigned by Albert Martos and Ian Eito (2015) * LICENSE: zlib/libpng
* Reviewed by Ramon Santamaria (2015-2016) *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
* This software is provided "as-is", without any express or implied warranty. In no event * 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. * will the authors be held liable for any damages arising from the use of this software.

13
raylib/models.c
View file

@ -1,14 +1,15 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.models * raylib.models - Basic functions to draw 3d shapes and 3d models
* *
* Basic functions to draw 3d shapes and load/draw 3d models (.OBJ) * CONFIGURATION:
* *
* External libs: * #define SUPPORT_FILEFORMAT_OBJ / SUPPORT_LOAD_OBJ
* rlgl - raylib OpenGL abstraction layer
* *
* Module Configuration Flags: * #define SUPPORT_FILEFORMAT_MTL
* ... *
*
* LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *

65
raylib/raylib.h
View file

@ -1,10 +1,10 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib 1.7.0 (www.raylib.com) * raylib v1.7.0 (www.raylib.com)
* *
* A simple and easy-to-use library to learn videogames programming * A simple and easy-to-use library to learn videogames programming
* *
* Features: * FEATURES:
* Library written in plain C code (C99) * Library written in plain C code (C99)
* Uses PascalCase/camelCase notation * Uses PascalCase/camelCase notation
* Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES 2.0) * Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES 2.0)
@ -20,7 +20,13 @@
* Minimal external dependencies (GLFW3, OpenGL, OpenAL) * Minimal external dependencies (GLFW3, OpenGL, OpenAL)
* Complete binding for Lua [rlua] * Complete binding for Lua [rlua]
* *
* External libs: * NOTES:
* 32bit Colors - All defined color are always RGBA (struct Color is 4 byte)
* One custom default font could be loaded automatically when InitWindow() [core]
* If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads
* If using OpenGL 3.3 or ES2, two default shaders could be loaded automatically (internally defined)
*
* DEPENDENCIES:
* GLFW3 (www.glfw.org) for window/context management and input [core] * GLFW3 (www.glfw.org) for window/context management and input [core]
* GLAD for OpenGL extensions loading (3.3 Core profile, only PLATFORM_DESKTOP) [rlgl] * GLAD for OpenGL extensions loading (3.3 Core profile, only PLATFORM_DESKTOP) [rlgl]
* stb_image (Sean Barret) for images loading (JPEG, PNG, BMP, TGA) [textures] * stb_image (Sean Barret) for images loading (JPEG, PNG, BMP, TGA) [textures]
@ -33,13 +39,8 @@
* OpenAL Soft for audio device/context management [audio] * OpenAL Soft for audio device/context management [audio]
* tinfl for data decompression (DEFLATE algorithm) [utils] * tinfl for data decompression (DEFLATE algorithm) [utils]
* *
* Some design decisions:
* 32bit Colors - All defined color are always RGBA (struct Color is 4 byte)
* One custom default font could be loaded automatically when InitWindow() [core]
* If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads
* If using OpenGL 3.3 or ES2, two default shaders could be loaded automatically (internally defined)
* *
* -- LICENSE -- * LICENSE: zlib/libpng
* *
* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, * raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
* BSD-like license that allows static linking with closed source software: * BSD-like license that allows static linking with closed source software:
@ -97,13 +98,13 @@
#define RAD2DEG (180.0f/PI) #define RAD2DEG (180.0f/PI)
// raylib Config Flags // raylib Config Flags
#define FLAG_FULLSCREEN_MODE 1 #define FLAG_SHOW_LOGO 1 // Set to show raylib logo at startup
#define FLAG_RESIZABLE_WINDOW 2 #define FLAG_FULLSCREEN_MODE 2 // Set to run program in fullscreen
#define FLAG_SHOW_LOGO 4 #define FLAG_WINDOW_RESIZABLE 4 // Set to allow resizable window
#define FLAG_SHOW_MOUSE_CURSOR 8 #define FLAG_WINDOW_DECORATED 8 // Set to show window decoration (frame and buttons)
#define FLAG_CENTERED_MODE 16 #define FLAG_WINDOW_TRANSPARENT 16 // Set to allow transparent window
#define FLAG_MSAA_4X_HINT 32 #define FLAG_MSAA_4X_HINT 32 // Set to try enabling MSAA 4X
#define FLAG_VSYNC_HINT 64 #define FLAG_VSYNC_HINT 64 // Set to try enabling V-Sync on GPU
// Keyboard Function Keys // Keyboard Function Keys
#define KEY_SPACE 32 #define KEY_SPACE 32
@ -592,8 +593,9 @@ typedef enum {
HMD_FOVE_VR, HMD_FOVE_VR,
} VrDevice; } VrDevice;
// rRES data returned when reading a resource, it contains all required data for user (24 byte) // rRES data returned when reading a resource,
typedef struct { // it contains all required data for user (24 byte)
typedef struct RRESData {
unsigned int type; // Resource type (4 byte) unsigned int type; // Resource type (4 byte)
unsigned int param1; // Resouce parameter 1 (4 byte) unsigned int param1; // Resouce parameter 1 (4 byte)
@ -604,14 +606,21 @@ typedef struct {
void *data; // Resource data pointer (4 byte) void *data; // Resource data pointer (4 byte)
} RRESData; } RRESData;
typedef enum { // RRESData type
RRES_RAW = 0, typedef enum {
RRES_IMAGE, RRES_TYPE_RAW = 0,
RRES_WAVE, RRES_TYPE_IMAGE,
RRES_VERTEX, RRES_TYPE_WAVE,
RRES_TEXT RRES_TYPE_VERTEX,
RRES_TYPE_TEXT,
RRES_TYPE_FONT_IMAGE,
RRES_TYPE_FONT_CHARDATA, // CharInfo data array
RRES_TYPE_DIRECTORY
} RRESDataType; } RRESDataType;
// RRES type (pointer to RRESData array)
typedef struct RRESData *RRES;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { // Prevents name mangling of functions extern "C" { // Prevents name mangling of functions
#endif #endif
@ -635,6 +644,8 @@ RLAPI bool WindowShouldClose(void); // Detect if K
RLAPI bool IsWindowMinimized(void); // Detect if window has been minimized (or lost focus) RLAPI bool IsWindowMinimized(void); // Detect if window has been minimized (or lost focus)
RLAPI void ToggleFullscreen(void); // Fullscreen toggle (only PLATFORM_DESKTOP) RLAPI void ToggleFullscreen(void); // Fullscreen toggle (only PLATFORM_DESKTOP)
RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP) RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP)
RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP)
RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode)
RLAPI int GetScreenWidth(void); // Get current screen width RLAPI int GetScreenWidth(void); // Get current screen width
RLAPI int GetScreenHeight(void); // Get current screen height RLAPI int GetScreenHeight(void); // Get current screen height
@ -662,8 +673,8 @@ RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Returns the
RLAPI Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix) RLAPI Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix)
RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum)
RLAPI int GetFPS(void); // Returns current FPS (rounded value) RLAPI int GetFPS(void); // Returns current FPS
RLAPI float GetFrameTime(void); // Returns time in seconds for one frame (rounded value) RLAPI float GetFrameTime(void); // Returns time in seconds for one frame
RLAPI Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value RLAPI Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value
RLAPI int GetHexValue(Color color); // Returns hexadecimal value for a Color RLAPI int GetHexValue(Color color); // Returns hexadecimal value for a Color
@ -752,12 +763,14 @@ RLAPI void DrawPixel(int posX, int posY, Color color);
RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version)
RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line
RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version) RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version)
RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness
RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle
RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle
RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version)
RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline
RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle
RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle
RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters
RLAPI void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a gradient-filled rectangle RLAPI void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a gradient-filled rectangle
RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version)
RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline

25
raylib/raymath.h
View file

@ -1,22 +1,23 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raymath (header only file) * raymath v1.0 - Some useful functions to work with Vector3, Matrix and Quaternions
* *
* Some useful functions to work with Vector3, Matrix and Quaternions * CONFIGURATION:
* *
* You must: * #define RAYMATH_IMPLEMENTATION
* #define RAYMATH_IMPLEMENTATION * Generates the implementation of the library into the included file.
* before you include this file in *only one* C or C++ file to create the implementation. * If not defined, the library is in header only mode and can be included in other headers
* or source files without problems. But only ONE file should hold the implementation.
* *
* Example: * #define RAYMATH_EXTERN_INLINE
* #define RAYMATH_IMPLEMENTATION * Inlines all functions code, so it runs faster. This requires lots of memory on system.
* #include "raymath.h" *
* #define RAYMATH_STANDALONE
* Avoid raylib.h header inclusion in this file.
* Vector3 and Matrix data types are defined internally in raymath module.
* *
* You can also use:
* #define RAYMATH_EXTERN_INLINE // Inlines all functions code, so it runs faster.
* // This requires lots of memory on system.
* #define RAYMATH_STANDALONE // Not dependent on raylib.h structs: Vector3, Matrix.
* *
* LICENSE: zlib/libpng
* *
* Copyright (c) 2015 Ramon Santamaria (@raysan5) * Copyright (c) 2015 Ramon Santamaria (@raysan5)
* *

46
raylib/rlgl.c
View file

@ -2,6 +2,8 @@
* *
* rlgl - raylib OpenGL abstraction layer * rlgl - raylib OpenGL abstraction layer
* *
* DESCRIPTION:
*
* rlgl allows usage of OpenGL 1.1 style functions (rlVertex) that are internally mapped to * rlgl allows usage of OpenGL 1.1 style functions (rlVertex) that are internally mapped to
* selected OpenGL version (1.1, 2.1, 3.3 Core, ES 2.0). * selected OpenGL version (1.1, 2.1, 3.3 Core, ES 2.0).
* *
@ -11,20 +13,44 @@
* rlglDraw() - Process internal buffers and send required draw calls * rlglDraw() - Process internal buffers and send required draw calls
* rlglClose() - De-initialize internal buffers data and other auxiliar resources * rlglClose() - De-initialize internal buffers data and other auxiliar resources
* *
* External libs: * CONFIGURATION:
*
* #define GRAPHICS_API_OPENGL_11
* Use OpenGL 1.1 backend
*
* #define GRAPHICS_API_OPENGL_21
* Use OpenGL 2.1 backend
*
* #define GRAPHICS_API_OPENGL_33
* Use OpenGL 3.3 Core profile backend
*
* #define GRAPHICS_API_OPENGL_ES2
* Use OpenGL ES 2.0 backend
*
* #define RLGL_STANDALONE
* Use rlgl as standalone library (no raylib dependency)
*
* #define RLGL_NO_DISTORTION_SHADER
* Avoid stereo rendering distortion sahder (shader_distortion.h) inclusion
*
* #define SUPPORT_SHADER_DEFAULT / ENABLE_SHADER_DEFAULT
*
* #define SUPPORT_SHADER_DISTORTION
*
*
* #define SUPPORT_OCULUS_RIFT_CV1 / RLGL_OCULUS_SUPPORT
* Enable Oculus Rift CV1 functionality
*
* #define SUPPORT_STEREO_RENDERING
*
* #define RLGL_NO_DEFAULT_SHADER
*
* DEPENDENCIES:
* raymath - 3D math functionality (Vector3, Matrix, Quaternion) * raymath - 3D math functionality (Vector3, Matrix, Quaternion)
* GLAD - OpenGL extensions loading (OpenGL 3.3 Core only) * GLAD - OpenGL extensions loading (OpenGL 3.3 Core only)
* *
* Module Configuration Flags:
* GRAPHICS_API_OPENGL_11 - Use OpenGL 1.1 backend
* GRAPHICS_API_OPENGL_21 - Use OpenGL 2.1 backend
* GRAPHICS_API_OPENGL_33 - Use OpenGL 3.3 Core profile backend
* GRAPHICS_API_OPENGL_ES2 - Use OpenGL ES 2.0 backend
*
* RLGL_STANDALONE - Use rlgl as standalone library (no raylib dependency)
* RLGL_NO_DISTORTION_SHADER - Avoid stereo rendering distortion sahder (shader_distortion.h) inclusion
* RLGL_OCULUS_SUPPORT - Enable Oculus Rift CV1 functionality
* *
* LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *

133
raylib/rres.h
View file

@ -4,14 +4,18 @@
* *
* Basic functions to load/save rRES resource files * Basic functions to load/save rRES resource files
* *
* External libs: * CONFIGURATION:
*
* #define RREM_IMPLEMENTATION
* Generates the implementation of the library into the included file.
* If not defined, the library is in header only mode and can be included in other headers
* or source files without problems. But only ONE file should hold the implementation.
*
* DEPENDENCIES:
* tinfl - DEFLATE decompression functions * tinfl - DEFLATE decompression functions
* *
* Module Configuration Flags:
*
* #define RREM_IMPLEMENTATION
* Generates the implementation of the library into the included file.
* *
* LICENSE: zlib/libpng
* *
* Copyright (c) 2016-2017 Ramon Santamaria (@raysan5) * Copyright (c) 2016-2017 Ramon Santamaria (@raysan5)
* *
@ -62,7 +66,7 @@
#if defined(RRES_STANDALONE) #if defined(RRES_STANDALONE)
// rRES data returned when reading a resource, it contains all required data for user (24 byte) // rRES data returned when reading a resource, it contains all required data for user (24 byte)
// NOTE: Using void *data pointer, so we can load to image.data, wave.data, mesh.*, (unsigned char *) // NOTE: Using void *data pointer, so we can load to image.data, wave.data, mesh.*, (unsigned char *)
typedef struct { typedef struct RRESData {
unsigned int type; // Resource type (4 byte) unsigned int type; // Resource type (4 byte)
unsigned int param1; // Resouce parameter 1 (4 byte) unsigned int param1; // Resouce parameter 1 (4 byte)
@ -73,6 +77,7 @@
void *data; // Resource data pointer (4 byte) void *data; // Resource data pointer (4 byte)
} RRESData; } RRESData;
// RRESData type
typedef enum { typedef enum {
RRES_TYPE_RAW = 0, RRES_TYPE_RAW = 0,
RRES_TYPE_IMAGE, RRES_TYPE_IMAGE,
@ -80,9 +85,12 @@
RRES_TYPE_VERTEX, RRES_TYPE_VERTEX,
RRES_TYPE_TEXT, RRES_TYPE_TEXT,
RRES_TYPE_FONT_IMAGE, RRES_TYPE_FONT_IMAGE,
RRES_TYPE_FONT_DATA, // Character { int value, recX, recY, recWidth, recHeight, offsetX, offsetY, xAdvance } RRES_TYPE_FONT_CHARDATA, // Character { int value, recX, recY, recWidth, recHeight, offsetX, offsetY, xAdvance }
RRES_TYPE_DIRECTORY RRES_TYPE_DIRECTORY
} RRESDataType; } RRESDataType;
// RRES type (pointer to RRESData array)
typedef struct RRESData *RRES;
#endif #endif
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -93,9 +101,9 @@
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Declaration // Module Functions Declaration
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
RRESDEF RRESData LoadResource(const char *rresFileName); //RRESDEF RRESData LoadResourceData(const char *rresFileName, int rresId, int part);
RRESDEF RRESData LoadResourceById(const char *rresFileName, int rresId); RRESDEF RRES LoadResource(const char *fileName, int rresId);
RRESDEF void UnloadResource(RRESData rres); RRESDEF void UnloadResource(RRES rres);
#endif // RRES_H #endif // RRES_H
@ -235,24 +243,12 @@ static void *DecompressData(const unsigned char *data, unsigned long compSize, i
// Module Functions Definition // Module Functions Definition
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Load resource from file (only one) // Load resource from file by id (could be multiple parts)
// NOTE: Returns uncompressed data with parameters, only first resource found
RRESDEF RRESData LoadResource(const char *fileName)
{
// Force loading first resource available
RRESData rres = { 0 };
rres = LoadResourceById(fileName, 0);
return rres;
}
// Load resource from file by id
// NOTE: Returns uncompressed data with parameters, search resource by id // NOTE: Returns uncompressed data with parameters, search resource by id
RRESDEF RRESData LoadResourceById(const char *fileName, int rresId) RRESDEF RRES LoadResource(const char *fileName, int rresId)
{ {
RRESData rres = { 0 }; RRES rres = { 0 };
RRESFileHeader fileHeader; RRESFileHeader fileHeader;
RRESInfoHeader infoHeader; RRESInfoHeader infoHeader;
@ -280,33 +276,42 @@ RRESDEF RRESData LoadResourceById(const char *fileName, int rresId)
{ {
// Read resource info and parameters // Read resource info and parameters
fread(&infoHeader, sizeof(RRESInfoHeader), 1, rresFile); fread(&infoHeader, sizeof(RRESInfoHeader), 1, rresFile);
rres = (RRES)malloc(sizeof(RRESData)*infoHeader.partsCount);
if (infoHeader.id == rresId) if (infoHeader.id == rresId)
{ {
// Register data type and parameters // Load all required resources parts
rres.type = infoHeader.dataType; for (int k = 0; k < infoHeader.partsCount; k++)
rres.param1 = infoHeader.param1;
rres.param2 = infoHeader.param2;
rres.param3 = infoHeader.param3;
rres.param4 = infoHeader.param4;
// Read resource data block
void *data = RRES_MALLOC(infoHeader.dataSize);
fread(data, infoHeader.dataSize, 1, rresFile);
if (infoHeader.compType == RRES_COMP_DEFLATE)
{ {
void *uncompData = DecompressData(data, infoHeader.dataSize, infoHeader.uncompSize); // TODO: Verify again that rresId is the same in every part
rres.data = uncompData; // Register data type and parameters
rres[k].type = infoHeader.dataType;
RRES_FREE(data); rres[k].param1 = infoHeader.param1;
} rres[k].param2 = infoHeader.param2;
else rres.data = data; rres[k].param3 = infoHeader.param3;
rres[k].param4 = infoHeader.param4;
if (rres.data != NULL) TraceLog(INFO, "[%s][ID %i] Resource data loaded successfully", fileName, (int)infoHeader.id); // Read resource data block
void *data = RRES_MALLOC(infoHeader.dataSize);
if (rresId == 0) break; // Break for loop, do not check next resource fread(data, infoHeader.dataSize, 1, rresFile);
if (infoHeader.compType == RRES_COMP_DEFLATE)
{
void *uncompData = DecompressData(data, infoHeader.dataSize, infoHeader.uncompSize);
rres[k].data = uncompData;
RRES_FREE(data);
}
else rres[k].data = data;
if (rres[k].data != NULL) TraceLog(INFO, "[%s][ID %i] Resource data loaded successfully", fileName, (int)infoHeader.id);
// Read next part
fread(&infoHeader, sizeof(RRESInfoHeader), 1, rresFile);
}
} }
else else
{ {
@ -315,7 +320,7 @@ RRESDEF RRESData LoadResourceById(const char *fileName, int rresId)
} }
} }
if (rres.data == NULL) TraceLog(WARNING, "[%s][ID %i] Requested resource could not be found", fileName, (int)rresId); if (rres[0].data == NULL) TraceLog(WARNING, "[%s][ID %i] Requested resource could not be found", fileName, (int)rresId);
} }
fclose(rresFile); fclose(rresFile);
@ -324,9 +329,9 @@ RRESDEF RRESData LoadResourceById(const char *fileName, int rresId)
return rres; return rres;
} }
RRESDEF void UnloadResource(RRESData rres) RRESDEF void UnloadResource(RRES rres)
{ {
if (rres.data != NULL) free(rres.data); if (rres[0].data != NULL) free(rres[0].data);
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -372,7 +377,6 @@ static void *DecompressData(const unsigned char *data, unsigned long compSize, i
return uncompData; return uncompData;
} }
// Some required functions for rres standalone module version // Some required functions for rres standalone module version
#if defined(RRES_STANDALONE) #if defined(RRES_STANDALONE)
// Outputs a trace log message (INFO, ERROR, WARNING) // Outputs a trace log message (INFO, ERROR, WARNING)
@ -417,22 +421,19 @@ Mesh LoadMeshEx(rres.param1, rres.data, rres.data + offset, rres.data + offset*2
Shader LoadShader(const char *vsText, int vsLength); Shader LoadShader(const char *vsText, int vsLength);
Shader LoadShaderV(rres.data, rres.param1); Shader LoadShaderV(rres.data, rres.param1);
// Parameters information depending on resource type (IMAGE, WAVE, MESH, TEXT) // Parameters information depending on resource type
// Image data params // RRES_TYPE_IMAGE params: imgWidth, imgHeight, format, mipmaps;
int imgWidth, imgHeight; // RRES_TYPE_WAVE params: sampleCount, sampleRate, sampleSize, channels;
char colorFormat, mipmaps; // RRES_TYPE_FONT_IMAGE params: imgWidth, imgHeight, format, mipmaps;
// RRES_TYPE_FONT_DATA params: charsCount, baseSize
// RRES_TYPE_VERTEX params: vertexCount, vertexType, vertexFormat // Use masks instead?
// RRES_TYPE_TEXT params: charsCount, cultureCode
// RRES_TYPE_DIRECTORY params: fileCount, directoryCount
// Wave data params // SpriteFont = RRES_TYPE_FONT_IMAGE chunk + RRES_TYPE_FONT_DATA chunk
int sampleCount, // Mesh = multiple RRES_TYPE_VERTEX chunks
short sampleRate, bps;
char channels, reserved;
// Mesh data params Ref: RIFF file-format: http://www.johnloomis.org/cpe102/asgn/asgn1/riff.html
int vertexCount, reserved;
short vertexTypesMask, vertexFormatsMask;
// Text data params
int charsCount;
int cultureCode;
*/ */

68
raylib/shapes.c
View file

@ -1,14 +1,17 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.shapes * raylib.shapes - Basic functions to draw 2d Shapes and check collisions
* *
* Basic functions to draw 2d Shapes and check collisions * CONFIGURATION:
* *
* External libs: * #define SUPPORT_QUADS_ONLY
* rlgl - raylib OpenGL abstraction layer * Draw shapes using only QUADS, vertex are accumulated in QUADS arrays (like textures)
* *
* Module Configuration Flags: * #define SUPPORT_TRIANGLES_ONLY
* ... * Draw shapes using only TRIANGLES, vertex are accumulated in TRIANGLES arrays
*
*
* LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
@ -100,6 +103,36 @@ void DrawLineV(Vector2 startPos, Vector2 endPos, Color color)
rlEnd(); rlEnd();
} }
// Draw a line defining thickness
void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color)
{
float dx = endPos.x - startPos.x;
float dy = endPos.y - startPos.y;
float d = sqrtf(dx*dx + dy*dy);
float angle = asinf(dy/d);
rlEnableTexture(GetDefaultTexture().id);
rlPushMatrix();
rlTranslatef((float)startPos.x, (float)startPos.y, 0);
rlRotatef(-RAD2DEG*angle, 0, 0, 1);
rlTranslatef(0, -thick/2.0f, 0);
rlBegin(RL_QUADS);
rlColor4ub(color.r, color.g, color.b, color.a);
rlNormal3f(0.0f, 0.0f, 1.0f);
rlVertex2f(0.0f, 0.0f);
rlVertex2f(0.0f, thick);
rlVertex2f(d, thick);
rlVertex2f(d, 0.0f);
rlEnd();
rlPopMatrix();
rlDisableTexture();
}
// Draw a color-filled circle // Draw a color-filled circle
void DrawCircle(int centerX, int centerY, float radius, Color color) void DrawCircle(int centerX, int centerY, float radius, Color color)
{ {
@ -190,6 +223,29 @@ void DrawRectangleRec(Rectangle rec, Color color)
DrawRectangle(rec.x, rec.y, rec.width, rec.height, color); DrawRectangle(rec.x, rec.y, rec.width, rec.height, color);
} }
void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color)
{
rlEnableTexture(GetDefaultTexture().id);
rlPushMatrix();
rlTranslatef((float)rec.x, (float)rec.y, 0);
rlRotatef(rotation, 0, 0, 1);
rlTranslatef(-origin.x, -origin.y, 0);
rlBegin(RL_QUADS);
rlColor4ub(color.r, color.g, color.b, color.a);
rlNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer
rlVertex2f(0.0f, 0.0f);
rlVertex2f(0.0f, (float)rec.height);
rlVertex2f((float)rec.width, (float)rec.height);
rlVertex2f((float)rec.width, 0.0f);
rlEnd();
rlPopMatrix();
rlDisableTexture();
}
// Draw a gradient-filled rectangle // Draw a gradient-filled rectangle
// NOTE: Gradient goes from bottom (color1) to top (color2) // NOTE: Gradient goes from bottom (color1) to top (color2)
void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2) void DrawRectangleGradient(int posX, int posY, int width, int height, Color color1, Color color2)

18
raylib/shapes.go
View file

@ -40,6 +40,15 @@ func DrawLineV(startPos Vector2, endPos Vector2, color Color) {
C.DrawLineV(*cstartPos, *cendPos, *ccolor) C.DrawLineV(*cstartPos, *cendPos, *ccolor)
} }
// DrawLineEx - Draw a line defining thickness
func DrawLineEx(startPos Vector2, endPos Vector2, thick float32, color Color) {
cstartPos := startPos.cptr()
cendPos := endPos.cptr()
cthick := (C.float)(thick)
ccolor := color.cptr()
C.DrawLineEx(*cstartPos, *cendPos, cthick, *ccolor)
}
// DrawCircle - Draw a color-filled circle // DrawCircle - Draw a color-filled circle
func DrawCircle(centerX int32, centerY int32, radius float32, color Color) { func DrawCircle(centerX int32, centerY int32, radius float32, color Color) {
ccenterX := (C.int)(centerX) ccenterX := (C.int)(centerX)
@ -93,6 +102,15 @@ func DrawRectangleRec(rec Rectangle, color Color) {
C.DrawRectangleRec(*crec, *ccolor) C.DrawRectangleRec(*crec, *ccolor)
} }
// DrawRectanglePro - Draw a color-filled rectangle with pro parameters
func DrawRectanglePro(rec Rectangle, origin Vector2, rotation float32, color Color) {
crec := rec.cptr()
corigin := origin.cptr()
crotation := (C.float)(rotation)
ccolor := color.cptr()
C.DrawRectanglePro(*crec, *corigin, crotation, *ccolor)
}
// DrawRectangleGradient - Draw a gradient-filled rectangle // DrawRectangleGradient - Draw a gradient-filled rectangle
func DrawRectangleGradient(posX int32, posY int32, width int32, height int32, color1 Color, color2 Color) { func DrawRectangleGradient(posX int32, posY int32, width int32, height int32, color1 Color, color2 Color) {
cposX := (C.int)(posX) cposX := (C.int)(posX)

393
raylib/stb_vorbis.h
View file

@ -1,393 +0,0 @@
// Ogg Vorbis audio decoder - v1.09 - public domain
// http://nothings.org/stb_vorbis/
//
// Original version written by Sean Barrett in 2007.
//
// Originally sponsored by RAD Game Tools. Seeking sponsored
// by Phillip Bennefall, Marc Andersen, Aaron Baker, Elias Software,
// Aras Pranckevicius, and Sean Barrett.
//
// LICENSE
//
// This software is dual-licensed to the public domain and under the following
// license: you are granted a perpetual, irrevocable license to copy, modify,
// publish, and distribute this file as you see fit.
//
// No warranty for any purpose is expressed or implied by the author (nor
// by RAD Game Tools). Report bugs and send enhancements to the author.
//
// Limitations:
//
// - floor 0 not supported (used in old ogg vorbis files pre-2004)
// - lossless sample-truncation at beginning ignored
// - cannot concatenate multiple vorbis streams
// - sample positions are 32-bit, limiting seekable 192Khz
// files to around 6 hours (Ogg supports 64-bit)
//
// Feature contributors:
// Dougall Johnson (sample-exact seeking)
//
// Bugfix/warning contributors:
// Terje Mathisen Niklas Frykholm Andy Hill
// Casey Muratori John Bolton Gargaj
// Laurent Gomila Marc LeBlanc Ronny Chevalier
// Bernhard Wodo Evan Balster alxprd@github
// Tom Beaumont Ingo Leitgeb Nicolas Guillemot
// Phillip Bennefall Rohit Thiago Goulart
// manxorist@github saga musix
//
// Partial history:
// 1.09 - 2016/04/04 - back out 'truncation of last frame' fix from previous version
// 1.08 - 2016/04/02 - warnings; setup memory leaks; truncation of last frame
// 1.07 - 2015/01/16 - fixes for crashes on invalid files; warning fixes; const
// 1.06 - 2015/08/31 - full, correct support for seeking API (Dougall Johnson)
// some crash fixes when out of memory or with corrupt files
// fix some inappropriately signed shifts
// 1.05 - 2015/04/19 - don't define __forceinline if it's redundant
// 1.04 - 2014/08/27 - fix missing const-correct case in API
// 1.03 - 2014/08/07 - warning fixes
// 1.02 - 2014/07/09 - declare qsort comparison as explicitly _cdecl in Windows
// 1.01 - 2014/06/18 - fix stb_vorbis_get_samples_float (interleaved was correct)
// 1.0 - 2014/05/26 - fix memory leaks; fix warnings; fix bugs in >2-channel;
// (API change) report sample rate for decode-full-file funcs
//
// See end of file for full version history.
//////////////////////////////////////////////////////////////////////////////
//
// HEADER BEGINS HERE
//
#ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
#define STB_VORBIS_INCLUDE_STB_VORBIS_H
#if defined(STB_VORBIS_NO_CRT) && !defined(STB_VORBIS_NO_STDIO)
#define STB_VORBIS_NO_STDIO 1
#endif
#ifndef STB_VORBIS_NO_STDIO
#include <stdio.h>
#endif
// NOTE: Added to work with raylib on Android
#if defined(PLATFORM_ANDROID)
#include "utils.h" // Android fopen function map
#endif
#ifdef __cplusplus
extern "C" {
#endif
/////////// THREAD SAFETY
// Individual stb_vorbis* handles are not thread-safe; you cannot decode from
// them from multiple threads at the same time. However, you can have multiple
// stb_vorbis* handles and decode from them independently in multiple thrads.
/////////// MEMORY ALLOCATION
// normally stb_vorbis uses malloc() to allocate memory at startup,
// and alloca() to allocate temporary memory during a frame on the
// stack. (Memory consumption will depend on the amount of setup
// data in the file and how you set the compile flags for speed
// vs. size. In my test files the maximal-size usage is ~150KB.)
//
// You can modify the wrapper functions in the source (setup_malloc,
// setup_temp_malloc, temp_malloc) to change this behavior, or you
// can use a simpler allocation model: you pass in a buffer from
// which stb_vorbis will allocate _all_ its memory (including the
// temp memory). "open" may fail with a VORBIS_outofmem if you
// do not pass in enough data; there is no way to determine how
// much you do need except to succeed (at which point you can
// query get_info to find the exact amount required. yes I know
// this is lame).
//
// If you pass in a non-NULL buffer of the type below, allocation
// will occur from it as described above. Otherwise just pass NULL
// to use malloc()/alloca()
typedef struct
{
char *alloc_buffer;
int alloc_buffer_length_in_bytes;
} stb_vorbis_alloc;
/////////// FUNCTIONS USEABLE WITH ALL INPUT MODES
typedef struct stb_vorbis stb_vorbis;
typedef struct
{
unsigned int sample_rate;
int channels;
unsigned int setup_memory_required;
unsigned int setup_temp_memory_required;
unsigned int temp_memory_required;
int max_frame_size;
} stb_vorbis_info;
// get general information about the file
extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f);
// get the last error detected (clears it, too)
extern int stb_vorbis_get_error(stb_vorbis *f);
// close an ogg vorbis file and free all memory in use
extern void stb_vorbis_close(stb_vorbis *f);
// this function returns the offset (in samples) from the beginning of the
// file that will be returned by the next decode, if it is known, or -1
// otherwise. after a flush_pushdata() call, this may take a while before
// it becomes valid again.
// NOT WORKING YET after a seek with PULLDATA API
extern int stb_vorbis_get_sample_offset(stb_vorbis *f);
// returns the current seek point within the file, or offset from the beginning
// of the memory buffer. In pushdata mode it returns 0.
extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f);
/////////// PUSHDATA API
#ifndef STB_VORBIS_NO_PUSHDATA_API
// this API allows you to get blocks of data from any source and hand
// them to stb_vorbis. you have to buffer them; stb_vorbis will tell
// you how much it used, and you have to give it the rest next time;
// and stb_vorbis may not have enough data to work with and you will
// need to give it the same data again PLUS more. Note that the Vorbis
// specification does not bound the size of an individual frame.
extern stb_vorbis *stb_vorbis_open_pushdata(
const unsigned char * datablock, int datablock_length_in_bytes,
int *datablock_memory_consumed_in_bytes,
int *error,
const stb_vorbis_alloc *alloc_buffer);
// create a vorbis decoder by passing in the initial data block containing
// the ogg&vorbis headers (you don't need to do parse them, just provide
// the first N bytes of the file--you're told if it's not enough, see below)
// on success, returns an stb_vorbis *, does not set error, returns the amount of
// data parsed/consumed on this call in *datablock_memory_consumed_in_bytes;
// on failure, returns NULL on error and sets *error, does not change *datablock_memory_consumed
// if returns NULL and *error is VORBIS_need_more_data, then the input block was
// incomplete and you need to pass in a larger block from the start of the file
extern int stb_vorbis_decode_frame_pushdata(
stb_vorbis *f,
const unsigned char *datablock, int datablock_length_in_bytes,
int *channels, // place to write number of float * buffers
float ***output, // place to write float ** array of float * buffers
int *samples // place to write number of output samples
);
// decode a frame of audio sample data if possible from the passed-in data block
//
// return value: number of bytes we used from datablock
//
// possible cases:
// 0 bytes used, 0 samples output (need more data)
// N bytes used, 0 samples output (resynching the stream, keep going)
// N bytes used, M samples output (one frame of data)
// note that after opening a file, you will ALWAYS get one N-bytes,0-sample
// frame, because Vorbis always "discards" the first frame.
//
// Note that on resynch, stb_vorbis will rarely consume all of the buffer,
// instead only datablock_length_in_bytes-3 or less. This is because it wants
// to avoid missing parts of a page header if they cross a datablock boundary,
// without writing state-machiney code to record a partial detection.
//
// The number of channels returned are stored in *channels (which can be
// NULL--it is always the same as the number of channels reported by
// get_info). *output will contain an array of float* buffers, one per
// channel. In other words, (*output)[0][0] contains the first sample from
// the first channel, and (*output)[1][0] contains the first sample from
// the second channel.
extern void stb_vorbis_flush_pushdata(stb_vorbis *f);
// inform stb_vorbis that your next datablock will not be contiguous with
// previous ones (e.g. you've seeked in the data); future attempts to decode
// frames will cause stb_vorbis to resynchronize (as noted above), and
// once it sees a valid Ogg page (typically 4-8KB, as large as 64KB), it
// will begin decoding the _next_ frame.
//
// if you want to seek using pushdata, you need to seek in your file, then
// call stb_vorbis_flush_pushdata(), then start calling decoding, then once
// decoding is returning you data, call stb_vorbis_get_sample_offset, and
// if you don't like the result, seek your file again and repeat.
#endif
////////// PULLING INPUT API
#ifndef STB_VORBIS_NO_PULLDATA_API
// This API assumes stb_vorbis is allowed to pull data from a source--
// either a block of memory containing the _entire_ vorbis stream, or a
// FILE * that you or it create, or possibly some other reading mechanism
// if you go modify the source to replace the FILE * case with some kind
// of callback to your code. (But if you don't support seeking, you may
// just want to go ahead and use pushdata.)
#if !defined(STB_VORBIS_NO_STDIO) && !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
extern int stb_vorbis_decode_filename(const char *filename, int *channels, int *sample_rate, short **output);
#endif
#if !defined(STB_VORBIS_NO_INTEGER_CONVERSION)
extern int stb_vorbis_decode_memory(const unsigned char *mem, int len, int *channels, int *sample_rate, short **output);
#endif
// decode an entire file and output the data interleaved into a malloc()ed
// buffer stored in *output. The return value is the number of samples
// decoded, or -1 if the file could not be opened or was not an ogg vorbis file.
// When you're done with it, just free() the pointer returned in *output.
extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len,
int *error, const stb_vorbis_alloc *alloc_buffer);
// create an ogg vorbis decoder from an ogg vorbis stream in memory (note
// this must be the entire stream!). on failure, returns NULL and sets *error
#ifndef STB_VORBIS_NO_STDIO
extern stb_vorbis * stb_vorbis_open_filename(const char *filename,
int *error, const stb_vorbis_alloc *alloc_buffer);
// create an ogg vorbis decoder from a filename via fopen(). on failure,
// returns NULL and sets *error (possibly to VORBIS_file_open_failure).
extern stb_vorbis * stb_vorbis_open_file(FILE *f, int close_handle_on_close,
int *error, const stb_vorbis_alloc *alloc_buffer);
// create an ogg vorbis decoder from an open FILE *, looking for a stream at
// the _current_ seek point (ftell). on failure, returns NULL and sets *error.
// note that stb_vorbis must "own" this stream; if you seek it in between
// calls to stb_vorbis, it will become confused. Morever, if you attempt to
// perform stb_vorbis_seek_*() operations on this file, it will assume it
// owns the _entire_ rest of the file after the start point. Use the next
// function, stb_vorbis_open_file_section(), to limit it.
extern stb_vorbis * stb_vorbis_open_file_section(FILE *f, int close_handle_on_close,
int *error, const stb_vorbis_alloc *alloc_buffer, unsigned int len);
// create an ogg vorbis decoder from an open FILE *, looking for a stream at
// the _current_ seek point (ftell); the stream will be of length 'len' bytes.
// on failure, returns NULL and sets *error. note that stb_vorbis must "own"
// this stream; if you seek it in between calls to stb_vorbis, it will become
// confused.
#endif
extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number);
extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number);
// these functions seek in the Vorbis file to (approximately) 'sample_number'.
// after calling seek_frame(), the next call to get_frame_*() will include
// the specified sample. after calling stb_vorbis_seek(), the next call to
// stb_vorbis_get_samples_* will start with the specified sample. If you
// do not need to seek to EXACTLY the target sample when using get_samples_*,
// you can also use seek_frame().
extern void stb_vorbis_seek_start(stb_vorbis *f);
// this function is equivalent to stb_vorbis_seek(f,0)
extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f);
extern float stb_vorbis_stream_length_in_seconds(stb_vorbis *f);
// these functions return the total length of the vorbis stream
extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output);
// decode the next frame and return the number of samples. the number of
// channels returned are stored in *channels (which can be NULL--it is always
// the same as the number of channels reported by get_info). *output will
// contain an array of float* buffers, one per channel. These outputs will
// be overwritten on the next call to stb_vorbis_get_frame_*.
//
// You generally should not intermix calls to stb_vorbis_get_frame_*()
// and stb_vorbis_get_samples_*(), since the latter calls the former.
#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
extern int stb_vorbis_get_frame_short_interleaved(stb_vorbis *f, int num_c, short *buffer, int num_shorts);
extern int stb_vorbis_get_frame_short (stb_vorbis *f, int num_c, short **buffer, int num_samples);
#endif
// decode the next frame and return the number of *samples* per channel.
// Note that for interleaved data, you pass in the number of shorts (the
// size of your array), but the return value is the number of samples per
// channel, not the total number of samples.
//
// The data is coerced to the number of channels you request according to the
// channel coercion rules (see below). You must pass in the size of your
// buffer(s) so that stb_vorbis will not overwrite the end of the buffer.
// The maximum buffer size needed can be gotten from get_info(); however,
// the Vorbis I specification implies an absolute maximum of 4096 samples
// per channel.
// Channel coercion rules:
// Let M be the number of channels requested, and N the number of channels present,
// and Cn be the nth channel; let stereo L be the sum of all L and center channels,
// and stereo R be the sum of all R and center channels (channel assignment from the
// vorbis spec).
// M N output
// 1 k sum(Ck) for all k
// 2 * stereo L, stereo R
// k l k > l, the first l channels, then 0s
// k l k <= l, the first k channels
// Note that this is not _good_ surround etc. mixing at all! It's just so
// you get something useful.
extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats);
extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples);
// gets num_samples samples, not necessarily on a frame boundary--this requires
// buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES.
// Returns the number of samples stored per channel; it may be less than requested
// at the end of the file. If there are no more samples in the file, returns 0.
#ifndef STB_VORBIS_NO_INTEGER_CONVERSION
extern int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short *buffer, int num_shorts);
extern int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, int num_samples);
#endif
// gets num_samples samples, not necessarily on a frame boundary--this requires
// buffering so you have to supply the buffers. Applies the coercion rules above
// to produce 'channels' channels. Returns the number of samples stored per channel;
// it may be less than requested at the end of the file. If there are no more
// samples in the file, returns 0.
#endif
//////// ERROR CODES
enum STBVorbisError
{
VORBIS__no_error,
VORBIS_need_more_data=1, // not a real error
VORBIS_invalid_api_mixing, // can't mix API modes
VORBIS_outofmem, // not enough memory
VORBIS_feature_not_supported, // uses floor 0
VORBIS_too_many_channels, // STB_VORBIS_MAX_CHANNELS is too small
VORBIS_file_open_failure, // fopen() failed
VORBIS_seek_without_length, // can't seek in unknown-length file
VORBIS_unexpected_eof=10, // file is truncated?
VORBIS_seek_invalid, // seek past EOF
// decoding errors (corrupt/invalid stream) -- you probably
// don't care about the exact details of these
// vorbis errors:
VORBIS_invalid_setup=20,
VORBIS_invalid_stream,
// ogg errors:
VORBIS_missing_capture_pattern=30,
VORBIS_invalid_stream_structure_version,
VORBIS_continued_packet_flag_invalid,
VORBIS_incorrect_stream_serial_number,
VORBIS_invalid_first_page,
VORBIS_bad_packet_type,
VORBIS_cant_find_last_page,
VORBIS_seek_failed
};
#ifdef __cplusplus
}
#endif
#endif // STB_VORBIS_INCLUDE_STB_VORBIS_H
//
// HEADER ENDS HERE
//
//////////////////////////////////////////////////////////////////////////////

52
raylib/text.c
View file

@ -1,14 +1,22 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.text * raylib.text - Basic functions to load SpriteFonts and draw Text
* *
* Basic functions to load SpriteFonts and draw Text * CONFIGURATION:
* *
* External libs: * #define SUPPORT_FILEFORMAT_FNT
* #define SUPPORT_FILEFORMAT_TTF / INCLUDE_STB_TRUETYPE
* #define SUPPORT_FILEFORMAT_IMAGE_FONT
* Selected desired fileformats to be supported for loading. Some of those formats are
* supported by default, to remove support, just comment unrequired #define in this module
*
* #define INCLUDE_DEFAULT_FONT / SUPPORT_DEFAULT_FONT
*
* DEPENDENCIES:
* stb_truetype - Load TTF file and rasterize characters data * stb_truetype - Load TTF file and rasterize characters data
* *
* Module Configuration Flags: *
* ... * LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
@ -262,30 +270,28 @@ SpriteFont LoadSpriteFont(const char *fileName)
else if (strcmp(GetExtension(fileName),"rres") == 0) else if (strcmp(GetExtension(fileName),"rres") == 0)
{ {
// TODO: Read multiple resource blocks from file (RRES_FONT_IMAGE, RRES_FONT_CHARDATA) // TODO: Read multiple resource blocks from file (RRES_FONT_IMAGE, RRES_FONT_CHARDATA)
RRESData rres = LoadResource(fileName); RRES rres = LoadResource(fileName, 0);
// Load sprite font texture // Load sprite font texture
/* if (rres[0].type == RRES_TYPE_FONT_IMAGE)
if (rres.type == RRES_FONT_IMAGE)
{ {
// NOTE: Parameters for RRES_FONT_IMAGE type are: width, height, format, mipmaps // NOTE: Parameters for RRES_FONT_IMAGE type are: width, height, format, mipmaps
Image image = LoadImagePro(rres.data, rres.param1, rres.param2, rres.param3); Image image = LoadImagePro(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3);
spriteFont.texture = LoadTextureFromImage(image); spriteFont.texture = LoadTextureFromImage(image);
UnloadImage(image); UnloadImage(image);
} }
// Load sprite characters data // Load sprite characters data
if (rres.type == RRES_FONT_CHARDATA) if (rres[1].type == RRES_TYPE_FONT_CHARDATA)
{ {
// NOTE: Parameters for RRES_FONT_CHARDATA type are: fontSize, charsCount // NOTE: Parameters for RRES_FONT_CHARDATA type are: fontSize, charsCount
spriteFont.baseSize = rres.param1; spriteFont.baseSize = rres[1].param1;
spriteFont.charsCount = rres.param2; spriteFont.charsCount = rres[1].param2;
spriteFont.chars = rres.data; spriteFont.chars = rres[1].data;
} }
*/
// TODO: Do not free rres.data memory (chars info data!) // TODO: Do not free rres.data memory (chars info data!)
UnloadResource(rres); //UnloadResource(rres[0]);
} }
else else
{ {
@ -525,8 +531,22 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, float fontSize, i
// NOTE: Uses default font // NOTE: Uses default font
void DrawFPS(int posX, int posY) void DrawFPS(int posX, int posY)
{ {
// NOTE: We are rendering fps every second for better viewing on high framerates
static int fps = 0;
static int counter = 0;
static int refreshRate = 20;
if (counter < refreshRate) counter++;
else
{
fps = GetFPS();
refreshRate = fps;
counter = 0;
}
// NOTE: We have rounding errors every frame, so it oscillates a lot // NOTE: We have rounding errors every frame, so it oscillates a lot
DrawText(FormatText("%2i FPS", GetFPS()), posX, posY, 20, LIME); DrawText(FormatText("%2i FPS", fps), posX, posY, 20, LIME);
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------

35
raylib/textures.c
View file

@ -1,16 +1,35 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.textures * raylib.textures - Basic functions to load and draw Textures (2d)
* *
* Basic functions to load and draw Textures (2d) * CONFIGURATION:
* *
* External libs: * #define SUPPORT_STB_IMAGE / INCLUDE_STB_IMAGE
*
* #define SUPPORT_FILEFORMAT_BMP / SUPPORT_LOAD_BMP
* #define SUPPORT_FILEFORMAT_PNG / SUPPORT_LOAD_PNG
* #define SUPPORT_FILEFORMAT_TGA
* #define SUPPORT_FILEFORMAT_JPG / ENABLE_LOAD_JPG
* #define SUPPORT_FILEFORMAT_GIF
* #define SUPPORT_FILEFORMAT_HDR
* #define SUPPORT_FILEFORMAT_DDS / ENABLE_LOAD_DDS
* #define SUPPORT_FILEFORMAT_PKM
* #define SUPPORT_FILEFORMAT_KTX
* #define SUPPORT_FILEFORMAT_PVR
* #define SUPPORT_FILEFORMAT_ASTC
* Selected desired fileformats to be supported for loading. Some of those formats are
* supported by default, to remove support, just comment unrequired #define in this module
*
* #define SUPPORT_IMAGE_RESIZE / INCLUDE_STB_IMAGE_RESIZE
* #define SUPPORT_IMAGE_MANIPULATION
*
* DEPENDENCIES:
* stb_image - Multiple image formats loading (JPEG, PNG, BMP, TGA, PSD, GIF, PIC) * stb_image - Multiple image formats loading (JPEG, PNG, BMP, TGA, PSD, GIF, PIC)
* NOTE: stb_image has been slightly modified to support Android platform. * NOTE: stb_image has been slightly modified to support Android platform.
* stb_image_resize - Multiple image resize algorythms * stb_image_resize - Multiple image resize algorythms
* *
* Module Configuration Flags: *
* ... * LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *
@ -143,11 +162,11 @@ Image LoadImage(const char *fileName)
else if (strcmp(GetExtension(fileName),"astc") == 0) image = LoadASTC(fileName); else if (strcmp(GetExtension(fileName),"astc") == 0) image = LoadASTC(fileName);
else if (strcmp(GetExtension(fileName),"rres") == 0) else if (strcmp(GetExtension(fileName),"rres") == 0)
{ {
RRESData rres = LoadResource(fileName); RRES rres = LoadResource(fileName, 0);
// NOTE: Parameters for RRES_IMAGE type are: width, height, format, mipmaps // NOTE: Parameters for RRES_TYPE_IMAGE are: width, height, format, mipmaps
if (rres.type == RRES_IMAGE) image = LoadImagePro(rres.data, rres.param1, rres.param2, rres.param3); if (rres[0].type == RRES_TYPE_IMAGE) image = LoadImagePro(rres[0].data, rres[0].param1, rres[0].param2, rres[0].param3);
else TraceLog(WARNING, "[%s] Resource file does not contain image data", fileName); else TraceLog(WARNING, "[%s] Resource file does not contain image data", fileName);
UnloadResource(rres); UnloadResource(rres);

19
raylib/utils.c
View file

@ -1,16 +1,23 @@
/********************************************************************************************** /**********************************************************************************************
* *
* raylib.utils * raylib.utils - Some common utility functions
* *
* Some utility functions * CONFIGURATION:
* *
* External libs: * #define SUPPORT_SAVE_PNG
* tinfl - zlib DEFLATE algorithm decompression * Enable saving PNG fileformat
* NOTE: Requires stb_image_write library
*
* #define SUPPORT_SAVE_BMP
*
* #define DO_NOT_TRACE_DEBUG_MSGS
* Avoid showing DEBUG TraceLog() messages
*
* DEPENDENCIES:
* stb_image_write - PNG writting functions * stb_image_write - PNG writting functions
* *
* Module Configuration Flags:
* DO_NOT_TRACE_DEBUG_MSGS - Avoid showing DEBUG TraceLog() messages
* *
* LICENSE: zlib/libpng
* *
* Copyright (c) 2014-2016 Ramon Santamaria (@raysan5) * Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
* *