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

Update C library

Browse source
This commit is contained in:
Milan Nikolic 2017-11-14 04:10:20 +01:00
parent 793e521511
commit 2d8472fb63
11 changed files with 360 additions and 302 deletions
Download patch file Download diff file Expand all files Collapse all files

0
examples/android/example/bootstrap.sh Executable file → Normal file
View file

52
raylib/core.c
View file

@ -3,17 +3,18 @@
* raylib.core - Basic functions to manage windows, OpenGL context and input on multiple platforms * raylib.core - Basic functions to manage windows, OpenGL context and input on multiple platforms
* *
* PLATFORMS SUPPORTED: * PLATFORMS SUPPORTED:
* - Windows (win32/Win64) * - Windows (Win32, Win64)
* - Linux (tested on Ubuntu) * - Linux (tested on Ubuntu)
* - OSX (Mac) * - FreeBSD
* - Android (ARM or ARM64) * - OSX/macOS
* - Android (ARM, ARM64)
* - Raspberry Pi (Raspbian) * - Raspberry Pi (Raspbian)
* - HTML5 (Chrome, Firefox) * - HTML5 (Chrome, Firefox)
* *
* CONFIGURATION: * CONFIGURATION:
* *
* #define PLATFORM_DESKTOP * #define PLATFORM_DESKTOP
* Windowing and input system configured for desktop platforms: Windows, Linux, OSX (managed by GLFW3 library) * Windowing and input system configured for desktop platforms: Windows, Linux, OSX, FreeBSD (managed by GLFW3 library)
* NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for mirror rendering - View [rlgl] module to enable it * NOTE: Oculus Rift CV1 requires PLATFORM_DESKTOP for mirror rendering - View [rlgl] module to enable it
* *
* #define PLATFORM_ANDROID * #define PLATFORM_ANDROID
@ -278,10 +279,11 @@ static int renderOffsetY = 0; // Offset Y from render area (must b
static bool fullscreen = false; // Fullscreen mode (useful only for PLATFORM_DESKTOP) static bool fullscreen = false; // Fullscreen mode (useful only for PLATFORM_DESKTOP)
static Matrix downscaleView; // Matrix to downscale view (in case screen size bigger than display size) static Matrix downscaleView; // Matrix to downscale view (in case screen size bigger than display size)
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
static const char *windowTitle; // Window text title...
static bool cursorOnScreen = false; // Tracks if cursor is inside client area
static bool cursorHidden = false; // Track if cursor is hidden static bool cursorHidden = false; // Track if cursor is hidden
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
static const char *windowTitle = NULL; // Window text title...
static bool cursorOnScreen = false; // Tracks if cursor is inside client area
static int screenshotCounter = 0; // Screenshots counter static int screenshotCounter = 0; // Screenshots counter
// Register mouse states // Register mouse states
@ -408,12 +410,13 @@ static void *GamepadThread(void *arg); // Mouse reading thread
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
// Initialize window and OpenGL context // Initialize window and OpenGL context
void InitWindow(int width, int height, const char *title) // NOTE: data parameter could be used to pass any kind of required data to the initialization
void InitWindow(int width, int height, void *data)
{ {
TraceLog(LOG_INFO, "Initializing raylib (v1.8.0)"); TraceLog(LOG_INFO, "Initializing raylib (v1.8.0)");
// Store window title (could be useful...) // Input data is window title char data
windowTitle = title; windowTitle = (char *)data;
// Init graphics device (display device and OpenGL context) // Init graphics device (display device and OpenGL context)
InitGraphicsDevice(width, height); InitGraphicsDevice(width, height);
@ -470,15 +473,17 @@ void InitWindow(int width, int height, const char *title)
#endif #endif
#if defined(PLATFORM_ANDROID) #if defined(PLATFORM_ANDROID)
// Initialize Android activity // Initialize window and OpenGL context (and Android activity)
void InitWindow(int width, int height, void *state) // NOTE: data parameter could be used to pass any kind of required data to the initialization
void InitWindow(int width, int height, void *data)
{ {
TraceLog(LOG_INFO, "Initializing raylib (v1.8.0)"); TraceLog(LOG_INFO, "Initializing raylib (v1.8.0)");
screenWidth = width; screenWidth = width;
screenHeight = height; screenHeight = height;
app = (struct android_app *)state; // Input data is android app pointer
app = (struct android_app *)data;
internalDataPath = app->activity->internalDataPath; internalDataPath = app->activity->internalDataPath;
// Set desired windows flags before initializing anything // Set desired windows flags before initializing anything
@ -507,7 +512,6 @@ void InitWindow(int width, int height, void *state)
//AConfiguration_getScreenSize(app->config); //AConfiguration_getScreenSize(app->config);
//AConfiguration_getScreenLong(app->config); //AConfiguration_getScreenLong(app->config);
//state->userData = &engine;
app->onAppCmd = AndroidCommandCallback; app->onAppCmd = AndroidCommandCallback;
app->onInputEvent = AndroidInputCallback; app->onInputEvent = AndroidInputCallback;
@ -708,7 +712,6 @@ int GetScreenHeight(void)
return screenHeight; return screenHeight;
} }
#if !defined(PLATFORM_ANDROID)
// Show mouse cursor // Show mouse cursor
void ShowCursor() void ShowCursor()
{ {
@ -771,7 +774,6 @@ void DisableCursor()
#endif #endif
cursorHidden = true; cursorHidden = true;
} }
#endif // !defined(PLATFORM_ANDROID)
// Set background color (framebuffer clear color) // Set background color (framebuffer clear color)
void ClearBackground(Color color) void ClearBackground(Color color)
@ -1108,9 +1110,7 @@ Color Fade(Color color, float alpha)
if (alpha < 0.0f) alpha = 0.0f; if (alpha < 0.0f) alpha = 0.0f;
else if (alpha > 1.0f) alpha = 1.0f; else if (alpha > 1.0f) alpha = 1.0f;
float colorAlpha = (float)color.a*alpha; return (Color){color.r, color.g, color.b, (unsigned char)(255.0f*alpha)};
return (Color){color.r, color.g, color.b, (unsigned char)colorAlpha};
} }
// Activate raylib logo at startup (can be done with flags) // Activate raylib logo at startup (can be done with flags)
@ -2525,6 +2525,8 @@ static void WindowSizeCallback(GLFWwindow *window, int width, int height)
rlClearScreenBuffers(); // Clear screen buffers (color and depth) rlClearScreenBuffers(); // Clear screen buffers (color and depth)
// Window size must be updated to be used on 3D mode to get new aspect ratio (Begin3dMode()) // Window size must be updated to be used on 3D mode to get new aspect ratio (Begin3dMode())
// NOTE: Be careful! GLFW3 will choose the closest fullscreen resolution supported by current monitor,
// for example, if reescaling back to 800x450 (desired), it could set 720x480 (closest fullscreen supported)
screenWidth = width; screenWidth = width;
screenHeight = height; screenHeight = height;
renderWidth = width; renderWidth = width;
@ -2776,8 +2778,16 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event)
ProcessGestureEvent(gestureEvent); ProcessGestureEvent(gestureEvent);
#else #else
// TODO: Support only simple touch position // Support only simple touch position
if (flags == AMOTION_EVENT_ACTION_DOWN)
{
// Get first touch position
touchPosition[0].x = AMotionEvent_getX(event, 0);
touchPosition[0].y = AMotionEvent_getY(event, 0);
touchPosition[0].x /= (float)GetScreenWidth();
touchPosition[0].y /= (float)GetScreenHeight();
}
#endif #endif
return 0; return 0;

8
raylib/core.go
View file

@ -624,7 +624,7 @@ func GetHexValue(color Color) int32 {
return v return v
} }
// ColorToFloat - Converts Color to float array and normalizes // ColorToFloat - Converts Color to float32 slice and normalizes
func ColorToFloat(color Color) []float32 { func ColorToFloat(color Color) []float32 {
data := make([]float32, 0) data := make([]float32, 0)
data[0] = float32(color.R) / 255 data[0] = float32(color.R) / 255
@ -635,8 +635,8 @@ func ColorToFloat(color Color) []float32 {
return data return data
} }
// VectorToFloat - Converts Vector3 to float array // Vector3ToFloat - Converts Vector3 to float32 slice
func VectorToFloat(vec Vector3) []float32 { func Vector3ToFloat(vec Vector3) []float32 {
data := make([]float32, 0) data := make([]float32, 0)
data[0] = vec.X data[0] = vec.X
data[1] = vec.Y data[1] = vec.Y
@ -645,7 +645,7 @@ func VectorToFloat(vec Vector3) []float32 {
return data return data
} }
// MatrixToFloat - Converts Matrix to float array // MatrixToFloat - Converts Matrix to float32 slice
func MatrixToFloat(mat Matrix) []float32 { func MatrixToFloat(mat Matrix) []float32 {
data := make([]float32, 0) data := make([]float32, 0)

46
raylib/external/rgif.h vendored
View file

@ -150,7 +150,7 @@ typedef struct GifBitStatus {
// The LZW dictionary is a 256-ary tree constructed // The LZW dictionary is a 256-ary tree constructed
// as the file is encoded, this is one node // as the file is encoded, this is one node
typedef struct GifLzwNode { typedef struct GifLzwNode {
uint16_t m_next[256]; unsigned short m_next[256];
} GifLzwNode; } GifLzwNode;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -299,9 +299,9 @@ static void GifGetClosestPaletteColor(GifPalette *pPal, int r, int g, int b, int
if (ind == gifTransparentIndex) return; if (ind == gifTransparentIndex) return;
// check whether this color is better than the current winner // check whether this color is better than the current winner
int r_err = r - ((int32_t)pPal->r[ind]); int r_err = r - ((int)pPal->r[ind]);
int g_err = g - ((int32_t)pPal->g[ind]); int g_err = g - ((int)pPal->g[ind]);
int b_err = b - ((int32_t)pPal->b[ind]); int b_err = b - ((int)pPal->b[ind]);
int diff = GIFABS(r_err)+GIFABS(g_err)+GIFABS(b_err); int diff = GIFABS(r_err)+GIFABS(g_err)+GIFABS(b_err);
if (diff < *bestDiff) if (diff < *bestDiff)
@ -463,7 +463,7 @@ static void GifSplitPalette(unsigned char *image, int numPixels, int firstElt, i
} }
// otherwise, take the average of all colors in this subcube // otherwise, take the average of all colors in this subcube
uint64_t r=0, g=0, b=0; unsigned long long r=0, g=0, b=0;
for (int ii=0; ii<numPixels; ++ii) for (int ii=0; ii<numPixels; ++ii)
{ {
r += image[ii*4+0]; r += image[ii*4+0];
@ -594,12 +594,12 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
// quantPixels initially holds color*256 for all pixels // quantPixels initially holds color*256 for all pixels
// The extra 8 bits of precision allow for sub-single-color error values // The extra 8 bits of precision allow for sub-single-color error values
// to be propagated // to be propagated
int32_t *quantPixels = (int32_t*)GIF_TEMP_MALLOC(sizeof(int32_t)*numPixels*4); int *quantPixels = (int*)GIF_TEMP_MALLOC(sizeof(int)*numPixels*4);
for (int ii=0; ii<numPixels*4; ++ii) for (int ii=0; ii<numPixels*4; ++ii)
{ {
unsigned char pix = nextFrame[ii]; unsigned char pix = nextFrame[ii];
int32_t pix16 = (int32_t)pix*256; int pix16 = (int)pix*256;
quantPixels[ii] = pix16; quantPixels[ii] = pix16;
} }
@ -607,13 +607,13 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
{ {
for (unsigned int xx=0; xx<width; ++xx) for (unsigned int xx=0; xx<width; ++xx)
{ {
int32_t *nextPix = quantPixels + 4*(yy*width+xx); int *nextPix = quantPixels + 4*(yy*width+xx);
const unsigned char *lastPix = lastFrame? lastFrame + 4*(yy*width+xx) : NULL; const unsigned char *lastPix = lastFrame? lastFrame + 4*(yy*width+xx) : NULL;
// Compute the colors we want (rounding to nearest) // Compute the colors we want (rounding to nearest)
int32_t rr = (nextPix[0] + 127) / 256; int rr = (nextPix[0] + 127) / 256;
int32_t gg = (nextPix[1] + 127) / 256; int gg = (nextPix[1] + 127) / 256;
int32_t bb = (nextPix[2] + 127) / 256; int bb = (nextPix[2] + 127) / 256;
// if it happens that we want the color from last frame, then just write out // if it happens that we want the color from last frame, then just write out
// a transparent pixel // a transparent pixel
@ -629,16 +629,16 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
continue; continue;
} }
int32_t bestDiff = 1000000; int bestDiff = 1000000;
int32_t bestInd = gifTransparentIndex; int bestInd = gifTransparentIndex;
// Search the palete // Search the palete
GifGetClosestPaletteColor(pPal, rr, gg, bb, &bestInd, &bestDiff, 1); GifGetClosestPaletteColor(pPal, rr, gg, bb, &bestInd, &bestDiff, 1);
// Write the result to the temp buffer // Write the result to the temp buffer
int32_t r_err = nextPix[0] - (int32_t)(pPal->r[bestInd])*256; int r_err = nextPix[0] - (int)(pPal->r[bestInd])*256;
int32_t g_err = nextPix[1] - (int32_t)(pPal->g[bestInd])*256; int g_err = nextPix[1] - (int)(pPal->g[bestInd])*256;
int32_t b_err = nextPix[2] - (int32_t)(pPal->b[bestInd])*256; int b_err = nextPix[2] - (int)(pPal->b[bestInd])*256;
nextPix[0] = pPal->r[bestInd]; nextPix[0] = pPal->r[bestInd];
nextPix[1] = pPal->g[bestInd]; nextPix[1] = pPal->g[bestInd];
@ -654,7 +654,7 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
if (quantloc_7 < numPixels) if (quantloc_7 < numPixels)
{ {
int32_t *pix7 = quantPixels+4*quantloc_7; int *pix7 = quantPixels+4*quantloc_7;
pix7[0] += GIFMAX(-pix7[0], r_err*7 / 16); pix7[0] += GIFMAX(-pix7[0], r_err*7 / 16);
pix7[1] += GIFMAX(-pix7[1], g_err*7 / 16); pix7[1] += GIFMAX(-pix7[1], g_err*7 / 16);
pix7[2] += GIFMAX(-pix7[2], b_err*7 / 16); pix7[2] += GIFMAX(-pix7[2], b_err*7 / 16);
@ -662,7 +662,7 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
if (quantloc_3 < numPixels) if (quantloc_3 < numPixels)
{ {
int32_t *pix3 = quantPixels+4*quantloc_3; int *pix3 = quantPixels+4*quantloc_3;
pix3[0] += GIFMAX(-pix3[0], r_err*3 / 16); pix3[0] += GIFMAX(-pix3[0], r_err*3 / 16);
pix3[1] += GIFMAX(-pix3[1], g_err*3 / 16); pix3[1] += GIFMAX(-pix3[1], g_err*3 / 16);
pix3[2] += GIFMAX(-pix3[2], b_err*3 / 16); pix3[2] += GIFMAX(-pix3[2], b_err*3 / 16);
@ -670,7 +670,7 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
if (quantloc_5 < numPixels) if (quantloc_5 < numPixels)
{ {
int32_t *pix5 = quantPixels+4*quantloc_5; int *pix5 = quantPixels+4*quantloc_5;
pix5[0] += GIFMAX(-pix5[0], r_err*5 / 16); pix5[0] += GIFMAX(-pix5[0], r_err*5 / 16);
pix5[1] += GIFMAX(-pix5[1], g_err*5 / 16); pix5[1] += GIFMAX(-pix5[1], g_err*5 / 16);
pix5[2] += GIFMAX(-pix5[2], b_err*5 / 16); pix5[2] += GIFMAX(-pix5[2], b_err*5 / 16);
@ -678,7 +678,7 @@ static void GifDitherImage(const unsigned char *lastFrame, const unsigned char *
if (quantloc_1 < numPixels) if (quantloc_1 < numPixels)
{ {
int32_t *pix1 = quantPixels+4*quantloc_1; int *pix1 = quantPixels+4*quantloc_1;
pix1[0] += GIFMAX(-pix1[0], r_err / 16); pix1[0] += GIFMAX(-pix1[0], r_err / 16);
pix1[1] += GIFMAX(-pix1[1], g_err / 16); pix1[1] += GIFMAX(-pix1[1], g_err / 16);
pix1[2] += GIFMAX(-pix1[2], b_err / 16); pix1[2] += GIFMAX(-pix1[2], b_err / 16);
@ -716,8 +716,8 @@ static void GifThresholdImage(const unsigned char *lastFrame, const unsigned cha
else else
{ {
// palettize the pixel // palettize the pixel
int32_t bestDiff = 1000000; int bestDiff = 1000000;
int32_t bestInd = 1; int bestInd = 1;
GifGetClosestPaletteColor(pPal, nextFrame[0], nextFrame[1], nextFrame[2], &bestInd, &bestDiff, 1); GifGetClosestPaletteColor(pPal, nextFrame[0], nextFrame[1], nextFrame[2], &bestInd, &bestDiff, 1);
// Write the resulting color to the output buffer // Write the resulting color to the output buffer
@ -835,7 +835,7 @@ static void GifWriteLzwImage(FILE *f, unsigned char *image, unsigned int left, u
GifLzwNode *codetree = (GifLzwNode *)GIF_TEMP_MALLOC(sizeof(GifLzwNode)*4096); GifLzwNode *codetree = (GifLzwNode *)GIF_TEMP_MALLOC(sizeof(GifLzwNode)*4096);
memset(codetree, 0, sizeof(GifLzwNode)*4096); memset(codetree, 0, sizeof(GifLzwNode)*4096);
int32_t curCode = -1; int curCode = -1;
unsigned int codeSize = minCodeSize + 1; unsigned int codeSize = minCodeSize + 1;
unsigned int maxCode = clearCode + 1; unsigned int maxCode = clearCode + 1;

5
raylib/platform_arm.go
View file

@ -21,8 +21,9 @@ func InitWindow(width int32, height int32, t interface{}) {
title, ok := t.(string) title, ok := t.(string)
if ok { if ok {
ctitle := C.CString(title) ctitle := C.CString(title)
defer C.free(unsafe.Pointer(ctitle)) cptitle := unsafe.Pointer(ctitle)
C.InitWindow(cwidth, cheight, ctitle) defer C.free(cptitle)
C.InitWindow(cwidth, cheight, cptitle)
} }
} }

5
raylib/platform_desktop.go
View file

@ -21,8 +21,9 @@ func InitWindow(width int32, height int32, t interface{}) {
title, ok := t.(string) title, ok := t.(string)
if ok { if ok {
ctitle := C.CString(title) ctitle := C.CString(title)
defer C.free(unsafe.Pointer(ctitle)) cptitle := unsafe.Pointer(ctitle)
C.InitWindow(cwidth, cheight, ctitle) defer C.free(cptitle)
C.InitWindow(cwidth, cheight, cptitle)
} }
} }

56
raylib/raylib.go
View file

@ -39,6 +39,62 @@ import (
"runtime" "runtime"
) )
// CallQueueCap is the capacity of the call queue.
//
// The default value is 16.
var CallQueueCap = 16
// callInMain calls a function in the main thread. It is only properly initialized inside raylib.Main(..).
// As a default, it panics.
var callInMain = func(f func()) {
panic("raylib.Main(main func()) must be called before raylib.Do(f func())")
}
func init() { func init() {
// Make sure the main goroutine is bound to the main thread.
runtime.LockOSThread() runtime.LockOSThread()
} }
// Main entry point. Run this function at the beginning of main(), and pass your own main body to it as a function. E.g.:
//
// func main() {
// raylib.Main(func() {
// // Your code here....
// // [....]
//
// // Calls to raylib can be made by any goroutine, but always guarded by raylib.Do()
// raylib.Do(func() {
// raylib.DrawTexture(..)
// })
// })
// }
func Main(main func()) {
// Queue of functions that are thread-sensitive
callQueue := make(chan func(), CallQueueCap)
done := make(chan bool, 1)
// Properly initialize callInMain for use by raylib.Do(..)
callInMain = func(f func()) {
callQueue <- func() {
f()
done <- true
}
<-done
}
go func() {
main()
close(callQueue)
}()
for f := range callQueue {
f()
}
}
// Do queues function f on the main thread and blocks until the function f finishes
func Do(f func()) {
callInMain(f)
}

57
raylib/raylib.h
View file

@ -72,20 +72,6 @@
#ifndef RAYLIB_H #ifndef RAYLIB_H
#define RAYLIB_H #define RAYLIB_H
// Choose your platform here or just define it at compile time: -DPLATFORM_DESKTOP
//#define PLATFORM_DESKTOP // Windows, Linux or OSX
//#define PLATFORM_ANDROID // Android device
//#define PLATFORM_RPI // Raspberry Pi
//#define PLATFORM_WEB // HTML5 (emscripten, asm.js)
// Security check in case no PLATFORM_* defined
#if !defined(PLATFORM_DESKTOP) && \
!defined(PLATFORM_ANDROID) && \
!defined(PLATFORM_RPI) && \
!defined(PLATFORM_WEB)
#define PLATFORM_DESKTOP
#endif
#if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
#define RLAPI __declspec(dllexport) // We are building raylib as a Win32 shared library (.dll) #define RLAPI __declspec(dllexport) // We are building raylib as a Win32 shared library (.dll)
#elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
@ -179,13 +165,11 @@
#define KEY_Y 89 #define KEY_Y 89
#define KEY_Z 90 #define KEY_Z 90
#if defined(PLATFORM_ANDROID) // Android Physical Buttons
// Android Physical Buttons #define KEY_BACK 4
#define KEY_BACK 4 #define KEY_MENU 82
#define KEY_MENU 82 #define KEY_VOLUME_UP 24
#define KEY_VOLUME_UP 24 #define KEY_VOLUME_DOWN 25
#define KEY_VOLUME_DOWN 25
#endif
// Mouse Buttons // Mouse Buttons
#define MOUSE_LEFT_BUTTON 0 #define MOUSE_LEFT_BUTTON 0
@ -710,11 +694,7 @@ extern "C" { // Prevents name mangling of functions
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
// Window-related functions // Window-related functions
#if defined(PLATFORM_ANDROID) RLAPI void InitWindow(int width, int height, void *data); // Initialize window and OpenGL context
RLAPI void InitWindow(int width, int height, void *state); // Initialize Android activity
#elif defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context
#endif
RLAPI void CloseWindow(void); // Close window and unload OpenGL context RLAPI void CloseWindow(void); // Close window and unload OpenGL context
RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed
RLAPI bool IsWindowMinimized(void); // Check if window has been minimized (or lost focus) RLAPI bool IsWindowMinimized(void); // Check if window has been minimized (or lost focus)
@ -727,14 +707,12 @@ RLAPI void SetWindowMinSize(int width, int height); // Set window
RLAPI int GetScreenWidth(void); // Get current screen width RLAPI int GetScreenWidth(void); // Get current screen width
RLAPI int GetScreenHeight(void); // Get current screen height RLAPI int GetScreenHeight(void); // Get current screen height
#if !defined(PLATFORM_ANDROID)
// Cursor-related functions // Cursor-related functions
RLAPI void ShowCursor(void); // Shows cursor RLAPI void ShowCursor(void); // Shows cursor
RLAPI void HideCursor(void); // Hides cursor RLAPI void HideCursor(void); // Hides cursor
RLAPI bool IsCursorHidden(void); // Check if cursor is not visible RLAPI bool IsCursorHidden(void); // Check if cursor is not visible
RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) RLAPI void EnableCursor(void); // Enables cursor (unlock cursor)
RLAPI void DisableCursor(void); // Disables cursor (lock cursor) RLAPI void DisableCursor(void); // Disables cursor (lock cursor)
#endif
// Drawing-related functions // Drawing-related functions
RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color)
@ -764,7 +742,7 @@ RLAPI Color Fade(Color color, float alpha); // Color fade-
RLAPI float *ColorToFloat(Color color); // Converts Color to float array and normalizes RLAPI float *ColorToFloat(Color color); // Converts Color to float array and normalizes
// Math useful functions (available from raymath.h) // Math useful functions (available from raymath.h)
RLAPI float *VectorToFloat(Vector3 vec); // Returns Vector3 as float array RLAPI float *Vector3ToFloat(Vector3 vec); // Returns Vector3 as float array
RLAPI float *MatrixToFloat(Matrix mat); // Returns Matrix as float array RLAPI float *MatrixToFloat(Matrix mat); // Returns Matrix as float array
RLAPI Vector3 Vector3Zero(void); // Vector with components value 0.0f RLAPI Vector3 Vector3Zero(void); // Vector with components value 0.0f
RLAPI Vector3 Vector3One(void); // Vector with components value 1.0f RLAPI Vector3 Vector3One(void); // Vector with components value 1.0f
@ -1075,8 +1053,8 @@ RLAPI Texture2D GetTextureDefault(void); // Get
// Shader configuration functions // Shader configuration functions
RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location
RLAPI void SetShaderValue(Shader shader, int uniformLoc, float *value, int size); // Set shader uniform value (float) RLAPI void SetShaderValue(Shader shader, int uniformLoc, const float *value, int size); // Set shader uniform value (float)
RLAPI void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size); // Set shader uniform value (int) RLAPI void SetShaderValuei(Shader shader, int uniformLoc, const int *value, int size); // Set shader uniform value (int)
RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4)
RLAPI void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) RLAPI void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
RLAPI void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) RLAPI void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
@ -1095,14 +1073,15 @@ RLAPI void BeginBlendMode(int mode); // Beg
RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending)
// VR control functions // VR control functions
VrDeviceInfo GetVrDeviceInfo(int vrDeviceType); // Get VR device information for some standard devices RLAPI VrDeviceInfo GetVrDeviceInfo(int vrDeviceType); // Get VR device information for some standard devices
void InitVrSimulator(VrDeviceInfo info); // Init VR simulator for selected device parameters RLAPI void InitVrSimulator(VrDeviceInfo info); // Init VR simulator for selected device parameters
RLAPI void CloseVrSimulator(void); // Close VR simulator for current device RLAPI void CloseVrSimulator(void); // Close VR simulator for current device
RLAPI bool IsVrSimulatorReady(void); // Detect if VR simulator is ready RLAPI bool IsVrSimulatorReady(void); // Detect if VR simulator is ready
RLAPI void UpdateVrTracking(Camera *camera); // Update VR tracking (position and orientation) and camera RLAPI void SetVrDistortionShader(Shader shader); // Set VR distortion shader for stereoscopic rendering
RLAPI void ToggleVrMode(void); // Enable/Disable VR experience RLAPI void UpdateVrTracking(Camera *camera); // Update VR tracking (position and orientation) and camera
RLAPI void BeginVrDrawing(void); // Begin VR simulator stereo rendering RLAPI void ToggleVrMode(void); // Enable/Disable VR experience
RLAPI void EndVrDrawing(void); // End VR simulator stereo rendering RLAPI void BeginVrDrawing(void); // Begin VR simulator stereo rendering
RLAPI void EndVrDrawing(void); // End VR simulator stereo rendering
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
// Audio Loading and Playing Functions (Module: audio) // Audio Loading and Playing Functions (Module: audio)

321
raylib/rlgl.c
View file

@ -170,6 +170,11 @@
#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
#endif #endif
#if defined(GRAPHICS_API_OPENGL_21)
#define GL_LUMINANCE 0x1909
#define GL_LUMINANCE_ALPHA 0x190A
#endif
#if defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_ES2)
#define glClearDepth glClearDepthf #define glClearDepth glClearDepthf
#define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER
@ -227,7 +232,7 @@ typedef struct DrawCall {
typedef struct VrStereoConfig { typedef struct VrStereoConfig {
RenderTexture2D stereoFbo; // VR stereo rendering framebuffer RenderTexture2D stereoFbo; // VR stereo rendering framebuffer
Shader distortionShader; // VR stereo rendering distortion shader Shader distortionShader; // VR stereo rendering distortion shader
//Rectangle eyesViewport[2]; // VR stereo rendering eyes viewports Rectangle eyesViewport[2]; // VR stereo rendering eyes viewports
Matrix eyesProjection[2]; // VR stereo rendering eyes projection matrices Matrix eyesProjection[2]; // VR stereo rendering eyes projection matrices
Matrix eyesViewOffset[2]; // VR stereo rendering eyes view offset matrices Matrix eyesViewOffset[2]; // VR stereo rendering eyes view offset matrices
} VrStereoConfig; } VrStereoConfig;
@ -262,7 +267,9 @@ static Vector3 *tempBuffer;
static int tempBufferCount = 0; static int tempBufferCount = 0;
static bool useTempBuffer = false; static bool useTempBuffer = false;
// Shader Programs // Shaders
static unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program)
static unsigned int defaultFShaderId; // Default fragment shader Id (used by default shader program)
static Shader defaultShader; // Basic shader, support vertex color and diffuse texture static Shader defaultShader; // Basic shader, support vertex color and diffuse texture
static Shader currentShader; // Shader to be used on rendering (by default, defaultShader) static Shader currentShader; // Shader to be used on rendering (by default, defaultShader)
@ -319,7 +326,9 @@ static int screenHeight; // Default framebuffer height
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
static void LoadTextureCompressed(unsigned char *data, int width, int height, int compressedFormat, int mipmapCount); static void LoadTextureCompressed(unsigned char *data, int width, int height, int compressedFormat, int mipmapCount);
static unsigned int LoadShaderProgram(const char *vShaderStr, const char *fShaderStr); // Load custom shader strings and return program id
static unsigned int CompileShader(const char *shaderStr, int type); // Compile custom shader and return shader id
static unsigned int LoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program
static Shader LoadShaderDefault(void); // Load default shader (just vertex positioning and texture coloring) static Shader LoadShaderDefault(void); // Load default shader (just vertex positioning and texture coloring)
static void SetShaderDefaultLocations(Shader *shader); // Bind default shader locations (attributes and uniforms) static void SetShaderDefaultLocations(Shader *shader); // Bind default shader locations (attributes and uniforms)
@ -1378,7 +1387,40 @@ unsigned int rlLoadTexture(void *data, int width, int height, int format, int mi
glBindTexture(GL_TEXTURE_2D, id); glBindTexture(GL_TEXTURE_2D, id);
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2)
// NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
switch (format)
{
case UNCOMPRESSED_GRAYSCALE: glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_GRAY_ALPHA: glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_R5G6B5: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, (unsigned short *)data); break;
case UNCOMPRESSED_R8G8B8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_R5G5B5A1: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (unsigned short *)data); break;
case UNCOMPRESSED_R4G4B4A4: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (unsigned short *)data); break;
case UNCOMPRESSED_R8G8B8A8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
#if defined(GRAPHICS_API_OPENGL_21)
case COMPRESSED_DXT1_RGB: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT1_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT3_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, mipmapCount); break;
case COMPRESSED_DXT5_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, mipmapCount); break;
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
case UNCOMPRESSED_R32G32B32: if (texFloatSupported) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_FLOAT, (float *)data); break; // NOTE: Requires extension OES_texture_float
case COMPRESSED_DXT1_RGB: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT1_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT3_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, mipmapCount); break; // NOTE: Not supported by WebGL
case COMPRESSED_DXT5_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, mipmapCount); break; // NOTE: Not supported by WebGL
case COMPRESSED_ETC1_RGB: if (texCompETC1Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_ETC1_RGB8_OES, mipmapCount); break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
case COMPRESSED_ETC2_RGB: if (texCompETC2Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB8_ETC2, mipmapCount); break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
case COMPRESSED_ETC2_EAC_RGBA: if (texCompETC2Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA8_ETC2_EAC, mipmapCount); break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
case COMPRESSED_PVRT_RGB: if (texCompPVRTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, mipmapCount); break; // NOTE: Requires PowerVR GPU
case COMPRESSED_PVRT_RGBA: if (texCompPVRTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, mipmapCount); break; // NOTE: Requires PowerVR GPU
case COMPRESSED_ASTC_4x4_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_4x4_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
case COMPRESSED_ASTC_8x8_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_8x8_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
#endif
default: TraceLog(LOG_WARNING, "Texture format not supported"); break;
}
#elif defined(GRAPHICS_API_OPENGL_33)
// NOTE: We define internal (GPU) format as GL_RGBA8 (probably BGRA8 in practice, driver takes care) // NOTE: We define internal (GPU) format as GL_RGBA8 (probably BGRA8 in practice, driver takes care)
// NOTE: On embedded systems, we let the driver choose the best internal format // NOTE: On embedded systems, we let the driver choose the best internal format
@ -1431,33 +1473,6 @@ unsigned int rlLoadTexture(void *data, int width, int height, int format, int mi
case COMPRESSED_ASTC_8x8_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_8x8_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 case COMPRESSED_ASTC_8x8_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_8x8_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
default: TraceLog(LOG_WARNING, "Texture format not recognized"); break; default: TraceLog(LOG_WARNING, "Texture format not recognized"); break;
} }
#elif defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_ES2)
// NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
switch (format)
{
case UNCOMPRESSED_GRAYSCALE: glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_GRAY_ALPHA: glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, width, height, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_R5G6B5: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, (unsigned short *)data); break;
case UNCOMPRESSED_R8G8B8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
case UNCOMPRESSED_R5G5B5A1: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, (unsigned short *)data); break;
case UNCOMPRESSED_R4G4B4A4: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, (unsigned short *)data); break;
case UNCOMPRESSED_R8G8B8A8: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char *)data); break;
#if defined(GRAPHICS_API_OPENGL_ES2)
case UNCOMPRESSED_R32G32B32: if (texFloatSupported) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_FLOAT, (float *)data); break; // NOTE: Requires extension OES_texture_float
case COMPRESSED_DXT1_RGB: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT1_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, mipmapCount); break;
case COMPRESSED_DXT3_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, mipmapCount); break; // NOTE: Not supported by WebGL
case COMPRESSED_DXT5_RGBA: if (texCompDXTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, mipmapCount); break; // NOTE: Not supported by WebGL
case COMPRESSED_ETC1_RGB: if (texCompETC1Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_ETC1_RGB8_OES, mipmapCount); break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
case COMPRESSED_ETC2_RGB: if (texCompETC2Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB8_ETC2, mipmapCount); break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
case COMPRESSED_ETC2_EAC_RGBA: if (texCompETC2Supported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA8_ETC2_EAC, mipmapCount); break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
case COMPRESSED_PVRT_RGB: if (texCompPVRTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, mipmapCount); break; // NOTE: Requires PowerVR GPU
case COMPRESSED_PVRT_RGBA: if (texCompPVRTSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, mipmapCount); break; // NOTE: Requires PowerVR GPU
case COMPRESSED_ASTC_4x4_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_4x4_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
case COMPRESSED_ASTC_8x8_RGBA: if (texCompASTCSupported) LoadTextureCompressed((unsigned char *)data, width, height, GL_COMPRESSED_RGBA_ASTC_8x8_KHR, mipmapCount); break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
#endif
default: TraceLog(LOG_WARNING, "Texture format not supported"); break;
}
#endif #endif
// Texture parameters configuration // Texture parameters configuration
@ -1575,10 +1590,10 @@ RenderTexture2D rlLoadRenderTexture(int width, int height)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
#if defined(GRAPHICS_API_OPENGL_33) #if defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2)
#define USE_DEPTH_TEXTURE
#else
#define USE_DEPTH_RENDERBUFFER #define USE_DEPTH_RENDERBUFFER
#else
#define USE_DEPTH_TEXTURE
#endif #endif
#if defined(USE_DEPTH_RENDERBUFFER) #if defined(USE_DEPTH_RENDERBUFFER)
@ -1937,17 +1952,17 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
// Upload to shader material.colDiffuse // Upload to shader material.colDiffuse
if (material.shader.locs[LOC_COLOR_DIFFUSE] != -1) if (material.shader.locs[LOC_COLOR_DIFFUSE] != -1)
glUniform4f(material.shader.locs[LOC_COLOR_DIFFUSE], (float)material.maps[MAP_DIFFUSE].color.r/255, glUniform4f(material.shader.locs[LOC_COLOR_DIFFUSE], (float)material.maps[MAP_DIFFUSE].color.r/255.0f,
(float)material.maps[MAP_DIFFUSE].color.g/255, (float)material.maps[MAP_DIFFUSE].color.g/255.0f,
(float)material.maps[MAP_DIFFUSE].color.b/255, (float)material.maps[MAP_DIFFUSE].color.b/255.0f,
(float)material.maps[MAP_DIFFUSE].color.a/255); (float)material.maps[MAP_DIFFUSE].color.a/255.0f);
// Upload to shader material.colSpecular (if available) // Upload to shader material.colSpecular (if available)
if (material.shader.locs[LOC_COLOR_SPECULAR] != -1) if (material.shader.locs[LOC_COLOR_SPECULAR] != -1)
glUniform4f(material.shader.locs[LOC_COLOR_SPECULAR], (float)material.maps[MAP_SPECULAR].color.r/255, glUniform4f(material.shader.locs[LOC_COLOR_SPECULAR], (float)material.maps[MAP_SPECULAR].color.r/255.0f,
(float)material.maps[MAP_SPECULAR].color.g/255, (float)material.maps[MAP_SPECULAR].color.g/255.0f,
(float)material.maps[MAP_SPECULAR].color.b/255, (float)material.maps[MAP_SPECULAR].color.b/255.0f,
(float)material.maps[MAP_SPECULAR].color.a/255); (float)material.maps[MAP_SPECULAR].color.a/255.0f);
if (material.shader.locs[LOC_MATRIX_VIEW] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_VIEW], modelview); if (material.shader.locs[LOC_MATRIX_VIEW] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_VIEW], modelview);
if (material.shader.locs[LOC_MATRIX_PROJECTION] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_PROJECTION], projection); if (material.shader.locs[LOC_MATRIX_PROJECTION] != -1) SetShaderValueMatrix(material.shader, material.shader.locs[LOC_MATRIX_PROJECTION], projection);
@ -2226,8 +2241,8 @@ void *rlReadTexturePixels(Texture2D texture)
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
//glDisable(GL_BLEND); //glDisable(GL_BLEND);
glViewport(0, 0, width, height); glViewport(0, 0, texture.width, texture.height);
rlOrtho(0.0, width, height, 0.0, 0.0, 1.0); rlOrtho(0.0, texture.width, texture.height, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(GetShaderDefault().id); glUseProgram(GetShaderDefault().id);
@ -2340,33 +2355,47 @@ char *LoadText(const char *fileName)
} }
// Load shader from files and bind default locations // Load shader from files and bind default locations
// NOTE: If shader string is NULL, using default vertex/fragment shaders
Shader LoadShader(char *vsFileName, char *fsFileName) Shader LoadShader(char *vsFileName, char *fsFileName)
{ {
Shader shader = { 0 }; Shader shader = { 0 };
// NOTE: All locations must be reseted to -1 (no location)
for (int i = 0; i < MAX_SHADER_LOCATIONS; i++) shader.locs[i] = -1;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Shaders loading from external text file
char *vShaderStr = LoadText(vsFileName);
char *fShaderStr = LoadText(fsFileName);
if ((vShaderStr != NULL) && (fShaderStr != NULL)) unsigned int vertexShaderId, fragmentShaderId;
if (vsFileName == NULL) vertexShaderId = defaultVShaderId;
else
{ {
shader.id = LoadShaderProgram(vShaderStr, fShaderStr); char *vShaderStr = LoadText(vsFileName);
vertexShaderId = CompileShader(vShaderStr, GL_VERTEX_SHADER);
// After shader loading, we TRY to set default location names
if (shader.id > 0) SetShaderDefaultLocations(&shader);
// Shader strings must be freed
free(vShaderStr); free(vShaderStr);
}
if (fsFileName == NULL) fragmentShaderId = defaultVShaderId;
else
{
char* fShaderStr = LoadText(fsFileName);
fragmentShaderId = CompileShader(fShaderStr, GL_FRAGMENT_SHADER);
free(fShaderStr); free(fShaderStr);
} }
shader.id = LoadShaderProgram(vertexShaderId, fragmentShaderId);
if (vertexShaderId != defaultVShaderId) glDeleteShader(vertexShaderId);
if (fragmentShaderId != defaultFShaderId) glDeleteShader(fragmentShaderId);
if (shader.id == 0) if (shader.id == 0)
{ {
TraceLog(LOG_WARNING, "Custom shader could not be loaded"); TraceLog(LOG_WARNING, "Custom shader could not be loaded");
shader = defaultShader; shader = defaultShader;
} }
// After shader loading, we TRY to set default location names
if (shader.id > 0) SetShaderDefaultLocations(&shader);
// Get available shader uniforms // Get available shader uniforms
// NOTE: This information is useful for debug... // NOTE: This information is useful for debug...
@ -2391,7 +2420,6 @@ Shader LoadShader(char *vsFileName, char *fsFileName)
TraceLog(LOG_DEBUG, "[SHDR ID %i] Active uniform [%s] set at location: %i", shader.id, name, location); TraceLog(LOG_DEBUG, "[SHDR ID %i] Active uniform [%s] set at location: %i", shader.id, name, location);
} }
#endif #endif
return shader; return shader;
@ -2441,7 +2469,7 @@ int GetShaderLocation(Shader shader, const char *uniformName)
} }
// Set shader uniform value (float) // Set shader uniform value (float)
void SetShaderValue(Shader shader, int uniformLoc, float *value, int size) void SetShaderValue(Shader shader, int uniformLoc, const float *value, int size)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
glUseProgram(shader.id); glUseProgram(shader.id);
@ -2457,7 +2485,7 @@ void SetShaderValue(Shader shader, int uniformLoc, float *value, int size)
} }
// Set shader uniform value (int) // Set shader uniform value (int)
void SetShaderValuei(Shader shader, int uniformLoc, int *value, int size) void SetShaderValuei(Shader shader, int uniformLoc, const int *value, int size)
{ {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
glUseProgram(shader.id); glUseProgram(shader.id);
@ -2898,11 +2926,15 @@ void InitVrSimulator(VrDeviceInfo info)
vrConfig.stereoFbo = rlLoadRenderTexture(screenWidth, screenHeight); vrConfig.stereoFbo = rlLoadRenderTexture(screenWidth, screenHeight);
#if defined(SUPPORT_DISTORTION_SHADER) #if defined(SUPPORT_DISTORTION_SHADER)
// Load distortion shader (initialized by default with Oculus Rift CV1 parameters) // Load distortion shader
vrConfig.distortionShader.id = LoadShaderProgram(vDistortionShaderStr, fDistortionShaderStr); unsigned int vertexShaderId = CompileShader(distortionVShaderStr, GL_VERTEX_SHADER);
unsigned int fragmentShaderId = CompileShader(distortionFShaderStr, GL_FRAGMENT_SHADER);
vrConfig.distortionShader.id = LoadShaderProgram(vertexShaderId, fragmentShaderId);
if (vrConfig.distortionShader.id > 0) SetShaderDefaultLocations(&vrConfig.distortionShader); if (vrConfig.distortionShader.id > 0) SetShaderDefaultLocations(&vrConfig.distortionShader);
#endif #endif
// Set VR configutarion parameters, including distortion shader
SetStereoConfig(info); SetStereoConfig(info);
vrSimulatorReady = true; vrSimulatorReady = true;
@ -2927,18 +2959,6 @@ void CloseVrSimulator(void)
#endif #endif
} }
// TODO: Review VR system to be more flexible,
// move distortion shader to user side,
// SetStereoConfig() must be reviewed...
/*
// Set VR view distortion shader
void SetVrDistortionShader(Shader shader)
{
vrConfig.distortionShader = shader;
SetStereoConfig(info);
}
*/
// Detect if VR simulator is running // Detect if VR simulator is running
bool IsVrSimulatorReady(void) bool IsVrSimulatorReady(void)
{ {
@ -2949,6 +2969,15 @@ bool IsVrSimulatorReady(void)
#endif #endif
} }
// Set VR distortion shader for stereoscopic rendering
// TODO: Review VR system to be more flexible, move distortion shader to user side
void SetVrDistortionShader(Shader shader)
{
vrConfig.distortionShader = shader;
//SetStereoConfig(info); // TODO: Must be reviewed to set new distortion shader uniform values...
}
// Enable/Disable VR experience (device or simulator) // Enable/Disable VR experience (device or simulator)
void ToggleVrMode(void) void ToggleVrMode(void)
{ {
@ -3113,86 +3142,53 @@ static void LoadTextureCompressed(unsigned char *data, int width, int height, in
} }
} }
// Compile custom shader and return shader id
static unsigned int CompileShader(const char *shaderStr, int type)
{
unsigned int shader = glCreateShader(type);
glShaderSource(shader, 1, &shaderStr, NULL);
GLint success = 0;
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (success != GL_TRUE)
{
TraceLog(LOG_WARNING, "[SHDR ID %i] Failed to compile shader...", shader);
int maxLength = 0;
int length;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
#ifdef _MSC_VER
char *log = malloc(maxLength);
#else
char log[maxLength];
#endif
glGetShaderInfoLog(shader, maxLength, &length, log);
TraceLog(LOG_INFO, "%s", log);
#ifdef _MSC_VER
free(log);
#endif
}
else TraceLog(LOG_INFO, "[SHDR ID %i] Shader compiled successfully", shader);
return shader;
}
// Load custom shader strings and return program id // Load custom shader strings and return program id
static unsigned int LoadShaderProgram(const char *vShaderStr, const char *fShaderStr) static unsigned int LoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId)
{ {
unsigned int program = 0; unsigned int program = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
GLuint vertexShader;
GLuint fragmentShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const char *pvs = vShaderStr;
const char *pfs = fShaderStr;
glShaderSource(vertexShader, 1, &pvs, NULL);
glShaderSource(fragmentShader, 1, &pfs, NULL);
GLint success = 0; GLint success = 0;
glCompileShader(vertexShader);
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (success != GL_TRUE)
{
TraceLog(LOG_WARNING, "[VSHDR ID %i] Failed to compile vertex shader...", vertexShader);
int maxLength = 0;
int length;
glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &maxLength);
#ifdef _MSC_VER
char *log = malloc(maxLength);
#else
char log[maxLength];
#endif
glGetShaderInfoLog(vertexShader, maxLength, &length, log);
TraceLog(LOG_INFO, "%s", log);
#ifdef _MSC_VER
free(log);
#endif
}
else TraceLog(LOG_INFO, "[VSHDR ID %i] Vertex shader compiled successfully", vertexShader);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (success != GL_TRUE)
{
TraceLog(LOG_WARNING, "[FSHDR ID %i] Failed to compile fragment shader...", fragmentShader);
int maxLength = 0;
int length;
glGetShaderiv(fragmentShader, GL_INFO_LOG_LENGTH, &maxLength);
#ifdef _MSC_VER
char *log = malloc(maxLength);
#else
char log[maxLength];
#endif
glGetShaderInfoLog(fragmentShader, maxLength, &length, log);
TraceLog(LOG_INFO, "%s", log);
#ifdef _MSC_VER
free(log);
#endif
}
else TraceLog(LOG_INFO, "[FSHDR ID %i] Fragment shader compiled successfully", fragmentShader);
program = glCreateProgram(); program = glCreateProgram();
glAttachShader(program, vertexShader); glAttachShader(program, vShaderId);
glAttachShader(program, fragmentShader); glAttachShader(program, fShaderId);
// NOTE: Default attribute shader locations must be binded before linking // NOTE: Default attribute shader locations must be binded before linking
glBindAttribLocation(program, 0, DEFAULT_ATTRIB_POSITION_NAME); glBindAttribLocation(program, 0, DEFAULT_ATTRIB_POSITION_NAME);
@ -3236,9 +3232,6 @@ static unsigned int LoadShaderProgram(const char *vShaderStr, const char *fShade
program = 0; program = 0;
} }
else TraceLog(LOG_INFO, "[SHDR ID %i] Shader program loaded successfully", program); else TraceLog(LOG_INFO, "[SHDR ID %i] Shader program loaded successfully", program);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
#endif #endif
return program; return program;
} }
@ -3248,10 +3241,13 @@ static unsigned int LoadShaderProgram(const char *vShaderStr, const char *fShade
// NOTE: This shader program is used for batch buffers (lines, triangles, quads) // NOTE: This shader program is used for batch buffers (lines, triangles, quads)
static Shader LoadShaderDefault(void) static Shader LoadShaderDefault(void)
{ {
Shader shader; Shader shader = { 0 };
// NOTE: All locations must be reseted to -1 (no location)
for (int i = 0; i < MAX_SHADER_LOCATIONS; i++) shader.locs[i] = -1;
// Vertex shader directly defined, no external file required // Vertex shader directly defined, no external file required
char vDefaultShaderStr[] = char defaultVShaderStr[] =
#if defined(GRAPHICS_API_OPENGL_21) #if defined(GRAPHICS_API_OPENGL_21)
"#version 120 \n" "#version 120 \n"
#elif defined(GRAPHICS_API_OPENGL_ES2) #elif defined(GRAPHICS_API_OPENGL_ES2)
@ -3280,7 +3276,7 @@ static Shader LoadShaderDefault(void)
"} \n"; "} \n";
// Fragment shader directly defined, no external file required // Fragment shader directly defined, no external file required
char fDefaultShaderStr[] = char defaultFShaderStr[] =
#if defined(GRAPHICS_API_OPENGL_21) #if defined(GRAPHICS_API_OPENGL_21)
"#version 120 \n" "#version 120 \n"
#elif defined(GRAPHICS_API_OPENGL_ES2) #elif defined(GRAPHICS_API_OPENGL_ES2)
@ -3309,22 +3305,29 @@ static Shader LoadShaderDefault(void)
#endif #endif
"} \n"; "} \n";
shader.id = LoadShaderProgram(vDefaultShaderStr, fDefaultShaderStr); // NOTE: Compiled vertex/fragment shaders are kept for re-use
defaultVShaderId = CompileShader(defaultVShaderStr, GL_VERTEX_SHADER); // Compile default vertex shader
defaultFShaderId = CompileShader(defaultFShaderStr, GL_FRAGMENT_SHADER); // Compile default fragment shader
shader.id = LoadShaderProgram(defaultVShaderId, defaultFShaderId);
if (shader.id > 0) if (shader.id > 0)
{ {
TraceLog(LOG_INFO, "[SHDR ID %i] Default shader loaded successfully", shader.id); TraceLog(LOG_INFO, "[SHDR ID %i] Default shader loaded successfully", shader.id);
// Set default shader locations // Set default shader locations: attributes locations
// Get handles to GLSL input attibute locations
shader.locs[LOC_VERTEX_POSITION] = glGetAttribLocation(shader.id, "vertexPosition"); shader.locs[LOC_VERTEX_POSITION] = glGetAttribLocation(shader.id, "vertexPosition");
shader.locs[LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader.id, "vertexTexCoord"); shader.locs[LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(shader.id, "vertexTexCoord");
shader.locs[LOC_VERTEX_COLOR] = glGetAttribLocation(shader.id, "vertexColor"); shader.locs[LOC_VERTEX_COLOR] = glGetAttribLocation(shader.id, "vertexColor");
// Get handles to GLSL uniform locations // Set default shader locations: uniform locations
shader.locs[LOC_MATRIX_MVP] = glGetUniformLocation(shader.id, "mvp"); shader.locs[LOC_MATRIX_MVP] = glGetUniformLocation(shader.id, "mvp");
shader.locs[LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader.id, "colDiffuse"); shader.locs[LOC_COLOR_DIFFUSE] = glGetUniformLocation(shader.id, "colDiffuse");
shader.locs[LOC_MAP_DIFFUSE] = glGetUniformLocation(shader.id, "texture0"); shader.locs[LOC_MAP_DIFFUSE] = glGetUniformLocation(shader.id, "texture0");
// NOTE: We could also use below function but in case DEFAULT_ATTRIB_* points are
// changed for external custom shaders, we just use direct bindings above
//SetShaderDefaultLocations(&shader);
} }
else TraceLog(LOG_WARNING, "[SHDR ID %i] Default shader could not be loaded", shader.id); else TraceLog(LOG_WARNING, "[SHDR ID %i] Default shader could not be loaded", shader.id);
@ -3368,10 +3371,10 @@ static void UnloadShaderDefault(void)
{ {
glUseProgram(0); glUseProgram(0);
//glDetachShader(defaultShader, vertexShader); glDetachShader(defaultShader.id, defaultVShaderId);
//glDetachShader(defaultShader, fragmentShader); glDetachShader(defaultShader.id, defaultFShaderId);
//glDeleteShader(vertexShader); // Already deleted on shader compilation glDeleteShader(defaultVShaderId);
//glDeleteShader(fragmentShader); // Already deleted on shader compilation glDeleteShader(defaultFShaderId);
glDeleteProgram(defaultShader.id); glDeleteProgram(defaultShader.id);
} }
@ -4021,8 +4024,8 @@ static void SetStereoConfig(VrDeviceInfo hmd)
vrConfig.eyesViewOffset[1] = MatrixTranslate(hmd.interpupillaryDistance*0.5f, 0.075f, 0.045f); vrConfig.eyesViewOffset[1] = MatrixTranslate(hmd.interpupillaryDistance*0.5f, 0.075f, 0.045f);
// Compute eyes Viewports // Compute eyes Viewports
//vrConfig.eyesViewport[0] = (Rectangle){ 0, 0, hmd.hResolution/2, hmd.vResolution }; vrConfig.eyesViewport[0] = (Rectangle){ 0, 0, hmd.hResolution/2, hmd.vResolution };
//vrConfig.eyesViewport[1] = (Rectangle){ hmd.hResolution/2, 0, hmd.hResolution/2, hmd.vResolution }; vrConfig.eyesViewport[1] = (Rectangle){ hmd.hResolution/2, 0, hmd.hResolution/2, hmd.vResolution };
} }
// Set internal projection and modelview matrix depending on eyes tracking data // Set internal projection and modelview matrix depending on eyes tracking data

108
raylib/rlgl.h
View file

@ -145,56 +145,6 @@ typedef unsigned char byte;
// Boolean type // Boolean type
typedef enum { false, true } bool; typedef enum { false, true } bool;
#endif #endif
// Shader location point type
typedef enum {
LOC_VERTEX_POSITION = 0,
LOC_VERTEX_TEXCOORD01,
LOC_VERTEX_TEXCOORD02,
LOC_VERTEX_NORMAL,
LOC_VERTEX_TANGENT,
LOC_VERTEX_COLOR,
LOC_MATRIX_MVP,
LOC_MATRIX_MODEL,
LOC_MATRIX_VIEW,
LOC_MATRIX_PROJECTION,
LOC_VECTOR_VIEW,
LOC_COLOR_DIFFUSE,
LOC_COLOR_SPECULAR,
LOC_COLOR_AMBIENT,
LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE
LOC_MAP_METALNESS, // LOC_MAP_SPECULAR
LOC_MAP_NORMAL,
LOC_MAP_ROUGHNESS,
LOC_MAP_OCCUSION,
LOC_MAP_EMISSION,
LOC_MAP_HEIGHT,
LOC_MAP_CUBEMAP,
LOC_MAP_IRRADIANCE,
LOC_MAP_PREFILTER,
LOC_MAP_BRDF
} ShaderLocationIndex;
#define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
#define LOC_MAP_SPECULAR LOC_MAP_METALNESS
// Material map type
typedef enum {
MAP_ALBEDO = 0, // MAP_DIFFUSE
MAP_METALNESS = 1, // MAP_SPECULAR
MAP_NORMAL = 2,
MAP_ROUGHNESS = 3,
MAP_OCCLUSION,
MAP_EMISSION,
MAP_HEIGHT,
MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_BRDF
} TexmapIndex;
#define MAP_DIFFUSE MAP_ALBEDO
#define MAP_SPECULAR MAP_METALNESS
// Color type, RGBA (32bit) // Color type, RGBA (32bit)
typedef struct Color { typedef struct Color {
@ -204,6 +154,14 @@ typedef unsigned char byte;
unsigned char a; unsigned char a;
} Color; } Color;
// Rectangle type
typedef struct Rectangle {
int x;
int y;
int width;
int height;
} Rectangle;
// Texture2D type // Texture2D type
// NOTE: Data stored in GPU memory // NOTE: Data stored in GPU memory
typedef struct Texture2D { typedef struct Texture2D {
@ -341,6 +299,56 @@ typedef unsigned char byte;
BLEND_MULTIPLIED BLEND_MULTIPLIED
} BlendMode; } BlendMode;
// Shader location point type
typedef enum {
LOC_VERTEX_POSITION = 0,
LOC_VERTEX_TEXCOORD01,
LOC_VERTEX_TEXCOORD02,
LOC_VERTEX_NORMAL,
LOC_VERTEX_TANGENT,
LOC_VERTEX_COLOR,
LOC_MATRIX_MVP,
LOC_MATRIX_MODEL,
LOC_MATRIX_VIEW,
LOC_MATRIX_PROJECTION,
LOC_VECTOR_VIEW,
LOC_COLOR_DIFFUSE,
LOC_COLOR_SPECULAR,
LOC_COLOR_AMBIENT,
LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE
LOC_MAP_METALNESS, // LOC_MAP_SPECULAR
LOC_MAP_NORMAL,
LOC_MAP_ROUGHNESS,
LOC_MAP_OCCUSION,
LOC_MAP_EMISSION,
LOC_MAP_HEIGHT,
LOC_MAP_CUBEMAP,
LOC_MAP_IRRADIANCE,
LOC_MAP_PREFILTER,
LOC_MAP_BRDF
} ShaderLocationIndex;
#define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
#define LOC_MAP_SPECULAR LOC_MAP_METALNESS
// Material map type
typedef enum {
MAP_ALBEDO = 0, // MAP_DIFFUSE
MAP_METALNESS = 1, // MAP_SPECULAR
MAP_NORMAL = 2,
MAP_ROUGHNESS = 3,
MAP_OCCLUSION,
MAP_EMISSION,
MAP_HEIGHT,
MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
MAP_BRDF
} TexmapIndex;
#define MAP_DIFFUSE MAP_ALBEDO
#define MAP_SPECULAR MAP_METALNESS
// VR Head Mounted Display devices // VR Head Mounted Display devices
typedef enum { typedef enum {
HMD_DEFAULT_DEVICE = 0, HMD_DEFAULT_DEVICE = 0,

4
raylib/shader_distortion.h
View file

@ -1,6 +1,6 @@
// Vertex shader definition to embed, no external file required // Vertex shader definition to embed, no external file required
static const char vDistortionShaderStr[] = static const char distortionVShaderStr[] =
#if defined(GRAPHICS_API_OPENGL_21) #if defined(GRAPHICS_API_OPENGL_21)
"#version 120 \n" "#version 120 \n"
#elif defined(GRAPHICS_API_OPENGL_ES2) #elif defined(GRAPHICS_API_OPENGL_ES2)
@ -29,7 +29,7 @@ static const char vDistortionShaderStr[] =
"} \n"; "} \n";
// Fragment shader definition to embed, no external file required // Fragment shader definition to embed, no external file required
static const char fDistortionShaderStr[] = static const char distortionFShaderStr[] =
#if defined(GRAPHICS_API_OPENGL_21) #if defined(GRAPHICS_API_OPENGL_21)
"#version 120 \n" "#version 120 \n"
#elif defined(GRAPHICS_API_OPENGL_ES2) #elif defined(GRAPHICS_API_OPENGL_ES2)