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

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

Browse source
This commit is contained in:
Joshua Reisenauer 2016-06-02 13:43:11 -07:00
commit 96fa716525
14 changed files with 371 additions and 390 deletions
Download patch file Download diff file Expand all files Collapse all files

51
examples/oculus_glfw_sample/oculus_glfw_sample.c
View file

@ -30,7 +30,7 @@
#define RLGL_STANDALONE #define RLGL_STANDALONE
#include "rlgl.h" #include "rlgl.h"
//#define PLATFORM_OCULUS #define PLATFORM_OCULUS
#if defined(PLATFORM_OCULUS) #if defined(PLATFORM_OCULUS)
#include "OculusSDK/LibOVR/Include/OVR_CAPI_GL.h" // Oculus SDK for OpenGL #include "OculusSDK/LibOVR/Include/OVR_CAPI_GL.h" // Oculus SDK for OpenGL
@ -72,7 +72,7 @@ typedef struct OculusMirror {
typedef struct OculusLayer { typedef struct OculusLayer {
ovrViewScaleDesc viewScaleDesc; ovrViewScaleDesc viewScaleDesc;
ovrLayerEyeFov eyeLayer; // layer 0 ovrLayerEyeFov eyeLayer; // layer 0
//ovrLayerQuad quadLayer; // layer 1 //ovrLayerQuad quadLayer; // TODO: layer 1: '2D' quad for GUI
Matrix eyeProjections[2]; Matrix eyeProjections[2];
int width; int width;
int height; int height;
@ -222,6 +222,7 @@ int main(void)
layer.eyeLayer.RenderPose[0] = eyePoses[0]; layer.eyeLayer.RenderPose[0] = eyePoses[0];
layer.eyeLayer.RenderPose[1] = eyePoses[1]; layer.eyeLayer.RenderPose[1] = eyePoses[1];
#endif #endif
Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -229,13 +230,12 @@ int main(void)
#if defined(PLATFORM_OCULUS) #if defined(PLATFORM_OCULUS)
SetOculusBuffer(session, buffer); SetOculusBuffer(session, buffer);
#endif #endif
rlClearScreenBuffers(); // Clear current framebuffer(s)
rlClearScreenBuffers(); // Clear current framebuffers
#if defined(PLATFORM_OCULUS) #if defined(PLATFORM_OCULUS)
for (int eye = 0; eye < 2; eye++) for (int eye = 0; eye < 2; eye++)
{ {
glViewport(layer.eyeLayer.Viewport[eye].Pos.x, layer.eyeLayer.Viewport[eye].Pos.y, layer.eyeLayer.Viewport[eye].Size.w, layer.eyeLayer.Viewport[eye].Size.h); rlViewport(layer.eyeLayer.Viewport[eye].Pos.x, layer.eyeLayer.Viewport[eye].Pos.y, layer.eyeLayer.Viewport[eye].Size.w, layer.eyeLayer.Viewport[eye].Size.h);
Quaternion eyeRPose = (Quaternion){ eyePoses[eye].Orientation.x, eyePoses[eye].Orientation.y, eyePoses[eye].Orientation.z, eyePoses[eye].Orientation.w }; Quaternion eyeRPose = (Quaternion){ eyePoses[eye].Orientation.x, eyePoses[eye].Orientation.y, eyePoses[eye].Orientation.z, eyePoses[eye].Orientation.w };
QuaternionInvert(&eyeRPose); QuaternionInvert(&eyeRPose);
@ -244,32 +244,39 @@ int main(void)
Matrix eyeView = MatrixMultiply(eyeTranslation, eyeOrientation); Matrix eyeView = MatrixMultiply(eyeTranslation, eyeOrientation);
Matrix modelview = MatrixMultiply(matView, eyeView); Matrix modelview = MatrixMultiply(matView, eyeView);
Matrix mvp = MatrixMultiply(modelview, layer.eyeProjections[eye]); //Matrix mvp = MatrixMultiply(modelview, layer.eyeProjections[eye]);
SetMatrixModelview(modelview);
SetMatrixProjection(layer.eyeProjections[eye]);
#else #else
// Calculate projection matrix (from perspective) and view matrix from camera look at // Calculate projection matrix (from perspective) and view matrix from camera look at
Matrix matProj = MatrixPerspective(camera.fovy, (double)screenWidth/(double)screenHeight, 0.01, 1000.0); Matrix matProj = MatrixPerspective(camera.fovy, (double)screenWidth/(double)screenHeight, 0.01, 1000.0);
MatrixTranspose(&matProj); MatrixTranspose(&matProj);
Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
Matrix mvp = MatrixMultiply(matView, matProj); SetMatrixModelview(matView); // Replace internal modelview matrix by a custom one
SetMatrixProjection(matProj); // Replace internal projection matrix by a custom one
#endif #endif
DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED); DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE); DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE);
DrawGrid(10, 1.0f); DrawGrid(10, 1.0f);
// NOTE: Internal buffers drawing (3D data) // NOTE: Internal buffers drawing (3D data)
rlglDraw(mvp); rlglDraw();
matProj = MatrixOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0);
MatrixTranspose(&matProj);
matView = MatrixIdentity();
mvp = MatrixMultiply(matView, matProj);
#if !defined(PLATFORM_OCULUS)
// Draw '2D' elements in the scene (GUI)
// TODO: 2D drawing on Oculus Rift: requires an ovrLayerQuad layer // TODO: 2D drawing on Oculus Rift: requires an ovrLayerQuad layer
DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 300.0f, 20.0f }, DARKGRAY); rlMatrixMode(RL_PROJECTION); // Enable internal projection matrix
rlLoadIdentity(); // Reset internal projection matrix
rlOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0); // Recalculate internal projection matrix
rlMatrixMode(RL_MODELVIEW); // Enable internal modelview matrix
rlLoadIdentity(); // Reset internal modelview matrix
DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 600.0f, 20.0f }, DARKGRAY);
// NOTE: Internal buffers drawing (2D data) // NOTE: Internal buffers drawing (2D data)
rlglDraw(mvp); rlglDraw();
#endif
#if defined(PLATFORM_OCULUS) #if defined(PLATFORM_OCULUS)
} }
@ -593,14 +600,12 @@ static OculusBuffer LoadOculusBuffer(ovrSession session, int width, int height)
desc.Width = width; desc.Width = width;
desc.Height = height; desc.Height = height;
desc.MipLevels = 1; desc.MipLevels = 1;
desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB; desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB; // Requires glEnable(GL_FRAMEBUFFER_SRGB);
desc.SampleCount = 1; desc.SampleCount = 1;
desc.StaticImage = ovrFalse; desc.StaticImage = ovrFalse;
ovrResult result = ovr_CreateTextureSwapChainGL(session, &desc, &buffer.textureChain); ovrResult result = ovr_CreateTextureSwapChainGL(session, &desc, &buffer.textureChain);
//eyeLayer.ColorTexture[0] = buffer.textureChain; // <------------------- ???
if (!OVR_SUCCESS(result)) TraceLog(LOG_WARNING, "OVR: Failed to create swap textures buffer"); if (!OVR_SUCCESS(result)) TraceLog(LOG_WARNING, "OVR: Failed to create swap textures buffer");
int textureCount = 0; int textureCount = 0;
@ -672,9 +677,11 @@ static void SetOculusBuffer(ovrSession session, OculusBuffer buffer)
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, currentTexId, 0); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, currentTexId, 0);
//glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, buffer.depthId, 0); // Already binded //glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, buffer.depthId, 0); // Already binded
//glViewport(0, 0, buffer.width, buffer.height); //glViewport(0, 0, buffer.width, buffer.height); // Useful if rendering to separate framebuffers (every eye)
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glEnable(GL_FRAMEBUFFER_SRGB);
// Required if OculusBuffer format is OVR_FORMAT_R8G8B8A8_UNORM_SRGB
glEnable(GL_FRAMEBUFFER_SRGB);
} }
// Unset Oculus buffer // Unset Oculus buffer

80
examples/oculus_glfw_sample/rlgl.c
View file

@ -28,40 +28,38 @@
#include "rlgl.h" #include "rlgl.h"
#include <stdio.h> // Standard input / output lib #include <stdio.h> // Required for: fopen(), fclose(), fread()... [Used only on ReadTextFile()]
#include <stdlib.h> // Declares malloc() and free() for memory management, rand() #include <stdlib.h> // Required for: malloc(), free(), rand()
#include <string.h> // Declares strcmp(), strlen(), strtok() #include <string.h> // Required for: strcmp(), strlen(), strtok()
#ifndef RLGL_STANDALONE #ifndef RLGL_STANDALONE
#include "raymath.h" // Required for Vector3 and Matrix functions #include "raymath.h" // Required for Vector3 and Matrix functions
#endif #endif
#if defined(GRAPHICS_API_OPENGL_11) #if defined(GRAPHICS_API_OPENGL_11)
#ifdef __APPLE__ // OpenGL include for OSX #ifdef __APPLE__
#include <OpenGL/gl.h> #include <OpenGL/gl.h> // OpenGL 1.1 library for OSX
#else #else
#include <GL/gl.h> // Basic OpenGL include #include <GL/gl.h> // OpenGL 1.1 library
#endif #endif
#endif #endif
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_33)
#ifdef __APPLE__ // OpenGL include for OSX #ifdef __APPLE__
#include <OpenGL/gl3.h> #include <OpenGL/gl3.h> // OpenGL 3 library for OSX
#else #else
//#define GLEW_STATIC #include "glad.h" // GLAD library, includes OpenGL headers
//#include <GL/glew.h> // GLEW header, includes OpenGL headers
#include "glad.h" // glad header, includes OpenGL headers
#endif #endif
#endif #endif
#if defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_ES2)
#include <EGL/egl.h> #include <EGL/egl.h> // EGL library
#include <GLES2/gl2.h> #include <GLES2/gl2.h> // OpenGL ES 2.0 library
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h> // OpenGL ES 2.0 extensions library
#endif #endif
#if defined(RLGL_STANDALONE) #if defined(RLGL_STANDALONE)
#include <stdarg.h> // Used for functions with variable number of parameters (TraceLog()) #include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() [Used only on TraceLog()]
#endif #endif
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -171,7 +169,6 @@ static Matrix modelview;
static Matrix projection; static Matrix projection;
static Matrix *currentMatrix; static Matrix *currentMatrix;
static int currentMatrixMode; static int currentMatrixMode;
static Matrix customMVP;
static DrawMode currentDrawMode; static DrawMode currentDrawMode;
@ -913,8 +910,8 @@ void rlglInit(void)
vaoSupported = true; vaoSupported = true;
npotSupported = true; npotSupported = true;
// NOTE: We don't need to check again supported extensions but we do (in case GLEW is replaced sometime)
// We get a list of available extensions and we check for some of them (compressed textures) // We get a list of available extensions and we check for some of them (compressed textures)
// NOTE: We don't need to check again supported extensions but we do (GLAD already dealt with that)
glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
const char *extList[numExt]; const char *extList[numExt];
@ -1083,10 +1080,8 @@ void rlglClose(void)
} }
// Drawing batches: triangles, quads, lines // Drawing batches: triangles, quads, lines
void rlglDraw(Matrix mvp) void rlglDraw(void)
{ {
customMVP = mvp;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
/* /*
for (int i = 0; i < modelsCount; i++) for (int i = 0; i < modelsCount; i++)
@ -1548,10 +1543,10 @@ void rlglLoadMesh(Mesh *mesh, bool dynamic)
mesh->vboId[5] = 0; // Vertex texcoords2 VBO mesh->vboId[5] = 0; // Vertex texcoords2 VBO
mesh->vboId[6] = 0; // Vertex indices VBO mesh->vboId[6] = 0; // Vertex indices VBO
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
int drawHint = GL_STATIC_DRAW; int drawHint = GL_STATIC_DRAW;
if (dynamic) drawHint = GL_DYNAMIC_DRAW; if (dynamic) drawHint = GL_DYNAMIC_DRAW;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
GLuint vaoId = 0; // Vertex Array Objects (VAO) GLuint vaoId = 0; // Vertex Array Objects (VAO)
GLuint vboId[7]; // Vertex Buffer Objects (VBOs) GLuint vboId[7]; // Vertex Buffer Objects (VBOs)
@ -1677,6 +1672,7 @@ void rlglLoadMesh(Mesh *mesh, bool dynamic)
// Update vertex data on GPU (upload new data to one buffer) // Update vertex data on GPU (upload new data to one buffer)
void rlglUpdateMesh(Mesh mesh, int buffer, int numVertex) void rlglUpdateMesh(Mesh mesh, int buffer, int numVertex)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Activate mesh VAO // Activate mesh VAO
if (vaoSupported) glBindVertexArray(mesh.vaoId); if (vaoSupported) glBindVertexArray(mesh.vaoId);
@ -1732,6 +1728,7 @@ void rlglUpdateMesh(Mesh mesh, int buffer, int numVertex)
//mesh.vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); //mesh.vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
// Now we can modify vertices // Now we can modify vertices
//glUnmapBuffer(GL_ARRAY_BUFFER); //glUnmapBuffer(GL_ARRAY_BUFFER);
#endif
} }
// Draw a 3d mesh with material and transform // Draw a 3d mesh with material and transform
@ -2156,19 +2153,19 @@ void UnloadShader(Shader shader)
} }
} }
// Set custom shader to be used on batch draw // Begin custom shader mode
void BeginShaderMode(Shader shader) void BeginShaderMode(Shader shader)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if (currentShader.id != shader.id) if (currentShader.id != shader.id)
{ {
//rlglDraw(); rlglDraw();
currentShader = shader; currentShader = shader;
} }
#endif #endif
} }
// Set default shader to be used in batch draw // End custom shader mode (returns to default shader)
void EndShaderMode(void) void EndShaderMode(void)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2254,13 +2251,25 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
#endif #endif
} }
// Set a custom projection matrix (replaces internal projection matrix)
void SetMatrixProjection(Matrix proj)
{
projection = proj;
}
// Set a custom modelview matrix (replaces internal modelview matrix)
void SetMatrixModelview(Matrix view)
{
modelview = view;
}
// Begin blending mode (alpha, additive, multiplied) // Begin blending mode (alpha, additive, multiplied)
// NOTE: Only 3 blending modes supported, default blend mode is alpha // NOTE: Only 3 blending modes supported, default blend mode is alpha
void BeginBlendMode(int mode) void BeginBlendMode(int mode)
{ {
if ((blendMode != mode) && (mode < 3)) if ((blendMode != mode) && (mode < 3))
{ {
//rlglDraw(); rlglDraw();
switch (mode) switch (mode)
{ {
@ -2283,8 +2292,11 @@ void EndBlendMode(void)
// Create a new light, initialize it and add to pool // Create a new light, initialize it and add to pool
Light CreateLight(int type, Vector3 position, Color diffuse) Light CreateLight(int type, Vector3 position, Color diffuse)
{ {
Light light = NULL;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Allocate dynamic memory // Allocate dynamic memory
Light light = (Light)malloc(sizeof(LightData)); light = (Light)malloc(sizeof(LightData));
// Initialize light values with generic values // Initialize light values with generic values
light->id = lightsCount; light->id = lightsCount;
@ -2301,13 +2313,18 @@ Light CreateLight(int type, Vector3 position, Color diffuse)
// Increase enabled lights count // Increase enabled lights count
lightsCount++; lightsCount++;
#else
// TODO: Support OpenGL 1.1 lighting system
TraceLog(WARNING, "Lighting currently not supported on OpenGL 1.1");
#endif
return light; return light;
} }
// Destroy a light and take it out of the list // Destroy a light and take it out of the list
void DestroyLight(Light light) void DestroyLight(Light light)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Free dynamic memory allocation // Free dynamic memory allocation
free(lights[light->id]); free(lights[light->id]);
@ -2325,6 +2342,7 @@ void DestroyLight(Light light)
// Decrease enabled physic objects count // Decrease enabled physic objects count
lightsCount--; lightsCount--;
#endif
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -2869,9 +2887,9 @@ static void DrawDefaultBuffers(void)
glUseProgram(currentShader.id); glUseProgram(currentShader.id);
// Create modelview-projection matrix // Create modelview-projection matrix
//Matrix matMVP = MatrixMultiply(modelview, projection); Matrix matMVP = MatrixMultiply(modelview, projection);
glUniformMatrix4fv(currentShader.mvpLoc, 1, false, MatrixToFloat(customMVP)); //customMVP glUniformMatrix4fv(currentShader.mvpLoc, 1, false, MatrixToFloat(matMVP));
glUniform4f(currentShader.tintColorLoc, 1.0f, 1.0f, 1.0f, 1.0f); glUniform4f(currentShader.tintColorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
glUniform1i(currentShader.mapTexture0Loc, 0); glUniform1i(currentShader.mapTexture0Loc, 0);
@ -3062,7 +3080,7 @@ static void UnloadDefaultBuffers(void)
free(quads.indices); free(quads.indices);
} }
// Sets shader uniform values for lights array // Setup shader uniform values for lights array
// NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0f // NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0f
static void SetShaderLights(Shader shader) static void SetShaderLights(Shader shader)
{ {

11
examples/oculus_glfw_sample/rlgl.h
View file

@ -32,15 +32,15 @@
//#define RLGL_STANDALONE // NOTE: To use rlgl as standalone lib, just uncomment this line //#define RLGL_STANDALONE // NOTE: To use rlgl as standalone lib, just uncomment this line
#ifndef RLGL_STANDALONE #ifndef RLGL_STANDALONE
#include "raylib.h" // Required for typedef(s): Model, Shader, Texture2D #include "raylib.h" // Required for: Model, Shader, Texture2D
#include "utils.h" // Required for function TraceLog() #include "utils.h" // Required for: TraceLog()
#endif #endif
#ifdef RLGL_STANDALONE #ifdef RLGL_STANDALONE
#define RAYMATH_STANDALONE #define RAYMATH_STANDALONE
#endif #endif
#include "raymath.h" // Required for types: Vector3, Matrix #include "raymath.h" // Required for: Vector3, Matrix
// Select desired OpenGL version // Select desired OpenGL version
// NOTE: Those preprocessor defines are only used on rlgl module, // NOTE: Those preprocessor defines are only used on rlgl module,
@ -291,7 +291,7 @@ int rlGetVersion(void); // Returns current OpenGL versio
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
void rlglInit(void); // Initialize rlgl (shaders, VAO, VBO...) void rlglInit(void); // Initialize rlgl (shaders, VAO, VBO...)
void rlglClose(void); // De-init rlgl void rlglClose(void); // De-init rlgl
void rlglDraw(Matrix mvp); // Draw VAO/VBO void rlglDraw(void); // Draw VAO/VBO
void rlglInitGraphics(int offsetX, int offsetY, int width, int height); // Initialize Graphics (OpenGL stuff) void rlglInitGraphics(int offsetX, int offsetY, int width, int height); // Initialize Graphics (OpenGL stuff)
unsigned int rlglLoadTexture(void *data, int width, int height, int textureFormat, int mipmapCount); // Load texture in GPU unsigned int rlglLoadTexture(void *data, int width, int height, int textureFormat, int mipmapCount); // Load texture in GPU
@ -329,6 +329,9 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // S
void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int) void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int)
void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4)
void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
void BeginShaderMode(Shader shader); // Begin custom shader drawing void BeginShaderMode(Shader shader); // Begin custom shader drawing
void EndShaderMode(void); // End custom shader drawing (use default shader) void EndShaderMode(void); // End custom shader drawing (use default shader)
void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)

425
src/audio.c
View file

@ -35,29 +35,29 @@
#include "raylib.h" #include "raylib.h"
#endif #endif
#include "AL/al.h" // OpenAL basic header #include "AL/al.h" // OpenAL basic header
#include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work) #include "AL/alc.h" // OpenAL context header (like OpenGL, OpenAL requires a context to work)
#include "AL/alext.h" // OpenAL extensions for other format types #include "AL/alext.h" // OpenAL extensions for other format types
#include <stdlib.h> // Required for: malloc(), free() #include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp() #include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread() #include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
#if defined(AUDIO_STANDALONE) #if defined(AUDIO_STANDALONE)
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() #include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
#else #else
#include "utils.h" // Required for: DecompressData() #include "utils.h" // Required for: DecompressData()
// NOTE: Includes Android fopen() function map // NOTE: Includes Android fopen() function map
#endif #endif
//#define STB_VORBIS_HEADER_ONLY //#define STB_VORBIS_HEADER_ONLY
#include "stb_vorbis.h" // OGG loading functions #include "stb_vorbis.h" // OGG loading functions
#define JAR_XM_IMPLEMENTATION #define JAR_XM_IMPLEMENTATION
#include "jar_xm.h" // XM loading functions #include "jar_xm.h" // XM loading functions
#define JAR_MOD_IMPLEMENTATION #define JAR_MOD_IMPLEMENTATION
#include "jar_mod.h" // For playing .mod files #include "jar_mod.h" // MOD loading functions
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Defines and Macros // Defines and Macros
@ -89,25 +89,45 @@ typedef struct MixChannel_t {
unsigned char mixChannel; // 0-3 or mixA-mixD, each mix channel can receive up to one dedicated audio stream unsigned char mixChannel; // 0-3 or mixA-mixD, each mix channel can receive up to one dedicated audio stream
bool floatingPoint; // if false then the short datatype is used instead bool floatingPoint; // if false then the short datatype is used instead
bool playing; // false if paused bool playing; // false if paused
ALenum alFormat; // openAL format specifier
ALuint alSource; // openAL source ALenum alFormat; // OpenAL format specifier
ALuint alBuffer[MAX_STREAM_BUFFERS]; // openAL sample buffer ALuint alSource; // OpenAL source
ALuint alBuffer[MAX_STREAM_BUFFERS]; // OpenAL sample buffer
} MixChannel_t; } MixChannel_t;
// Music type (file streaming from memory) // Music type (file streaming from memory)
// NOTE: Anything longer than ~10 seconds should be streamed into a mix channel... // NOTE: Anything longer than ~10 seconds should be streamed into a mix channel...
typedef struct Music { typedef struct Music {
stb_vorbis *stream; stb_vorbis *stream;
jar_xm_context_t *xmctx; // Stores jar_xm mixc, XM chiptune context jar_xm_context_t *xmctx; // XM chiptune context
jar_mod_context_t modctx; // Stores mod chiptune context jar_mod_context_t modctx; // MOD chiptune context
MixChannel_t *mixc; // mix channel MixChannel_t *mixc; // mix channel
unsigned int totalSamplesLeft; unsigned int totalSamplesLeft;
float totalLengthSeconds; float totalLengthSeconds;
bool loop; bool loop;
bool chipTune; // True if chiptune is loaded bool chipTune; // chiptune is loaded?
} Music; } Music;
// Audio errors registered
typedef enum {
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
#if defined(AUDIO_STANDALONE) #if defined(AUDIO_STANDALONE)
typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType; typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
#endif #endif
@ -115,9 +135,11 @@ typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Global Variables Definition // Global Variables Definition
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
static MixChannel_t* mixChannels_g[MAX_MIX_CHANNELS]; // What mix channels are currently active
static bool musicEnabled_g = false;
static Music musicChannels_g[MAX_MUSIC_STREAMS]; // Current music loaded, up to two can play at the same time static Music musicChannels_g[MAX_MUSIC_STREAMS]; // Current music loaded, up to two can play at the same time
static MixChannel_t *mixChannels_g[MAX_MIX_CHANNELS]; // What mix channels are currently active
static bool musicEnabled_g = false;
static int lastAudioError = 0; // Registers last audio error
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module specific Functions Declaration // Module specific Functions Declaration
@ -129,10 +151,9 @@ static void UnloadWave(Wave wave); // Unload wave data
static bool BufferMusicStream(int index, int numBuffers); // Fill music buffers with data static bool BufferMusicStream(int index, int numBuffers); // Fill music buffers with data
static void EmptyMusicStream(int index); // Empty music buffers static void EmptyMusicStream(int index); // Empty music buffers
static MixChannel_t *InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint); // For streaming into mix channels.
static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint); // For streaming into mix channels. static void CloseMixChannel(MixChannel_t *mixc); // Frees mix channel
static void CloseMixChannel(MixChannel_t* mixc); // Frees mix channel static int BufferMixChannel(MixChannel_t *mixc, void *data, int numberElements); // Pushes more audio data into mixc mix channel, if NULL is passed it pauses
static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements); // Pushes more audio data into mixc mix channel, if NULL is passed it pauses
static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer); // Fill buffer with zeros, returns number processed static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer); // Fill buffer with zeros, returns number processed
static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len); // Pass two arrays of the same legnth in static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len); // Pass two arrays of the same legnth in
static void ResampleByteToFloat(char *chars, float *floats, unsigned short len); // Pass two arrays of same length in static void ResampleByteToFloat(char *chars, float *floats, unsigned short len); // Pass two arrays of same length in
@ -153,13 +174,13 @@ void InitAudioDevice(void)
// Open and initialize a device with default settings // Open and initialize a device with default settings
ALCdevice *device = alcOpenDevice(NULL); ALCdevice *device = alcOpenDevice(NULL);
if(!device) TraceLog(ERROR, "Audio device could not be opened"); if (!device) TraceLog(ERROR, "Audio device could not be opened");
ALCcontext *context = alcCreateContext(device, NULL); ALCcontext *context = alcCreateContext(device, NULL);
if(context == NULL || alcMakeContextCurrent(context) == ALC_FALSE) if ((context == NULL) || (alcMakeContextCurrent(context) == ALC_FALSE))
{ {
if(context != NULL) alcDestroyContext(context); if (context != NULL) alcDestroyContext(context);
alcCloseDevice(device); alcCloseDevice(device);
@ -177,11 +198,10 @@ void InitAudioDevice(void)
// Close the audio device for all contexts // Close the audio device for all contexts
void CloseAudioDevice(void) void CloseAudioDevice(void)
{ {
for(int index=0; index<MAX_MUSIC_STREAMS; index++) for (int index=0; index<MAX_MUSIC_STREAMS; index++)
{ {
if(musicChannels_g[index].mixc) StopMusicStream(index); // Stop music streaming and close current stream if (musicChannels_g[index].mixc) StopMusicStream(index); // Stop music streaming and close current stream
} }
ALCdevice *device; ALCdevice *device;
ALCcontext *context = alcGetCurrentContext(); ALCcontext *context = alcGetCurrentContext();
@ -199,9 +219,12 @@ void CloseAudioDevice(void)
bool IsAudioDeviceReady(void) bool IsAudioDeviceReady(void)
{ {
ALCcontext *context = alcGetCurrentContext(); ALCcontext *context = alcGetCurrentContext();
if (context == NULL) return false; if (context == NULL) return false;
else{ else
{
ALCdevice *device = alcGetContextsDevice(context); ALCdevice *device = alcGetContextsDevice(context);
if (device == NULL) return false; if (device == NULL) return false;
else return true; else return true;
} }
@ -214,33 +237,30 @@ bool IsAudioDeviceReady(void)
// For streaming into mix channels. // For streaming into mix channels.
// The mixChannel is what audio muxing channel you want to operate on, 0-3 are the ones available. Each mix channel can only be used one at a time. // The mixChannel is what audio muxing channel you want to operate on, 0-3 are the ones available. Each mix channel can only be used one at a time.
// exmple usage is InitMixChannel(48000, 0, 2, true); // mixchannel 1, 48khz, stereo, floating point // exmple usage is InitMixChannel(48000, 0, 2, true); // mixchannel 1, 48khz, stereo, floating point
static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint) static MixChannel_t *InitMixChannel(unsigned short sampleRate, unsigned char mixChannel, unsigned char channels, bool floatingPoint)
{ {
if(mixChannel >= MAX_MIX_CHANNELS) return NULL; if (mixChannel >= MAX_MIX_CHANNELS) return NULL;
if(!IsAudioDeviceReady()) InitAudioDevice(); if (!IsAudioDeviceReady()) InitAudioDevice();
if(!mixChannels_g[mixChannel]){ if (!mixChannels_g[mixChannel])
MixChannel_t *mixc = (MixChannel_t*)malloc(sizeof(MixChannel_t)); {
MixChannel_t *mixc = (MixChannel_t *)malloc(sizeof(MixChannel_t));
mixc->sampleRate = sampleRate; mixc->sampleRate = sampleRate;
mixc->channels = channels; mixc->channels = channels;
mixc->mixChannel = mixChannel; mixc->mixChannel = mixChannel;
mixc->floatingPoint = floatingPoint; mixc->floatingPoint = floatingPoint;
mixChannels_g[mixChannel] = mixc; mixChannels_g[mixChannel] = mixc;
// setup openAL format // Setup OpenAL format
if(channels == 1) if (channels == 1)
{ {
if(floatingPoint) if (floatingPoint) mixc->alFormat = AL_FORMAT_MONO_FLOAT32;
mixc->alFormat = AL_FORMAT_MONO_FLOAT32; else mixc->alFormat = AL_FORMAT_MONO16;
else
mixc->alFormat = AL_FORMAT_MONO16;
} }
else if(channels == 2) else if (channels == 2)
{ {
if(floatingPoint) if (floatingPoint) mixc->alFormat = AL_FORMAT_STEREO_FLOAT32;
mixc->alFormat = AL_FORMAT_STEREO_FLOAT32; else mixc->alFormat = AL_FORMAT_STEREO16;
else
mixc->alFormat = AL_FORMAT_STEREO16;
} }
// Create an audio source // Create an audio source
@ -253,10 +273,8 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
// Create Buffer // Create Buffer
alGenBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer); alGenBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
//fill buffers // Fill buffers
int x; for (int i = 0; i < MAX_STREAM_BUFFERS; i++) FillAlBufferWithSilence(mixc, mixc->alBuffer[i]);
for(x=0;x<MAX_STREAM_BUFFERS;x++)
FillAlBufferWithSilence(mixc, mixc->alBuffer[x]);
alSourceQueueBuffers(mixc->alSource, MAX_STREAM_BUFFERS, mixc->alBuffer); alSourceQueueBuffers(mixc->alSource, MAX_STREAM_BUFFERS, mixc->alBuffer);
mixc->playing = true; mixc->playing = true;
@ -264,27 +282,30 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
return mixc; return mixc;
} }
return NULL; return NULL;
} }
// Frees buffer in mix channel // Frees buffer in mix channel
static void CloseMixChannel(MixChannel_t* mixc) static void CloseMixChannel(MixChannel_t *mixc)
{ {
if(mixc){ if (mixc)
{
alSourceStop(mixc->alSource); alSourceStop(mixc->alSource);
mixc->playing = false; mixc->playing = false;
//flush out all queued buffers // Flush out all queued buffers
ALuint buffer = 0; ALuint buffer = 0;
int queued = 0; int queued = 0;
alGetSourcei(mixc->alSource, AL_BUFFERS_QUEUED, &queued); alGetSourcei(mixc->alSource, AL_BUFFERS_QUEUED, &queued);
while (queued > 0) while (queued > 0)
{ {
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer); alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
queued--; queued--;
} }
//delete source and buffers // Delete source and buffers
alDeleteSources(1, &mixc->alSource); alDeleteSources(1, &mixc->alSource);
alDeleteBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer); alDeleteBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
mixChannels_g[mixc->mixChannel] = NULL; mixChannels_g[mixc->mixChannel] = NULL;
@ -296,39 +317,46 @@ static void CloseMixChannel(MixChannel_t* mixc)
// Pushes more audio data into mixc mix channel, only one buffer per call // Pushes more audio data into mixc mix channel, only one buffer per call
// Call "BufferMixChannel(mixc, NULL, 0)" if you want to pause the audio. // Call "BufferMixChannel(mixc, NULL, 0)" if you want to pause the audio.
// @Returns number of samples that where processed. // @Returns number of samples that where processed.
static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements) static int BufferMixChannel(MixChannel_t *mixc, void *data, int numberElements)
{ {
if(!mixc || mixChannels_g[mixc->mixChannel] != mixc) return 0; // when there is two channels there must be an even number of samples if (!mixc || (mixChannels_g[mixc->mixChannel] != mixc)) return 0; // When there is two channels there must be an even number of samples
if (!data || !numberElements) if (!data || !numberElements)
{ // pauses audio until data is given {
if(mixc->playing){ // Pauses audio until data is given
if (mixc->playing)
{
alSourcePause(mixc->alSource); alSourcePause(mixc->alSource);
mixc->playing = false; mixc->playing = false;
} }
return 0; return 0;
} }
else if(!mixc->playing) else if (!mixc->playing)
{ // restart audio otherwise {
// Restart audio otherwise
alSourcePlay(mixc->alSource); alSourcePlay(mixc->alSource);
mixc->playing = true; mixc->playing = true;
} }
ALuint buffer = 0; ALuint buffer = 0;
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer); alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
if(!buffer) return 0; if (!buffer) return 0;
if(mixc->floatingPoint) // process float buffers
if (mixc->floatingPoint)
{ {
float *ptr = (float*)data; // Process float buffers
float *ptr = (float *)data;
alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(float), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(float), mixc->sampleRate);
} }
else // process short buffers else
{ {
short *ptr = (short*)data; // Process short buffers
short *ptr = (short *)data;
alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(short), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, ptr, numberElements*sizeof(short), mixc->sampleRate);
} }
alSourceQueueBuffers(mixc->alSource, 1, &buffer); alSourceQueueBuffers(mixc->alSource, 1, &buffer);
return numberElements; return numberElements;
@ -337,15 +365,18 @@ static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements)
// fill buffer with zeros, returns number processed // fill buffer with zeros, returns number processed
static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer) static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
{ {
if(mixc->floatingPoint){ if (mixc->floatingPoint)
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = {0.f}; {
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = { 0.0f };
alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_FLOAT*sizeof(float), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_FLOAT*sizeof(float), mixc->sampleRate);
return MUSIC_BUFFER_SIZE_FLOAT; return MUSIC_BUFFER_SIZE_FLOAT;
} }
else else
{ {
short pcm[MUSIC_BUFFER_SIZE_SHORT] = {0}; short pcm[MUSIC_BUFFER_SIZE_SHORT] = { 0 };
alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_SHORT*sizeof(short), mixc->sampleRate); alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_SHORT*sizeof(short), mixc->sampleRate);
return MUSIC_BUFFER_SIZE_SHORT; return MUSIC_BUFFER_SIZE_SHORT;
} }
} }
@ -355,13 +386,10 @@ static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
// ResampleShortToFloat(sh,fl,3); // ResampleShortToFloat(sh,fl,3);
static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len) static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len)
{ {
int x; for (int i = 0; i < len; i++)
for(x=0;x<len;x++)
{ {
if(shorts[x] < 0) if (shorts[i] < 0) floats[i] = (float)shorts[i]/32766.0f;
floats[x] = (float)shorts[x] / 32766.f; else floats[i] = (float)shorts[i]/32767.0f;
else
floats[x] = (float)shorts[x] / 32767.f;
} }
} }
@ -370,13 +398,10 @@ static void ResampleShortToFloat(short *shorts, float *floats, unsigned short le
// ResampleByteToFloat(ch,fl,3); // ResampleByteToFloat(ch,fl,3);
static void ResampleByteToFloat(char *chars, float *floats, unsigned short len) static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
{ {
int x; for (int i = 0; i < len; i++)
for(x=0;x<len;x++)
{ {
if(chars[x] < 0) if (chars[i] < 0) floats[i] = (float)chars[i]/127.0f;
floats[x] = (float)chars[x] / 127.f; else floats[i] = (float)chars[i]/128.0f;
else
floats[x] = (float)chars[x] / 128.f;
} }
} }
@ -385,22 +410,19 @@ static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
RawAudioContext InitRawAudioContext(int sampleRate, int channels, bool floatingPoint) RawAudioContext InitRawAudioContext(int sampleRate, int channels, bool floatingPoint)
{ {
int mixIndex; int mixIndex;
for(mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot for (mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
{ {
if(mixChannels_g[mixIndex] == NULL) break; if (mixChannels_g[mixIndex] == NULL) break;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
} }
if(InitMixChannel(sampleRate, mixIndex, channels, floatingPoint)) if (InitMixChannel(sampleRate, mixIndex, channels, floatingPoint)) return mixIndex;
return mixIndex; else return ERROR_RAW_CONTEXT_CREATION; // error
else
return ERROR_RAW_CONTEXT_CREATION; // error
} }
void CloseRawAudioContext(RawAudioContext ctx) void CloseRawAudioContext(RawAudioContext ctx)
{ {
if(mixChannels_g[ctx]) if (mixChannels_g[ctx]) CloseMixChannel(mixChannels_g[ctx]);
CloseMixChannel(mixChannels_g[ctx]);
} }
// if 0 is returned, the buffers are still full and you need to keep trying with the same data until a + number is returned. // if 0 is returned, the buffers are still full and you need to keep trying with the same data until a + number is returned.
@ -409,18 +431,16 @@ void CloseRawAudioContext(RawAudioContext ctx)
int BufferRawAudioContext(RawAudioContext ctx, void *data, unsigned short numberElements) int BufferRawAudioContext(RawAudioContext ctx, void *data, unsigned short numberElements)
{ {
int numBuffered = 0; int numBuffered = 0;
if(ctx >= 0)
if (ctx >= 0)
{ {
MixChannel_t* mixc = mixChannels_g[ctx]; MixChannel_t* mixc = mixChannels_g[ctx];
numBuffered = BufferMixChannel(mixc, data, numberElements); numBuffered = BufferMixChannel(mixc, data, numberElements);
} }
return numBuffered; return numBuffered;
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Definition - Sounds loading and playing (.WAV) // Module Functions Definition - Sounds loading and playing (.WAV)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -438,9 +458,12 @@ Sound LoadSound(char *fileName)
if (strcmp(GetExtension(fileName),"wav") == 0) wave = LoadWAV(fileName); if (strcmp(GetExtension(fileName),"wav") == 0) wave = LoadWAV(fileName);
else if (strcmp(GetExtension(fileName),"ogg") == 0) wave = LoadOGG(fileName); else if (strcmp(GetExtension(fileName),"ogg") == 0) wave = LoadOGG(fileName);
else{ else
{
TraceLog(WARNING, "[%s] Sound extension not recognized, it can't be loaded", fileName); TraceLog(WARNING, "[%s] Sound extension not recognized, it can't be loaded", fileName);
sound.error = ERROR_EXTENSION_NOT_RECOGNIZED; //error
// TODO: Find a better way to register errors (similar to glGetError())
lastAudioError = ERROR_EXTENSION_NOT_RECOGNIZED;
} }
if (wave.data != NULL) if (wave.data != NULL)
@ -568,7 +591,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
if (rresFile == NULL) if (rresFile == NULL)
{ {
TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName); TraceLog(WARNING, "[%s] rRES raylib resource file could not be opened", rresName);
sound.error = ERROR_UNABLE_TO_OPEN_RRES_FILE; //error lastAudioError = ERROR_UNABLE_TO_OPEN_RRES_FILE;
} }
else else
{ {
@ -583,7 +606,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
if ((id[0] != 'r') && (id[1] != 'R') && (id[2] != 'E') &&(id[3] != 'S')) if ((id[0] != 'r') && (id[1] != 'R') && (id[2] != 'E') &&(id[3] != 'S'))
{ {
TraceLog(WARNING, "[%s] This is not a valid raylib resource file", rresName); TraceLog(WARNING, "[%s] This is not a valid raylib resource file", rresName);
sound.error = ERROR_INVALID_RRES_FILE; lastAudioError = ERROR_INVALID_RRES_FILE;
} }
else else
{ {
@ -674,7 +697,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
else else
{ {
TraceLog(WARNING, "[%s] Required resource do not seem to be a valid SOUND resource", rresName); TraceLog(WARNING, "[%s] Required resource do not seem to be a valid SOUND resource", rresName);
sound.error = ERROR_INVALID_RRES_RESOURCE; lastAudioError = ERROR_INVALID_RRES_RESOURCE;
} }
} }
else else
@ -776,24 +799,24 @@ void SetSoundPitch(Sound sound, float pitch)
// Start music playing (open stream) // Start music playing (open stream)
// returns 0 on success // returns 0 on success
int PlayMusicStream(int musicIndex, char *fileName) int PlayMusicStream(int index, char *fileName)
{ {
int mixIndex; int mixIndex;
if(musicChannels_g[musicIndex].stream || musicChannels_g[musicIndex].xmctx) return ERROR_UNINITIALIZED_CHANNELS; // error if (musicChannels_g[index].stream || musicChannels_g[index].xmctx) return ERROR_UNINITIALIZED_CHANNELS; // error
for(mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot for (mixIndex = 0; mixIndex < MAX_MIX_CHANNELS; mixIndex++) // find empty mix channel slot
{ {
if(mixChannels_g[mixIndex] == NULL) break; if (mixChannels_g[mixIndex] == NULL) break;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
} }
if (strcmp(GetExtension(fileName),"ogg") == 0) if (strcmp(GetExtension(fileName),"ogg") == 0)
{ {
// Open audio stream // Open audio stream
musicChannels_g[musicIndex].stream = stb_vorbis_open_filename(fileName, NULL, NULL); musicChannels_g[index].stream = stb_vorbis_open_filename(fileName, NULL, NULL);
if (musicChannels_g[musicIndex].stream == NULL) if (musicChannels_g[index].stream == NULL)
{ {
TraceLog(WARNING, "[%s] OGG audio file could not be opened", fileName); TraceLog(WARNING, "[%s] OGG audio file could not be opened", fileName);
return ERROR_LOADING_OGG; // error return ERROR_LOADING_OGG; // error
@ -801,48 +824,53 @@ int PlayMusicStream(int musicIndex, char *fileName)
else else
{ {
// Get file info // Get file info
stb_vorbis_info info = stb_vorbis_get_info(musicChannels_g[musicIndex].stream); stb_vorbis_info info = stb_vorbis_get_info(musicChannels_g[index].stream);
TraceLog(INFO, "[%s] Ogg sample rate: %i", fileName, info.sample_rate); TraceLog(INFO, "[%s] Ogg sample rate: %i", fileName, info.sample_rate);
TraceLog(INFO, "[%s] Ogg channels: %i", fileName, info.channels); TraceLog(INFO, "[%s] Ogg channels: %i", fileName, info.channels);
TraceLog(DEBUG, "[%s] Temp memory required: %i", fileName, info.temp_memory_required); TraceLog(DEBUG, "[%s] Temp memory required: %i", fileName, info.temp_memory_required);
musicChannels_g[musicIndex].loop = true; // We loop by default musicChannels_g[index].loop = true; // We loop by default
musicEnabled_g = true; musicEnabled_g = true;
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[musicIndex].stream) * info.channels; musicChannels_g[index].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * info.channels;
musicChannels_g[musicIndex].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[musicIndex].stream); musicChannels_g[index].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
if (info.channels == 2){ if (info.channels == 2)
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false); {
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[index].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false);
musicChannels_g[index].mixc->playing = true;
} }
else{ else
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 1, false); {
musicChannels_g[musicIndex].mixc->playing = true; musicChannels_g[index].mixc = InitMixChannel(info.sample_rate, mixIndex, 1, false);
musicChannels_g[index].mixc->playing = true;
} }
if(!musicChannels_g[musicIndex].mixc) return ERROR_LOADING_OGG; // error
if (!musicChannels_g[index].mixc) return ERROR_LOADING_OGG; // error
} }
} }
else if (strcmp(GetExtension(fileName),"xm") == 0) else if (strcmp(GetExtension(fileName),"xm") == 0)
{ {
// only stereo is supported for xm // only stereo is supported for xm
if(!jar_xm_create_context_from_file(&musicChannels_g[musicIndex].xmctx, 48000, fileName)) if (!jar_xm_create_context_from_file(&musicChannels_g[index].xmctx, 48000, fileName))
{ {
musicChannels_g[musicIndex].chipTune = true; musicChannels_g[index].chipTune = true;
musicChannels_g[musicIndex].loop = true; musicChannels_g[index].loop = true;
jar_xm_set_max_loop_count(musicChannels_g[musicIndex].xmctx, 0); // infinite number of loops jar_xm_set_max_loop_count(musicChannels_g[index].xmctx, 0); // infinite number of loops
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)jar_xm_get_remaining_samples(musicChannels_g[musicIndex].xmctx); musicChannels_g[index].totalSamplesLeft = (unsigned int)jar_xm_get_remaining_samples(musicChannels_g[index].xmctx);
musicChannels_g[musicIndex].totalLengthSeconds = ((float)musicChannels_g[musicIndex].totalSamplesLeft) / 48000.f; musicChannels_g[index].totalLengthSeconds = ((float)musicChannels_g[index].totalSamplesLeft) / 48000.f;
musicEnabled_g = true; musicEnabled_g = true;
TraceLog(INFO, "[%s] XM number of samples: %i", fileName, musicChannels_g[musicIndex].totalSamplesLeft); TraceLog(INFO, "[%s] XM number of samples: %i", fileName, musicChannels_g[index].totalSamplesLeft);
TraceLog(INFO, "[%s] XM track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds); TraceLog(INFO, "[%s] XM track length: %11.6f sec", fileName, musicChannels_g[index].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, true); musicChannels_g[index].mixc = InitMixChannel(48000, mixIndex, 2, true);
if(!musicChannels_g[musicIndex].mixc) return ERROR_XM_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true; if (!musicChannels_g[index].mixc) return ERROR_XM_CONTEXT_CREATION; // error
musicChannels_g[index].mixc->playing = true;
} }
else else
{ {
@ -852,21 +880,24 @@ int PlayMusicStream(int musicIndex, char *fileName)
} }
else if (strcmp(GetExtension(fileName),"mod") == 0) else if (strcmp(GetExtension(fileName),"mod") == 0)
{ {
jar_mod_init(&musicChannels_g[musicIndex].modctx); jar_mod_init(&musicChannels_g[index].modctx);
if(jar_mod_load_file(&musicChannels_g[musicIndex].modctx, fileName))
if (jar_mod_load_file(&musicChannels_g[index].modctx, fileName))
{ {
musicChannels_g[musicIndex].chipTune = true; musicChannels_g[index].chipTune = true;
musicChannels_g[musicIndex].loop = true; musicChannels_g[index].loop = true;
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)jar_mod_max_samples(&musicChannels_g[musicIndex].modctx); musicChannels_g[index].totalSamplesLeft = (unsigned int)jar_mod_max_samples(&musicChannels_g[index].modctx);
musicChannels_g[musicIndex].totalLengthSeconds = ((float)musicChannels_g[musicIndex].totalSamplesLeft) / 48000.f; musicChannels_g[index].totalLengthSeconds = ((float)musicChannels_g[index].totalSamplesLeft) / 48000.f;
musicEnabled_g = true; musicEnabled_g = true;
TraceLog(INFO, "[%s] MOD number of samples: %i", fileName, musicChannels_g[musicIndex].totalSamplesLeft); TraceLog(INFO, "[%s] MOD number of samples: %i", fileName, musicChannels_g[index].totalSamplesLeft);
TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds); TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, musicChannels_g[index].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, false); musicChannels_g[index].mixc = InitMixChannel(48000, mixIndex, 2, false);
if(!musicChannels_g[musicIndex].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true; if (!musicChannels_g[index].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
musicChannels_g[index].mixc->playing = true;
} }
else else
{ {
@ -879,6 +910,7 @@ int PlayMusicStream(int musicIndex, char *fileName)
TraceLog(WARNING, "[%s] Music extension not recognized, it can't be loaded", fileName); TraceLog(WARNING, "[%s] Music extension not recognized, it can't be loaded", fileName);
return ERROR_EXTENSION_NOT_RECOGNIZED; // error return ERROR_EXTENSION_NOT_RECOGNIZED; // error
} }
return 0; // normal return return 0; // normal return
} }
@ -894,17 +926,12 @@ void StopMusicStream(int index)
jar_xm_free_context(musicChannels_g[index].xmctx); jar_xm_free_context(musicChannels_g[index].xmctx);
musicChannels_g[index].xmctx = 0; musicChannels_g[index].xmctx = 0;
} }
else if(musicChannels_g[index].chipTune && musicChannels_g[index].modctx.mod_loaded) else if (musicChannels_g[index].chipTune && musicChannels_g[index].modctx.mod_loaded) jar_mod_unload(&musicChannels_g[index].modctx);
{ else stb_vorbis_close(musicChannels_g[index].stream);
jar_mod_unload(&musicChannels_g[index].modctx);
}
else
{
stb_vorbis_close(musicChannels_g[index].stream);
}
if(!getMusicStreamCount()) musicEnabled_g = false; if (!GetMusicStreamCount()) musicEnabled_g = false;
if(musicChannels_g[index].stream || musicChannels_g[index].xmctx)
if (musicChannels_g[index].stream || musicChannels_g[index].xmctx)
{ {
musicChannels_g[index].stream = NULL; musicChannels_g[index].stream = NULL;
musicChannels_g[index].xmctx = NULL; musicChannels_g[index].xmctx = NULL;
@ -913,11 +940,15 @@ void StopMusicStream(int index)
} }
//get number of music channels active at this time, this does not mean they are playing //get number of music channels active at this time, this does not mean they are playing
int getMusicStreamCount(void) int GetMusicStreamCount(void)
{ {
int musicCount = 0; int musicCount = 0;
for(int musicIndex = 0; musicIndex < MAX_MUSIC_STREAMS; musicIndex++) // find empty music slot
// Find empty music slot
for (int musicIndex = 0; musicIndex < MAX_MUSIC_STREAMS; musicIndex++)
{
if(musicChannels_g[musicIndex].stream != NULL || musicChannels_g[musicIndex].chipTune) musicCount++; if(musicChannels_g[musicIndex].stream != NULL || musicChannels_g[musicIndex].chipTune) musicCount++;
}
return musicCount; return musicCount;
} }
@ -939,8 +970,11 @@ void ResumeMusicStream(int index)
{ {
// Resume music playing... if music available! // Resume music playing... if music available!
ALenum state; ALenum state;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state); alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state);
if (state == AL_PAUSED) if (state == AL_PAUSED)
{ {
TraceLog(INFO, "Resuming music stream"); TraceLog(INFO, "Resuming music stream");
@ -956,8 +990,10 @@ bool IsMusicPlaying(int index)
bool playing = false; bool playing = false;
ALint state; ALint state;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){ if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state); alGetSourcei(musicChannels_g[index].mixc->alSource, AL_SOURCE_STATE, &state);
if (state == AL_PLAYING) playing = true; if (state == AL_PLAYING) playing = true;
} }
@ -967,14 +1003,17 @@ bool IsMusicPlaying(int index)
// Set volume for music // Set volume for music
void SetMusicVolume(int index, float volume) void SetMusicVolume(int index, float volume)
{ {
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){ if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alSourcef(musicChannels_g[index].mixc->alSource, AL_GAIN, volume); alSourcef(musicChannels_g[index].mixc->alSource, AL_GAIN, volume);
} }
} }
// Set pitch for music
void SetMusicPitch(int index, float pitch) void SetMusicPitch(int index, float pitch)
{ {
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc){ if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{
alSourcef(musicChannels_g[index].mixc->alSource, AL_PITCH, pitch); alSourcef(musicChannels_g[index].mixc->alSource, AL_PITCH, pitch);
} }
} }
@ -983,14 +1022,9 @@ void SetMusicPitch(int index, float pitch)
float GetMusicTimeLength(int index) float GetMusicTimeLength(int index)
{ {
float totalSeconds; float totalSeconds;
if (musicChannels_g[index].chipTune)
{ if (musicChannels_g[index].chipTune) totalSeconds = (float)musicChannels_g[index].totalLengthSeconds;
totalSeconds = (float)musicChannels_g[index].totalLengthSeconds; else totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
}
else
{
totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
}
return totalSeconds; return totalSeconds;
} }
@ -999,7 +1033,8 @@ float GetMusicTimeLength(int index)
float GetMusicTimePlayed(int index) float GetMusicTimePlayed(int index)
{ {
float secondsPlayed = 0.0f; float secondsPlayed = 0.0f;
if(index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
if (index < MAX_MUSIC_STREAMS && musicChannels_g[index].mixc)
{ {
if (musicChannels_g[index].chipTune && musicChannels_g[index].xmctx) if (musicChannels_g[index].chipTune && musicChannels_g[index].xmctx)
{ {
@ -1033,33 +1068,33 @@ static bool BufferMusicStream(int index, int numBuffers)
short pcm[MUSIC_BUFFER_SIZE_SHORT]; short pcm[MUSIC_BUFFER_SIZE_SHORT];
float pcmf[MUSIC_BUFFER_SIZE_FLOAT]; float pcmf[MUSIC_BUFFER_SIZE_FLOAT];
int size = 0; // Total size of data steamed in L+R samples for xm floats, individual L or R for ogg shorts int size = 0; // Total size of data steamed in L+R samples for xm floats, individual L or R for ogg shorts
bool active = true; // We can get more data from stream (not finished) bool active = true; // We can get more data from stream (not finished)
if (musicChannels_g[index].chipTune) // There is no end of stream for xmfiles, once the end is reached zeros are generated for non looped chiptunes. if (musicChannels_g[index].chipTune) // There is no end of stream for xmfiles, once the end is reached zeros are generated for non looped chiptunes.
{ {
for(int x=0; x<numBuffers; x++) for (int i = 0; i < numBuffers; i++)
{ {
if(musicChannels_g[index].modctx.mod_loaded){ if (musicChannels_g[index].modctx.mod_loaded)
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) {
size = MUSIC_BUFFER_SIZE_SHORT / 2; if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size = MUSIC_BUFFER_SIZE_SHORT/2;
else else size = musicChannels_g[index].totalSamplesLeft/2;
size = musicChannels_g[index].totalSamplesLeft / 2;
jar_mod_fillbuffer(&musicChannels_g[index].modctx, pcm, size, 0 ); jar_mod_fillbuffer(&musicChannels_g[index].modctx, pcm, size, 0 );
BufferMixChannel(musicChannels_g[index].mixc, pcm, size * 2); BufferMixChannel(musicChannels_g[index].mixc, pcm, size*2);
} }
else if(musicChannels_g[index].xmctx){ else if (musicChannels_g[index].xmctx)
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT) {
size = MUSIC_BUFFER_SIZE_FLOAT / 2; if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT) size = MUSIC_BUFFER_SIZE_FLOAT/2;
else else size = musicChannels_g[index].totalSamplesLeft/2;
size = musicChannels_g[index].totalSamplesLeft / 2;
jar_xm_generate_samples(musicChannels_g[index].xmctx, pcmf, size); // reads 2*readlen shorts and moves them to buffer+size memory location jar_xm_generate_samples(musicChannels_g[index].xmctx, pcmf, size); // reads 2*readlen shorts and moves them to buffer+size memory location
BufferMixChannel(musicChannels_g[index].mixc, pcmf, size * 2); BufferMixChannel(musicChannels_g[index].mixc, pcmf, size*2);
} }
musicChannels_g[index].totalSamplesLeft -= size; musicChannels_g[index].totalSamplesLeft -= size;
if(musicChannels_g[index].totalSamplesLeft <= 0)
if (musicChannels_g[index].totalSamplesLeft <= 0)
{ {
active = false; active = false;
break; break;
@ -1068,17 +1103,16 @@ static bool BufferMusicStream(int index, int numBuffers)
} }
else else
{ {
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size = MUSIC_BUFFER_SIZE_SHORT;
size = MUSIC_BUFFER_SIZE_SHORT; else size = musicChannels_g[index].totalSamplesLeft;
else
size = musicChannels_g[index].totalSamplesLeft;
for(int x=0; x<numBuffers; x++) for (int i = 0; i < numBuffers; i++)
{ {
int streamedBytes = stb_vorbis_get_samples_short_interleaved(musicChannels_g[index].stream, musicChannels_g[index].mixc->channels, pcm, size); int streamedBytes = stb_vorbis_get_samples_short_interleaved(musicChannels_g[index].stream, musicChannels_g[index].mixc->channels, pcm, size);
BufferMixChannel(musicChannels_g[index].mixc, pcm, streamedBytes * musicChannels_g[index].mixc->channels); BufferMixChannel(musicChannels_g[index].mixc, pcm, streamedBytes * musicChannels_g[index].mixc->channels);
musicChannels_g[index].totalSamplesLeft -= streamedBytes * musicChannels_g[index].mixc->channels; musicChannels_g[index].totalSamplesLeft -= streamedBytes * musicChannels_g[index].mixc->channels;
if(musicChannels_g[index].totalSamplesLeft <= 0)
if (musicChannels_g[index].totalSamplesLeft <= 0)
{ {
active = false; active = false;
break; break;
@ -1105,7 +1139,7 @@ static void EmptyMusicStream(int index)
} }
} }
//determine if a music stream is ready to be written to // Determine if a music stream is ready to be written
static int IsMusicStreamReadyForBuffering(int index) static int IsMusicStreamReadyForBuffering(int index)
{ {
ALint processed = 0; ALint processed = 0;
@ -1120,7 +1154,7 @@ void UpdateMusicStream(int index)
bool active = true; bool active = true;
int numBuffers = IsMusicStreamReadyForBuffering(index); int numBuffers = IsMusicStreamReadyForBuffering(index);
if (musicChannels_g[index].mixc->playing && index < MAX_MUSIC_STREAMS && musicEnabled_g && musicChannels_g[index].mixc && numBuffers) if (musicChannels_g[index].mixc->playing && (index < MAX_MUSIC_STREAMS) && musicEnabled_g && musicChannels_g[index].mixc && numBuffers)
{ {
active = BufferMusicStream(index, numBuffers); active = BufferMusicStream(index, numBuffers);
@ -1136,9 +1170,9 @@ void UpdateMusicStream(int index)
stb_vorbis_seek_start(musicChannels_g[index].stream); stb_vorbis_seek_start(musicChannels_g[index].stream);
musicChannels_g[index].totalSamplesLeft = stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * musicChannels_g[index].mixc->channels; musicChannels_g[index].totalSamplesLeft = stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * musicChannels_g[index].mixc->channels;
} }
active = true; active = true;
} }
if (alGetError() != AL_NO_ERROR) TraceLog(WARNING, "Error buffering data..."); if (alGetError() != AL_NO_ERROR) TraceLog(WARNING, "Error buffering data...");
@ -1149,9 +1183,6 @@ void UpdateMusicStream(int index)
if (!active) StopMusicStream(index); if (!active) StopMusicStream(index);
} }
else
return;
} }
// Load WAV file into Wave structure // Load WAV file into Wave structure

22
src/audio.h
View file

@ -47,24 +47,6 @@
#endif #endif
#endif #endif
typedef enum {
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
// Sound source type // Sound source type
typedef struct Sound { typedef struct Sound {
unsigned int source; unsigned int source;
@ -111,7 +93,7 @@ bool IsSoundPlaying(Sound sound); // Check if a so
void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
int PlayMusicStream(int musicIndex, char *fileName); // Start music playing (open stream) int PlayMusicStream(int index, char *fileName); // Start music playing (open stream)
void UpdateMusicStream(int index); // Updates buffers for music streaming void UpdateMusicStream(int index); // Updates buffers for music streaming
void StopMusicStream(int index); // Stop music playing (close stream) void StopMusicStream(int index); // Stop music playing (close stream)
void PauseMusicStream(int index); // Pause music playing void PauseMusicStream(int index); // Pause music playing
@ -120,7 +102,7 @@ bool IsMusicPlaying(int index); // Check if musi
void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level) void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level)
float GetMusicTimeLength(int index); // Get music time length (in seconds) float GetMusicTimeLength(int index); // Get music time length (in seconds)
float GetMusicTimePlayed(int index); // Get current music time played (in seconds) float GetMusicTimePlayed(int index); // Get current music time played (in seconds)
int getMusicStreamCount(void); int GetMusicStreamCount(void);
void SetMusicPitch(int index, float pitch); void SetMusicPitch(int index, float pitch);
// used to output raw audio streams, returns negative numbers on error // used to output raw audio streams, returns negative numbers on error

42
src/core.c
View file

@ -54,13 +54,7 @@
#include <errno.h> // Macros for reporting and retrieving error conditions through error codes #include <errno.h> // Macros for reporting and retrieving error conditions through error codes
#if defined(PLATFORM_DESKTOP) #if defined(PLATFORM_DESKTOP)
#define GLAD_EXTENSIONS_LOADER #include "glad.h" // GLAD library: Manage OpenGL headers and extensions
#if defined(GLEW_EXTENSIONS_LOADER)
#define GLEW_STATIC
#include <GL/glew.h> // GLEW extensions loading lib
#elif defined(GLAD_EXTENSIONS_LOADER)
#include "glad.h" // GLAD library: Manage OpenGL headers and extensions
#endif
#endif #endif
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
@ -1576,33 +1570,15 @@ static void InitDisplay(int width, int height)
// Extensions initialization for OpenGL 3.3 // Extensions initialization for OpenGL 3.3
if (rlGetVersion() == OPENGL_33) if (rlGetVersion() == OPENGL_33)
{ {
#if defined(GLEW_EXTENSIONS_LOADER) // NOTE: glad is generated and contains only required OpenGL version and Core extensions
// Initialize extensions using GLEW //if (!gladLoadGL()) TraceLog(ERROR, "Failed to initialize glad\n");
glewExperimental = 1; // Needed for core profile if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) TraceLog(ERROR, "Failed to initialize glad\n"); // No GLFW3 in this module...
GLenum error = glewInit();
if (error != GLEW_OK) TraceLog(ERROR, "Failed to initialize GLEW - Error Code: %s\n", glewGetErrorString(error));
if (glewIsSupported("GL_VERSION_3_3")) TraceLog(INFO, "OpenGL 3.3 Core profile supported");
else TraceLog(ERROR, "OpenGL 3.3 Core profile not supported");
// With GLEW, we can check if an extension has been loaded in two ways: if (GLAD_GL_VERSION_3_3) TraceLog(INFO, "OpenGL 3.3 Core profile supported");
//if (GLEW_ARB_vertex_array_object) { } else TraceLog(ERROR, "OpenGL 3.3 Core profile not supported");
//if (glewIsSupported("GL_ARB_vertex_array_object")) { }
// With GLAD, we can check if an extension is supported using the GLAD_GL_xxx booleans
// NOTE: GLEW is a big library that loads ALL extensions, we can use some alternative to load only required ones //if (GLAD_GL_ARB_vertex_array_object) // Use GL_ARB_vertex_array_object
// Alternatives: glLoadGen, glad, libepoxy
#elif defined(GLAD_EXTENSIONS_LOADER)
// NOTE: glad is generated and contains only required OpenGL version and Core extensions
//if (!gladLoadGL()) TraceLog(ERROR, "Failed to initialize glad\n");
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) TraceLog(ERROR, "Failed to initialize glad\n"); // No GLFW3 in this module...
if (GLAD_GL_VERSION_3_3) TraceLog(INFO, "OpenGL 3.3 Core profile supported");
else TraceLog(ERROR, "OpenGL 3.3 Core profile not supported");
// With GLAD, we can check if an extension is supported using the GLAD_GL_xxx booleans
//if (GLAD_GL_ARB_vertex_array_object) // Use GL_ARB_vertex_array_object
#endif
} }
#endif #endif

29
src/easings.h
View file

@ -9,21 +9,24 @@
* // This requires lots of memory on system. * // This requires lots of memory on system.
* How to use: * How to use:
* The four inputs t,b,c,d are defined as follows: * The four inputs t,b,c,d are defined as follows:
* t = current time in milliseconds * t = current time (in any unit measure, but same unit as duration)
* b = starting position in only one dimension [X || Y || Z] your choice * b = starting value to interpolate
* c = the total change in value of b that needs to occur * c = the total change in value of b that needs to occur
* d = total time it should take to complete * d = total time it should take to complete (duration)
* *
* Example: * Example:
* float speed = 1.f; *
* float currentTime = 0.f; * int currentTime = 0;
* float currentPos[2] = {0,0}; * int duration = 100;
* float finalPos[2] = {1,1}; * float startPositionX = 0.0f;
* float startPosition[2] = currentPos;//x,y positions * float finalPositionX = 30.0f;
* while(currentPos[0] < finalPos[0]) * float currentPositionX = startPositionX;
* currentPos[0] = EaseSineIn(currentTime, startPosition[0], startPosition[0]-finalPos[0], speed); *
* currentPos[1] = EaseSineIn(currentTime, startPosition[1], startPosition[1]-finalPos[0], speed); * while (currentPositionX < finalPositionX)
* currentTime += diffTime(); * {
* currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
* currentTime++;
* }
* *
* A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/) * A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
* *
@ -87,7 +90,7 @@
#define EASEDEF extern #define EASEDEF extern
#endif #endif
#include <math.h> #include <math.h> // Required for: sin(), cos(), sqrt(), pow()
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { // Prevents name mangling of functions extern "C" { // Prevents name mangling of functions

16
src/physac.c
View file

@ -570,22 +570,6 @@ Rectangle TransformToRectangle(Transform transform)
return (Rectangle){transform.position.x, transform.position.y, transform.scale.x, transform.scale.y}; return (Rectangle){transform.position.x, transform.position.y, transform.scale.x, transform.scale.y};
} }
// Draw physic object information at screen position
void DrawPhysicObjectInfo(PhysicObject pObj, Vector2 position, int fontSize)
{
// Draw physic object ID
DrawText(FormatText("PhysicObject ID: %i - Enabled: %i", pObj->id, pObj->enabled), position.x, position.y, fontSize, BLACK);
// Draw physic object transform values
DrawText(FormatText("\nTRANSFORM\nPosition: %f, %f\nRotation: %f\nScale: %f, %f", pObj->transform.position.x, pObj->transform.position.y, pObj->transform.rotation, pObj->transform.scale.x, pObj->transform.scale.y), position.x, position.y, fontSize, BLACK);
// Draw physic object rigidbody values
DrawText(FormatText("\n\n\n\n\n\nRIGIDBODY\nEnabled: %i\nMass: %f\nAcceleration: %f, %f\nVelocity: %f, %f\nApplyGravity: %i\nIsGrounded: %i\nFriction: %f\nBounciness: %f", pObj->rigidbody.enabled, pObj->rigidbody.mass, pObj->rigidbody.acceleration.x, pObj->rigidbody.acceleration.y,
pObj->rigidbody.velocity.x, pObj->rigidbody.velocity.y, pObj->rigidbody.applyGravity, pObj->rigidbody.isGrounded, pObj->rigidbody.friction, pObj->rigidbody.bounciness), position.x, position.y, fontSize, BLACK);
DrawText(FormatText("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nCOLLIDER\nEnabled: %i\nBounds: %i, %i, %i, %i\nRadius: %i", pObj->collider.enabled, pObj->collider.bounds.x, pObj->collider.bounds.y, pObj->collider.bounds.width, pObj->collider.bounds.height, pObj->collider.radius), position.x, position.y, fontSize, BLACK);
}
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module specific Functions Definition // Module specific Functions Definition
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------

1
src/physac.h
View file

@ -92,7 +92,6 @@ void ApplyForce(PhysicObject pObj, Vector2 force);
void ApplyForceAtPosition(Vector2 position, float force, float radius); // Apply radial force to all physic objects in range void ApplyForceAtPosition(Vector2 position, float force, float radius); // Apply radial force to all physic objects in range
Rectangle TransformToRectangle(Transform transform); // Convert Transform data type to Rectangle (position and scale) Rectangle TransformToRectangle(Transform transform); // Convert Transform data type to Rectangle (position and scale)
void DrawPhysicObjectInfo(PhysicObject pObj, Vector2 position, int fontSize); // Draw physic object information at screen position
#ifdef __cplusplus #ifdef __cplusplus
} }

2
src/raygui.c
View file

@ -667,7 +667,7 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
Vector2 mousePoint = GetMousePosition(); Vector2 mousePoint = GetMousePosition();
int textWidth = MeasureText(FormatText("%i", value), style[GLOBAL_TEXT_FONTSIZE]); int textWidth = MeasureText(FormatText("%i", value), style[GLOBAL_TEXT_FONTSIZE]);
int textHeight = style[GLOBAL_TEXT_FONTSIZE]; //int textHeight = style[GLOBAL_TEXT_FONTSIZE]; // Unused variable
int buttonSide = 0; int buttonSide = 0;

29
src/raylib.h
View file

@ -452,29 +452,10 @@ typedef struct Ray {
Vector3 direction; Vector3 direction;
} Ray; } Ray;
typedef enum { // allows errors to be & together
ERROR_RAW_CONTEXT_CREATION = 1,
ERROR_XM_CONTEXT_CREATION = 2,
ERROR_MOD_CONTEXT_CREATION = 4,
ERROR_MIX_CHANNEL_CREATION = 8,
ERROR_MUSIC_CHANNEL_CREATION = 16,
ERROR_LOADING_XM = 32,
ERROR_LOADING_MOD = 64,
ERROR_LOADING_WAV = 128,
ERROR_LOADING_OGG = 256,
ERROR_OUT_OF_MIX_CHANNELS = 512,
ERROR_EXTENSION_NOT_RECOGNIZED = 1024,
ERROR_UNABLE_TO_OPEN_RRES_FILE = 2048,
ERROR_INVALID_RRES_FILE = 4096,
ERROR_INVALID_RRES_RESOURCE = 8192,
ERROR_UNINITIALIZED_CHANNELS = 16384
} AudioError;
// Sound source type // Sound source type
typedef struct Sound { typedef struct Sound {
unsigned int source; unsigned int source;
unsigned int buffer; unsigned int buffer;
AudioError error; // if there was any error during the creation or use of this Sound
} Sound; } Sound;
// Wave type, defines audio wave data // Wave type, defines audio wave data
@ -488,8 +469,6 @@ typedef struct Wave {
typedef int RawAudioContext; typedef int RawAudioContext;
// Texture formats // Texture formats
// NOTE: Support depends on OpenGL version and platform // NOTE: Support depends on OpenGL version and platform
typedef enum { typedef enum {
@ -889,6 +868,9 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // S
void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int) void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int)
void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4)
void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
void BeginShaderMode(Shader shader); // Begin custom shader drawing void BeginShaderMode(Shader shader); // Begin custom shader drawing
void EndShaderMode(void); // End custom shader drawing (use default shader) void EndShaderMode(void); // End custom shader drawing (use default shader)
void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)
@ -911,7 +893,6 @@ void ApplyForce(PhysicObject pObj, Vector2 force);
void ApplyForceAtPosition(Vector2 position, float force, float radius); // Apply radial force to all physic objects in range void ApplyForceAtPosition(Vector2 position, float force, float radius); // Apply radial force to all physic objects in range
Rectangle TransformToRectangle(Transform transform); // Convert Transform data type to Rectangle (position and scale) Rectangle TransformToRectangle(Transform transform); // Convert Transform data type to Rectangle (position and scale)
void DrawPhysicObjectInfo(PhysicObject pObj, Vector2 position, int fontSize); // Draw physic object information at screen position
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
// Audio Loading and Playing Functions (Module: audio) // Audio Loading and Playing Functions (Module: audio)
@ -931,7 +912,7 @@ bool IsSoundPlaying(Sound sound); // Check if a so
void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
int PlayMusicStream(int musicIndex, char *fileName); // Start music playing (open stream) int PlayMusicStream(int index, char *fileName); // Start music playing (open stream)
void UpdateMusicStream(int index); // Updates buffers for music streaming void UpdateMusicStream(int index); // Updates buffers for music streaming
void StopMusicStream(int index); // Stop music playing (close stream) void StopMusicStream(int index); // Stop music playing (close stream)
void PauseMusicStream(int index); // Pause music playing void PauseMusicStream(int index); // Pause music playing
@ -940,7 +921,7 @@ bool IsMusicPlaying(int index); // Check if musi
void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level) void SetMusicVolume(int index, float volume); // Set volume for music (1.0 is max level)
float GetMusicTimeLength(int index); // Get current music time length (in seconds) float GetMusicTimeLength(int index); // Get current music time length (in seconds)
float GetMusicTimePlayed(int index); // Get current music time played (in seconds) float GetMusicTimePlayed(int index); // Get current music time played (in seconds)
int getMusicStreamCount(void); int GetMusicStreamCount(void);
void SetMusicPitch(int index, float pitch); void SetMusicPitch(int index, float pitch);
// used to output raw audio streams, returns negative numbers on error // used to output raw audio streams, returns negative numbers on error

21
src/raymath.h
View file

@ -151,7 +151,6 @@ RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top,
RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far); // Returns perspective projection matrix RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far); // Returns perspective projection matrix
RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far); // Returns orthographic projection matrix RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far); // Returns orthographic projection matrix
RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up); // Returns camera look-at matrix (view matrix) RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up); // Returns camera look-at matrix (view matrix)
RMDEF void PrintMatrix(Matrix m); // Print matrix utility
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
// Functions Declaration to work with Quaternions // Functions Declaration to work with Quaternions
@ -178,9 +177,7 @@ RMDEF void QuaternionTransform(Quaternion *q, Matrix mat); // Transfo
#if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE) #if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE)
#include <stdio.h> // Used only on PrintMatrix() #include <math.h> // Required for: sinf(), cosf(), tan(), fabs()
#include <math.h> // Standard math libary: sin(), cos(), tan()...
#include <stdlib.h> // Used for abs()
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Definition - Vector3 math // Module Functions Definition - Vector3 math
@ -342,15 +339,14 @@ RMDEF Vector3 VectorReflect(Vector3 vector, Vector3 normal)
return result; return result;
} }
// Transforms a Vector3 with a given Matrix // Transforms a Vector3 by a given Matrix
// TODO: Review math (matrix transpose required?)
RMDEF void VectorTransform(Vector3 *v, Matrix mat) RMDEF void VectorTransform(Vector3 *v, Matrix mat)
{ {
float x = v->x; float x = v->x;
float y = v->y; float y = v->y;
float z = v->z; float z = v->z;
//MatrixTranspose(&mat);
v->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; v->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
v->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; v->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
v->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; v->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
@ -871,17 +867,6 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
return result; return result;
} }
// Print matrix utility (for debug)
RMDEF void PrintMatrix(Matrix m)
{
printf("----------------------\n");
printf("%2.2f %2.2f %2.2f %2.2f\n", m.m0, m.m4, m.m8, m.m12);
printf("%2.2f %2.2f %2.2f %2.2f\n", m.m1, m.m5, m.m9, m.m13);
printf("%2.2f %2.2f %2.2f %2.2f\n", m.m2, m.m6, m.m10, m.m14);
printf("%2.2f %2.2f %2.2f %2.2f\n", m.m3, m.m7, m.m11, m.m15);
printf("----------------------\n");
}
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Definition - Quaternion math // Module Functions Definition - Quaternion math
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------

29
src/rlgl.c
View file

@ -28,7 +28,7 @@
#include "rlgl.h" #include "rlgl.h"
#include <stdio.h> // Standard input / output lib #include <stdio.h> // Required for: fopen(), fclose(), fread()... [Used only on ReadTextFile()]
#include <stdlib.h> // Required for: malloc(), free(), rand() #include <stdlib.h> // Required for: malloc(), free(), rand()
#include <string.h> // Required for: strcmp(), strlen(), strtok() #include <string.h> // Required for: strcmp(), strlen(), strtok()
@ -48,8 +48,6 @@
#ifdef __APPLE__ #ifdef __APPLE__
#include <OpenGL/gl3.h> // OpenGL 3 library for OSX #include <OpenGL/gl3.h> // OpenGL 3 library for OSX
#else #else
//#define GLEW_STATIC
//#include <GL/glew.h> // GLEW header, includes OpenGL headers
#include "glad.h" // GLAD library, includes OpenGL headers #include "glad.h" // GLAD library, includes OpenGL headers
#endif #endif
#endif #endif
@ -61,8 +59,8 @@
#endif #endif
#if defined(RLGL_STANDALONE) #if defined(RLGL_STANDALONE)
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() #include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() [Used only on TraceLog()]
#endif // NOTE: Used on TraceLog() #endif
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Defines and Macros // Defines and Macros
@ -357,7 +355,6 @@ void rlRotatef(float angleDeg, float x, float y, float z)
Vector3 axis = (Vector3){ x, y, z }; Vector3 axis = (Vector3){ x, y, z };
VectorNormalize(&axis); VectorNormalize(&axis);
matRotation = MatrixRotate(axis, angleDeg*DEG2RAD); matRotation = MatrixRotate(axis, angleDeg*DEG2RAD);
MatrixTranspose(&matRotation); MatrixTranspose(&matRotation);
*currentMatrix = MatrixMultiply(*currentMatrix, matRotation); *currentMatrix = MatrixMultiply(*currentMatrix, matRotation);
@ -912,8 +909,8 @@ void rlglInit(void)
vaoSupported = true; vaoSupported = true;
npotSupported = true; npotSupported = true;
// NOTE: We don't need to check again supported extensions but we do (in case GLEW is replaced sometime)
// We get a list of available extensions and we check for some of them (compressed textures) // We get a list of available extensions and we check for some of them (compressed textures)
// NOTE: We don't need to check again supported extensions but we do (GLAD already dealt with that)
glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
const char *extList[numExt]; const char *extList[numExt];
@ -2155,7 +2152,7 @@ void UnloadShader(Shader shader)
} }
} }
// Set custom shader to be used on batch draw // Begin custom shader mode
void BeginShaderMode(Shader shader) void BeginShaderMode(Shader shader)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2167,7 +2164,7 @@ void BeginShaderMode(Shader shader)
#endif #endif
} }
// Set default shader to be used in batch draw // End custom shader mode (returns to default shader)
void EndShaderMode(void) void EndShaderMode(void)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2253,6 +2250,18 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
#endif #endif
} }
// Set a custom projection matrix (replaces internal projection matrix)
void SetMatrixProjection(Matrix proj)
{
projection = proj;
}
// Set a custom modelview matrix (replaces internal modelview matrix)
void SetMatrixModelview(Matrix view)
{
modelview = view;
}
// Begin blending mode (alpha, additive, multiplied) // Begin blending mode (alpha, additive, multiplied)
// NOTE: Only 3 blending modes supported, default blend mode is alpha // NOTE: Only 3 blending modes supported, default blend mode is alpha
void BeginBlendMode(int mode) void BeginBlendMode(int mode)
@ -3070,7 +3079,7 @@ static void UnloadDefaultBuffers(void)
free(quads.indices); free(quads.indices);
} }
// Sets shader uniform values for lights array // Setup shader uniform values for lights array
// NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0f // NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0f
static void SetShaderLights(Shader shader) static void SetShaderLights(Shader shader)
{ {

3
src/rlgl.h
View file

@ -329,6 +329,9 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // S
void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int) void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int)
void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4)
void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
void BeginShaderMode(Shader shader); // Begin custom shader drawing void BeginShaderMode(Shader shader); // Begin custom shader drawing
void EndShaderMode(void); // End custom shader drawing (use default shader) void EndShaderMode(void); // End custom shader drawing (use default shader)
void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)