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
#include "rlgl.h"
//#define PLATFORM_OCULUS
#define PLATFORM_OCULUS
#if defined(PLATFORM_OCULUS)
#include "OculusSDK/LibOVR/Include/OVR_CAPI_GL.h" // Oculus SDK for OpenGL
@ -72,7 +72,7 @@ typedef struct OculusMirror {
typedef struct OculusLayer {
ovrViewScaleDesc viewScaleDesc;
ovrLayerEyeFov eyeLayer; // layer 0
//ovrLayerQuad quadLayer; // layer 1
//ovrLayerQuad quadLayer; // TODO: layer 1: '2D' quad for GUI
Matrix eyeProjections[2];
int width;
int height;
@ -222,6 +222,7 @@ int main(void)
layer.eyeLayer.RenderPose[0] = eyePoses[0];
layer.eyeLayer.RenderPose[1] = eyePoses[1];
#endif
Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
//----------------------------------------------------------------------------------
// Draw
@ -229,13 +230,12 @@ int main(void)
#if defined(PLATFORM_OCULUS)
SetOculusBuffer(session, buffer);
#endif
rlClearScreenBuffers(); // Clear current framebuffers
rlClearScreenBuffers(); // Clear current framebuffer(s)
#if defined(PLATFORM_OCULUS)
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 };
QuaternionInvert(&eyeRPose);
@ -244,32 +244,39 @@ int main(void)
Matrix eyeView = MatrixMultiply(eyeTranslation, eyeOrientation);
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
// 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);
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
DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE);
DrawGrid(10, 1.0f);
// NOTE: Internal buffers drawing (3D data)
rlglDraw(mvp);
matProj = MatrixOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0);
MatrixTranspose(&matProj);
matView = MatrixIdentity();
mvp = MatrixMultiply(matView, matProj);
rlglDraw();
#if !defined(PLATFORM_OCULUS)
// Draw '2D' elements in the scene (GUI)
// 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)
rlglDraw(mvp);
rlglDraw();
#endif
#if defined(PLATFORM_OCULUS)
}
@ -593,14 +600,12 @@ static OculusBuffer LoadOculusBuffer(ovrSession session, int width, int height)
desc.Width = width;
desc.Height = height;
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.StaticImage = ovrFalse;
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");
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_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);
//glEnable(GL_FRAMEBUFFER_SRGB);
// Required if OculusBuffer format is OVR_FORMAT_R8G8B8A8_UNORM_SRGB
glEnable(GL_FRAMEBUFFER_SRGB);
}
// Unset Oculus buffer

80
examples/oculus_glfw_sample/rlgl.c
View file

@ -28,40 +28,38 @@
#include "rlgl.h"
#include <stdio.h> // Standard input / output lib
#include <stdlib.h> // Declares malloc() and free() for memory management, rand()
#include <string.h> // Declares strcmp(), strlen(), strtok()
#include <stdio.h> // Required for: fopen(), fclose(), fread()... [Used only on ReadTextFile()]
#include <stdlib.h> // Required for: malloc(), free(), rand()
#include <string.h> // Required for: strcmp(), strlen(), strtok()
#ifndef RLGL_STANDALONE
#include "raymath.h" // Required for Vector3 and Matrix functions
#include "raymath.h" // Required for Vector3 and Matrix functions
#endif
#if defined(GRAPHICS_API_OPENGL_11)
#ifdef __APPLE__ // OpenGL include for OSX
#include <OpenGL/gl.h>
#ifdef __APPLE__
#include <OpenGL/gl.h> // OpenGL 1.1 library for OSX
#else
#include <GL/gl.h> // Basic OpenGL include
#include <GL/gl.h> // OpenGL 1.1 library
#endif
#endif
#if defined(GRAPHICS_API_OPENGL_33)
#ifdef __APPLE__ // OpenGL include for OSX
#include <OpenGL/gl3.h>
#ifdef __APPLE__
#include <OpenGL/gl3.h> // OpenGL 3 library for OSX
#else
//#define GLEW_STATIC
//#include <GL/glew.h> // GLEW header, includes OpenGL headers
#include "glad.h" // glad header, includes OpenGL headers
#include "glad.h" // GLAD library, includes OpenGL headers
#endif
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <EGL/egl.h> // EGL library
#include <GLES2/gl2.h> // OpenGL ES 2.0 library
#include <GLES2/gl2ext.h> // OpenGL ES 2.0 extensions library
#endif
#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
//----------------------------------------------------------------------------------
@ -171,7 +169,6 @@ static Matrix modelview;
static Matrix projection;
static Matrix *currentMatrix;
static int currentMatrixMode;
static Matrix customMVP;
static DrawMode currentDrawMode;
@ -913,8 +910,8 @@ void rlglInit(void)
vaoSupported = 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)
// NOTE: We don't need to check again supported extensions but we do (GLAD already dealt with that)
glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
const char *extList[numExt];
@ -1083,10 +1080,8 @@ void rlglClose(void)
}
// 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)
/*
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[6] = 0; // Vertex indices VBO
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
int drawHint = GL_STATIC_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 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)
void rlglUpdateMesh(Mesh mesh, int buffer, int numVertex)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Activate mesh VAO
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);
// Now we can modify vertices
//glUnmapBuffer(GL_ARRAY_BUFFER);
#endif
}
// 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)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
if (currentShader.id != shader.id)
{
//rlglDraw();
rlglDraw();
currentShader = shader;
}
#endif
}
// Set default shader to be used in batch draw
// End custom shader mode (returns to default shader)
void EndShaderMode(void)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2254,13 +2251,25 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
#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)
// NOTE: Only 3 blending modes supported, default blend mode is alpha
void BeginBlendMode(int mode)
{
if ((blendMode != mode) && (mode < 3))
{
//rlglDraw();
rlglDraw();
switch (mode)
{
@ -2283,8 +2292,11 @@ void EndBlendMode(void)
// Create a new light, initialize it and add to pool
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
Light light = (Light)malloc(sizeof(LightData));
light = (Light)malloc(sizeof(LightData));
// Initialize light values with generic values
light->id = lightsCount;
@ -2301,13 +2313,18 @@ Light CreateLight(int type, Vector3 position, Color diffuse)
// Increase enabled lights count
lightsCount++;
#else
// TODO: Support OpenGL 1.1 lighting system
TraceLog(WARNING, "Lighting currently not supported on OpenGL 1.1");
#endif
return light;
}
// Destroy a light and take it out of the list
void DestroyLight(Light light)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Free dynamic memory allocation
free(lights[light->id]);
@ -2325,6 +2342,7 @@ void DestroyLight(Light light)
// Decrease enabled physic objects count
lightsCount--;
#endif
}
//----------------------------------------------------------------------------------
@ -2869,9 +2887,9 @@ static void DrawDefaultBuffers(void)
glUseProgram(currentShader.id);
// 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);
glUniform1i(currentShader.mapTexture0Loc, 0);
@ -3062,7 +3080,7 @@ static void UnloadDefaultBuffers(void)
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
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
#ifndef RLGL_STANDALONE
#include "raylib.h" // Required for typedef(s): Model, Shader, Texture2D
#include "utils.h" // Required for function TraceLog()
#include "raylib.h" // Required for: Model, Shader, Texture2D
#include "utils.h" // Required for: TraceLog()
#endif
#ifdef RLGL_STANDALONE
#define RAYMATH_STANDALONE
#endif
#include "raymath.h" // Required for types: Vector3, Matrix
#include "raymath.h" // Required for: Vector3, Matrix
// Select desired OpenGL version
// 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 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)
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 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 EndShaderMode(void); // End custom shader drawing (use default shader)
void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)

425
src/audio.c
View file

@ -35,29 +35,29 @@
#include "raylib.h"
#endif
#include "AL/al.h" // OpenAL basic header
#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/al.h" // OpenAL basic header
#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 <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
#include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strncmp()
#include <stdio.h> // Required for: FILE, fopen(), fclose(), fread()
#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
#include "utils.h" // Required for: DecompressData()
// NOTE: Includes Android fopen() function map
#include "utils.h" // Required for: DecompressData()
// NOTE: Includes Android fopen() function map
#endif
//#define STB_VORBIS_HEADER_ONLY
#include "stb_vorbis.h" // OGG loading functions
#include "stb_vorbis.h" // OGG loading functions
#define JAR_XM_IMPLEMENTATION
#include "jar_xm.h" // XM loading functions
#include "jar_xm.h" // XM loading functions
#define JAR_MOD_IMPLEMENTATION
#include "jar_mod.h" // For playing .mod files
#include "jar_mod.h" // MOD loading functions
//----------------------------------------------------------------------------------
// 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
bool floatingPoint; // if false then the short datatype is used instead
bool playing; // false if paused
ALenum alFormat; // openAL format specifier
ALuint alSource; // openAL source
ALuint alBuffer[MAX_STREAM_BUFFERS]; // openAL sample buffer
ALenum alFormat; // OpenAL format specifier
ALuint alSource; // OpenAL source
ALuint alBuffer[MAX_STREAM_BUFFERS]; // OpenAL sample buffer
} MixChannel_t;
// Music type (file streaming from memory)
// NOTE: Anything longer than ~10 seconds should be streamed into a mix channel...
typedef struct Music {
stb_vorbis *stream;
jar_xm_context_t *xmctx; // Stores jar_xm mixc, XM chiptune context
jar_mod_context_t modctx; // Stores mod chiptune context
jar_xm_context_t *xmctx; // XM chiptune context
jar_mod_context_t modctx; // MOD chiptune context
MixChannel_t *mixc; // mix channel
unsigned int totalSamplesLeft;
float totalLengthSeconds;
bool loop;
bool chipTune; // True if chiptune is loaded
bool chipTune; // chiptune is loaded?
} 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)
typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
#endif
@ -115,9 +135,11 @@ typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
//----------------------------------------------------------------------------------
// 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 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
@ -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 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 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 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 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 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
@ -153,13 +174,13 @@ void InitAudioDevice(void)
// Open and initialize a device with default settings
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);
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);
@ -177,11 +198,10 @@ void InitAudioDevice(void)
// Close the audio device for all contexts
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;
ALCcontext *context = alcGetCurrentContext();
@ -199,9 +219,12 @@ void CloseAudioDevice(void)
bool IsAudioDeviceReady(void)
{
ALCcontext *context = alcGetCurrentContext();
if (context == NULL) return false;
else{
else
{
ALCdevice *device = alcGetContextsDevice(context);
if (device == NULL) return false;
else return true;
}
@ -214,33 +237,30 @@ bool IsAudioDeviceReady(void)
// 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.
// 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(!IsAudioDeviceReady()) InitAudioDevice();
if (mixChannel >= MAX_MIX_CHANNELS) return NULL;
if (!IsAudioDeviceReady()) InitAudioDevice();
if(!mixChannels_g[mixChannel]){
MixChannel_t *mixc = (MixChannel_t*)malloc(sizeof(MixChannel_t));
if (!mixChannels_g[mixChannel])
{
MixChannel_t *mixc = (MixChannel_t *)malloc(sizeof(MixChannel_t));
mixc->sampleRate = sampleRate;
mixc->channels = channels;
mixc->mixChannel = mixChannel;
mixc->floatingPoint = floatingPoint;
mixChannels_g[mixChannel] = mixc;
// setup openAL format
if(channels == 1)
// Setup OpenAL format
if (channels == 1)
{
if(floatingPoint)
mixc->alFormat = AL_FORMAT_MONO_FLOAT32;
else
mixc->alFormat = AL_FORMAT_MONO16;
if (floatingPoint) mixc->alFormat = AL_FORMAT_MONO_FLOAT32;
else mixc->alFormat = AL_FORMAT_MONO16;
}
else if(channels == 2)
else if (channels == 2)
{
if(floatingPoint)
mixc->alFormat = AL_FORMAT_STEREO_FLOAT32;
else
mixc->alFormat = AL_FORMAT_STEREO16;
if (floatingPoint) mixc->alFormat = AL_FORMAT_STEREO_FLOAT32;
else mixc->alFormat = AL_FORMAT_STEREO16;
}
// Create an audio source
@ -253,10 +273,8 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
// Create Buffer
alGenBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
//fill buffers
int x;
for(x=0;x<MAX_STREAM_BUFFERS;x++)
FillAlBufferWithSilence(mixc, mixc->alBuffer[x]);
// Fill buffers
for (int i = 0; i < MAX_STREAM_BUFFERS; i++) FillAlBufferWithSilence(mixc, mixc->alBuffer[i]);
alSourceQueueBuffers(mixc->alSource, MAX_STREAM_BUFFERS, mixc->alBuffer);
mixc->playing = true;
@ -264,27 +282,30 @@ static MixChannel_t* InitMixChannel(unsigned short sampleRate, unsigned char mix
return mixc;
}
return NULL;
}
// Frees buffer in mix channel
static void CloseMixChannel(MixChannel_t* mixc)
static void CloseMixChannel(MixChannel_t *mixc)
{
if(mixc){
if (mixc)
{
alSourceStop(mixc->alSource);
mixc->playing = false;
//flush out all queued buffers
// Flush out all queued buffers
ALuint buffer = 0;
int queued = 0;
alGetSourcei(mixc->alSource, AL_BUFFERS_QUEUED, &queued);
while (queued > 0)
{
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
queued--;
}
//delete source and buffers
// Delete source and buffers
alDeleteSources(1, &mixc->alSource);
alDeleteBuffers(MAX_STREAM_BUFFERS, mixc->alBuffer);
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
// Call "BufferMixChannel(mixc, NULL, 0)" if you want to pause the audio.
// @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)
{ // pauses audio until data is given
if(mixc->playing){
if (!data || !numberElements)
{
// Pauses audio until data is given
if (mixc->playing)
{
alSourcePause(mixc->alSource);
mixc->playing = false;
}
return 0;
}
else if(!mixc->playing)
{ // restart audio otherwise
else if (!mixc->playing)
{
// Restart audio otherwise
alSourcePlay(mixc->alSource);
mixc->playing = true;
}
ALuint buffer = 0;
alSourceUnqueueBuffers(mixc->alSource, 1, &buffer);
if(!buffer) return 0;
if(mixc->floatingPoint) // process float buffers
if (!buffer) return 0;
if (mixc->floatingPoint)
{
float *ptr = (float*)data;
// Process float buffers
float *ptr = (float *)data;
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);
}
alSourceQueueBuffers(mixc->alSource, 1, &buffer);
return numberElements;
@ -337,15 +365,18 @@ static int BufferMixChannel(MixChannel_t* mixc, void *data, int numberElements)
// fill buffer with zeros, returns number processed
static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
{
if(mixc->floatingPoint){
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = {0.f};
if (mixc->floatingPoint)
{
float pcm[MUSIC_BUFFER_SIZE_FLOAT] = { 0.0f };
alBufferData(buffer, mixc->alFormat, pcm, MUSIC_BUFFER_SIZE_FLOAT*sizeof(float), mixc->sampleRate);
return MUSIC_BUFFER_SIZE_FLOAT;
}
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);
return MUSIC_BUFFER_SIZE_SHORT;
}
}
@ -355,13 +386,10 @@ static int FillAlBufferWithSilence(MixChannel_t *mixc, ALuint buffer)
// ResampleShortToFloat(sh,fl,3);
static void ResampleShortToFloat(short *shorts, float *floats, unsigned short len)
{
int x;
for(x=0;x<len;x++)
for (int i = 0; i < len; i++)
{
if(shorts[x] < 0)
floats[x] = (float)shorts[x] / 32766.f;
else
floats[x] = (float)shorts[x] / 32767.f;
if (shorts[i] < 0) floats[i] = (float)shorts[i]/32766.0f;
else floats[i] = (float)shorts[i]/32767.0f;
}
}
@ -370,13 +398,10 @@ static void ResampleShortToFloat(short *shorts, float *floats, unsigned short le
// ResampleByteToFloat(ch,fl,3);
static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
{
int x;
for(x=0;x<len;x++)
for (int i = 0; i < len; i++)
{
if(chars[x] < 0)
floats[x] = (float)chars[x] / 127.f;
else
floats[x] = (float)chars[x] / 128.f;
if (chars[i] < 0) floats[i] = (float)chars[i]/127.0f;
else floats[i] = (float)chars[i]/128.0f;
}
}
@ -385,22 +410,19 @@ static void ResampleByteToFloat(char *chars, float *floats, unsigned short len)
RawAudioContext InitRawAudioContext(int sampleRate, int channels, bool floatingPoint)
{
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;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error
if (mixChannels_g[mixIndex] == NULL) break;
else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
}
if(InitMixChannel(sampleRate, mixIndex, channels, floatingPoint))
return mixIndex;
else
return ERROR_RAW_CONTEXT_CREATION; // error
if (InitMixChannel(sampleRate, mixIndex, channels, floatingPoint)) return mixIndex;
else return ERROR_RAW_CONTEXT_CREATION; // error
}
void CloseRawAudioContext(RawAudioContext ctx)
{
if(mixChannels_g[ctx])
CloseMixChannel(mixChannels_g[ctx]);
if (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.
@ -409,18 +431,16 @@ void CloseRawAudioContext(RawAudioContext ctx)
int BufferRawAudioContext(RawAudioContext ctx, void *data, unsigned short numberElements)
{
int numBuffered = 0;
if(ctx >= 0)
if (ctx >= 0)
{
MixChannel_t* mixc = mixChannels_g[ctx];
numBuffered = BufferMixChannel(mixc, data, numberElements);
}
return numBuffered;
}
//----------------------------------------------------------------------------------
// 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);
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);
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)
@ -568,7 +591,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
if (rresFile == NULL)
{
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
{
@ -583,7 +606,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
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);
sound.error = ERROR_INVALID_RRES_FILE;
lastAudioError = ERROR_INVALID_RRES_FILE;
}
else
{
@ -674,7 +697,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId)
else
{
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
@ -776,24 +799,24 @@ void SetSoundPitch(Sound sound, float pitch)
// Start music playing (open stream)
// returns 0 on success
int PlayMusicStream(int musicIndex, char *fileName)
int PlayMusicStream(int index, char *fileName)
{
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;
else if(mixIndex == MAX_MIX_CHANNELS - 1) return ERROR_OUT_OF_MIX_CHANNELS; // error
if (mixChannels_g[mixIndex] == NULL) break;
else if (mixIndex == (MAX_MIX_CHANNELS - 1)) return ERROR_OUT_OF_MIX_CHANNELS; // error
}
if (strcmp(GetExtension(fileName),"ogg") == 0)
{
// 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);
return ERROR_LOADING_OGG; // error
@ -801,48 +824,53 @@ int PlayMusicStream(int musicIndex, char *fileName)
else
{
// 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 channels: %i", fileName, info.channels);
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;
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[musicIndex].stream) * info.channels;
musicChannels_g[musicIndex].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[musicIndex].stream);
musicChannels_g[index].totalSamplesLeft = (unsigned int)stb_vorbis_stream_length_in_samples(musicChannels_g[index].stream) * info.channels;
musicChannels_g[index].totalLengthSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
if (info.channels == 2){
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false);
musicChannels_g[musicIndex].mixc->playing = true;
if (info.channels == 2)
{
musicChannels_g[index].mixc = InitMixChannel(info.sample_rate, mixIndex, 2, false);
musicChannels_g[index].mixc->playing = true;
}
else{
musicChannels_g[musicIndex].mixc = InitMixChannel(info.sample_rate, mixIndex, 1, false);
musicChannels_g[musicIndex].mixc->playing = true;
else
{
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)
{
// 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[musicIndex].loop = true;
jar_xm_set_max_loop_count(musicChannels_g[musicIndex].xmctx, 0); // infinite number of loops
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)jar_xm_get_remaining_samples(musicChannels_g[musicIndex].xmctx);
musicChannels_g[musicIndex].totalLengthSeconds = ((float)musicChannels_g[musicIndex].totalSamplesLeft) / 48000.f;
musicChannels_g[index].chipTune = true;
musicChannels_g[index].loop = true;
jar_xm_set_max_loop_count(musicChannels_g[index].xmctx, 0); // infinite number of loops
musicChannels_g[index].totalSamplesLeft = (unsigned int)jar_xm_get_remaining_samples(musicChannels_g[index].xmctx);
musicChannels_g[index].totalLengthSeconds = ((float)musicChannels_g[index].totalSamplesLeft) / 48000.f;
musicEnabled_g = true;
TraceLog(INFO, "[%s] XM number of samples: %i", fileName, musicChannels_g[musicIndex].totalSamplesLeft);
TraceLog(INFO, "[%s] XM track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds);
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[index].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, true);
if(!musicChannels_g[musicIndex].mixc) return ERROR_XM_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true;
musicChannels_g[index].mixc = InitMixChannel(48000, mixIndex, 2, true);
if (!musicChannels_g[index].mixc) return ERROR_XM_CONTEXT_CREATION; // error
musicChannels_g[index].mixc->playing = true;
}
else
{
@ -852,21 +880,24 @@ int PlayMusicStream(int musicIndex, char *fileName)
}
else if (strcmp(GetExtension(fileName),"mod") == 0)
{
jar_mod_init(&musicChannels_g[musicIndex].modctx);
if(jar_mod_load_file(&musicChannels_g[musicIndex].modctx, fileName))
jar_mod_init(&musicChannels_g[index].modctx);
if (jar_mod_load_file(&musicChannels_g[index].modctx, fileName))
{
musicChannels_g[musicIndex].chipTune = true;
musicChannels_g[musicIndex].loop = true;
musicChannels_g[musicIndex].totalSamplesLeft = (unsigned int)jar_mod_max_samples(&musicChannels_g[musicIndex].modctx);
musicChannels_g[musicIndex].totalLengthSeconds = ((float)musicChannels_g[musicIndex].totalSamplesLeft) / 48000.f;
musicChannels_g[index].chipTune = true;
musicChannels_g[index].loop = true;
musicChannels_g[index].totalSamplesLeft = (unsigned int)jar_mod_max_samples(&musicChannels_g[index].modctx);
musicChannels_g[index].totalLengthSeconds = ((float)musicChannels_g[index].totalSamplesLeft) / 48000.f;
musicEnabled_g = true;
TraceLog(INFO, "[%s] MOD number of samples: %i", fileName, musicChannels_g[musicIndex].totalSamplesLeft);
TraceLog(INFO, "[%s] MOD track length: %11.6f sec", fileName, musicChannels_g[musicIndex].totalLengthSeconds);
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[index].totalLengthSeconds);
musicChannels_g[musicIndex].mixc = InitMixChannel(48000, mixIndex, 2, false);
if(!musicChannels_g[musicIndex].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
musicChannels_g[musicIndex].mixc->playing = true;
musicChannels_g[index].mixc = InitMixChannel(48000, mixIndex, 2, false);
if (!musicChannels_g[index].mixc) return ERROR_MOD_CONTEXT_CREATION; // error
musicChannels_g[index].mixc->playing = true;
}
else
{
@ -879,6 +910,7 @@ int PlayMusicStream(int musicIndex, char *fileName)
TraceLog(WARNING, "[%s] Music extension not recognized, it can't be loaded", fileName);
return ERROR_EXTENSION_NOT_RECOGNIZED; // error
}
return 0; // normal return
}
@ -894,17 +926,12 @@ void StopMusicStream(int index)
jar_xm_free_context(musicChannels_g[index].xmctx);
musicChannels_g[index].xmctx = 0;
}
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);
}
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);
if(!getMusicStreamCount()) musicEnabled_g = false;
if(musicChannels_g[index].stream || musicChannels_g[index].xmctx)
if (!GetMusicStreamCount()) musicEnabled_g = false;
if (musicChannels_g[index].stream || musicChannels_g[index].xmctx)
{
musicChannels_g[index].stream = 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
int getMusicStreamCount(void)
int GetMusicStreamCount(void)
{
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++;
}
return musicCount;
}
@ -939,8 +970,11 @@ void ResumeMusicStream(int index)
{
// Resume music playing... if music available!
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);
if (state == AL_PAUSED)
{
TraceLog(INFO, "Resuming music stream");
@ -956,8 +990,10 @@ bool IsMusicPlaying(int index)
bool playing = false;
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);
if (state == AL_PLAYING) playing = true;
}
@ -967,14 +1003,17 @@ bool IsMusicPlaying(int index)
// Set volume for music
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);
}
}
// Set pitch for music
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);
}
}
@ -983,14 +1022,9 @@ void SetMusicPitch(int index, float pitch)
float GetMusicTimeLength(int index)
{
float totalSeconds;
if (musicChannels_g[index].chipTune)
{
totalSeconds = (float)musicChannels_g[index].totalLengthSeconds;
}
else
{
totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
}
if (musicChannels_g[index].chipTune) totalSeconds = (float)musicChannels_g[index].totalLengthSeconds;
else totalSeconds = stb_vorbis_stream_length_in_seconds(musicChannels_g[index].stream);
return totalSeconds;
}
@ -999,7 +1033,8 @@ float GetMusicTimeLength(int index)
float GetMusicTimePlayed(int index)
{
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)
{
@ -1033,33 +1068,33 @@ static bool BufferMusicStream(int index, int numBuffers)
short pcm[MUSIC_BUFFER_SIZE_SHORT];
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
bool active = true; // We can get more data from stream (not finished)
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)
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].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT)
size = MUSIC_BUFFER_SIZE_SHORT / 2;
else
size = musicChannels_g[index].totalSamplesLeft / 2;
if (musicChannels_g[index].modctx.mod_loaded)
{
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size = MUSIC_BUFFER_SIZE_SHORT/2;
else size = musicChannels_g[index].totalSamplesLeft/2;
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){
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT)
size = MUSIC_BUFFER_SIZE_FLOAT / 2;
else
size = musicChannels_g[index].totalSamplesLeft / 2;
else if (musicChannels_g[index].xmctx)
{
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_FLOAT) size = MUSIC_BUFFER_SIZE_FLOAT/2;
else 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
BufferMixChannel(musicChannels_g[index].mixc, pcmf, size * 2);
BufferMixChannel(musicChannels_g[index].mixc, pcmf, size*2);
}
musicChannels_g[index].totalSamplesLeft -= size;
if(musicChannels_g[index].totalSamplesLeft <= 0)
if (musicChannels_g[index].totalSamplesLeft <= 0)
{
active = false;
break;
@ -1068,17 +1103,16 @@ static bool BufferMusicStream(int index, int numBuffers)
}
else
{
if(musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT)
size = MUSIC_BUFFER_SIZE_SHORT;
else
size = musicChannels_g[index].totalSamplesLeft;
if (musicChannels_g[index].totalSamplesLeft >= MUSIC_BUFFER_SIZE_SHORT) size = MUSIC_BUFFER_SIZE_SHORT;
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);
BufferMixChannel(musicChannels_g[index].mixc, pcm, 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;
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)
{
ALint processed = 0;
@ -1120,7 +1154,7 @@ void UpdateMusicStream(int index)
bool active = true;
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);
@ -1136,9 +1170,9 @@ void UpdateMusicStream(int index)
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;
}
active = true;
}
if (alGetError() != AL_NO_ERROR) TraceLog(WARNING, "Error buffering data...");
@ -1149,9 +1183,6 @@ void UpdateMusicStream(int index)
if (!active) StopMusicStream(index);
}
else
return;
}
// Load WAV file into Wave structure

22
src/audio.h
View file

@ -47,24 +47,6 @@
#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
typedef struct Sound {
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 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 StopMusicStream(int index); // Stop music playing (close stream)
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)
float GetMusicTimeLength(int index); // Get music time length (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);
// 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
#if defined(PLATFORM_DESKTOP)
#define GLAD_EXTENSIONS_LOADER
#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
#include "glad.h" // GLAD library: Manage OpenGL headers and extensions
#endif
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
@ -1576,33 +1570,15 @@ static void InitDisplay(int width, int height)
// Extensions initialization for OpenGL 3.3
if (rlGetVersion() == OPENGL_33)
{
#if defined(GLEW_EXTENSIONS_LOADER)
// Initialize extensions using GLEW
glewExperimental = 1; // Needed for core profile
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");
// 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...
// With GLEW, we can check if an extension has been loaded in two ways:
//if (GLEW_ARB_vertex_array_object) { }
//if (glewIsSupported("GL_ARB_vertex_array_object")) { }
// NOTE: GLEW is a big library that loads ALL extensions, we can use some alternative to load only required ones
// 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
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

29
src/easings.h
View file

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

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

2
src/raygui.c
View file

@ -667,7 +667,7 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
Vector2 mousePoint = GetMousePosition();
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;

29
src/raylib.h
View file

@ -452,29 +452,10 @@ typedef struct Ray {
Vector3 direction;
} 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
typedef struct Sound {
unsigned int source;
unsigned int buffer;
AudioError error; // if there was any error during the creation or use of this Sound
} Sound;
// Wave type, defines audio wave data
@ -488,8 +469,6 @@ typedef struct Wave {
typedef int RawAudioContext;
// Texture formats
// NOTE: Support depends on OpenGL version and platform
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 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 EndShaderMode(void); // End custom shader drawing (use default shader)
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
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)
@ -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 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 StopMusicStream(int index); // Stop music playing (close stream)
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)
float GetMusicTimeLength(int index); // Get current music time length (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);
// 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 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 void PrintMatrix(Matrix m); // Print matrix utility
//------------------------------------------------------------------------------------
// 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)
#include <stdio.h> // Used only on PrintMatrix()
#include <math.h> // Standard math libary: sin(), cos(), tan()...
#include <stdlib.h> // Used for abs()
#include <math.h> // Required for: sinf(), cosf(), tan(), fabs()
//----------------------------------------------------------------------------------
// Module Functions Definition - Vector3 math
@ -342,15 +339,14 @@ RMDEF Vector3 VectorReflect(Vector3 vector, Vector3 normal)
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)
{
float x = v->x;
float y = v->y;
float z = v->z;
//MatrixTranspose(&mat);
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->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;
}
// 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
//----------------------------------------------------------------------------------

29
src/rlgl.c
View file

@ -28,7 +28,7 @@
#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 <string.h> // Required for: strcmp(), strlen(), strtok()
@ -48,8 +48,6 @@
#ifdef __APPLE__
#include <OpenGL/gl3.h> // OpenGL 3 library for OSX
#else
//#define GLEW_STATIC
//#include <GL/glew.h> // GLEW header, includes OpenGL headers
#include "glad.h" // GLAD library, includes OpenGL headers
#endif
#endif
@ -61,8 +59,8 @@
#endif
#if defined(RLGL_STANDALONE)
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end()
#endif // NOTE: Used on TraceLog()
#include <stdarg.h> // Required for: va_list, va_start(), vfprintf(), va_end() [Used only on TraceLog()]
#endif
//----------------------------------------------------------------------------------
// Defines and Macros
@ -357,7 +355,6 @@ void rlRotatef(float angleDeg, float x, float y, float z)
Vector3 axis = (Vector3){ x, y, z };
VectorNormalize(&axis);
matRotation = MatrixRotate(axis, angleDeg*DEG2RAD);
MatrixTranspose(&matRotation);
*currentMatrix = MatrixMultiply(*currentMatrix, matRotation);
@ -912,8 +909,8 @@ void rlglInit(void)
vaoSupported = 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)
// NOTE: We don't need to check again supported extensions but we do (GLAD already dealt with that)
glGetIntegerv(GL_NUM_EXTENSIONS, &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)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2167,7 +2164,7 @@ void BeginShaderMode(Shader shader)
#endif
}
// Set default shader to be used in batch draw
// End custom shader mode (returns to default shader)
void EndShaderMode(void)
{
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
@ -2253,6 +2250,18 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
#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)
// NOTE: Only 3 blending modes supported, default blend mode is alpha
void BeginBlendMode(int mode)
@ -3070,7 +3079,7 @@ static void UnloadDefaultBuffers(void)
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
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 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 EndShaderMode(void); // End custom shader drawing (use default shader)
void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)