| // stbgl - v0.04 - Sean Barrett 2008 - public domain |
| // |
| // Note that the gl extensions support requires glext.h. In fact, it works |
| // if you just concatenate glext.h onto the end of this file. In that case, |
| // this file is covered by the SGI FreeB license, and is not public domain. |
| // |
| // Extension usage: |
| // |
| // 1. Make a file called something like "extlist.txt" which contains stuff like: |
| // GLE(ShaderSourceARB,SHADERSOURCEARB) |
| // GLE(Uniform1iARB,UNIFORM1IARB) |
| // GLARB(ActiveTexture,ACTIVETEXTURE) // same as GLE(ActiveTextureARB,ACTIVETEXTUREARB) |
| // GLARB(ClientActiveTexture,CLIENTACTIVETEXTURE) |
| // GLE(MultiTexCoord2f,MULTITEXCOORD2F) |
| // |
| // 2. To declare functions (to make a header file), do this: |
| // #define STB_GLEXT_DECLARE "extlist.txt" |
| // #include "stb_gl.h" |
| // |
| // A good way to do this is to define STB_GLEXT_DECLARE project-wide. |
| // |
| // 3. To define functions (implement), do this in some C file: |
| // #define STB_GLEXT_DEFINE "extlist.txt" |
| // #include "stb_gl.h" |
| // |
| // If you've already defined STB_GLEXT_DECLARE, you can just do: |
| // #define STB_GLEXT_DEFINE_DECLARE |
| // #include "stb_gl.h" |
| // |
| // 4. Now you need to initialize: |
| // |
| // stbgl_initExtensions(); |
| |
| |
| #ifndef INCLUDE_STB_GL_H |
| #define INCLUDE_STB_GL_H |
| |
| #define STB_GL |
| |
| #ifdef _WIN32 |
| #ifndef WINGDIAPI |
| #define CALLBACK __stdcall |
| #define WINGDIAPI __declspec(dllimport) |
| #define APIENTRY __stdcall |
| #endif |
| #endif //_WIN32 |
| |
| #include <stddef.h> |
| |
| #include <gl/gl.h> |
| #include <gl/glu.h> |
| |
| #ifndef M_PI |
| #define M_PI 3.14159265358979323846f |
| #endif |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| // like gluPerspective, but: |
| // fov is chosen to satisfy both hfov <= max_hfov & vfov <= max_vfov; |
| // set one to 179 or 0 to ignore it |
| // zoom is applied separately, so you can do linear zoom without |
| // mucking with trig with fov; 1 -> use exact fov |
| // 'aspect' is inferred from the current viewport, and ignores the |
| // possibility of non-square pixels |
| extern void stbgl_Perspective(float zoom, float max_hfov, float max_vfov, float znear, float zfar); |
| extern void stbgl_PerspectiveViewport(int x, int y, int w, int h, float zoom, float max_hfov, float max_vfov, float znear, float zfar); |
| extern void stbgl_initCamera_zup_facing_x(void); |
| extern void stbgl_initCamera_zup_facing_y(void); |
| extern void stbgl_positionCameraWithEulerAngles(float *loc, float *ang); |
| extern void stbgl_drawRect(float x0, float y0, float x1, float y1); |
| extern void stbgl_drawRectTC(float x0, float y0, float x1, float y1, float s0, float t0, float s1, float t1); |
| extern void stbgl_drawBox(float x, float y, float z, float sx, float sy, float sz, int cw); |
| |
| extern int stbgl_hasExtension(char *ext); |
| extern void stbgl_SimpleLight(int index, float bright, float x, float y, float z); |
| extern void stbgl_GlobalAmbient(float r, float g, float b); |
| |
| extern int stbgl_LoadTexture(char *filename, char *props); // only if stb_image is available |
| |
| extern int stbgl_TestTexture(int w); |
| extern int stbgl_TestTextureEx(int w, char *scale_table, int checks_log2, int r1,int g1,int b1, int r2, int b2, int g2); |
| extern unsigned int stbgl_rand(void); // internal, but exposed just in case; LCG, so use middle bits |
| |
| extern int stbgl_TexImage2D(int texid, int w, int h, void *data, char *props); |
| extern int stbgl_TexImage2D_Extra(int texid, int w, int h, void *data, int chan, char *props, int preserve_data); |
| // "props" is a series of characters (and blocks of characters), a la fopen()'s mode, |
| // e.g.: |
| // GLuint texid = stbgl_LoadTexture("myfile.jpg", "mbc") |
| // means: load the image "myfile.jpg", and do the following: |
| // generate mipmaps |
| // use bilinear filtering (not trilinear) |
| // use clamp-to-edge on both channels |
| // |
| // input descriptor: AT MOST ONE |
| // TEXT MEANING |
| // 1 1 channel of input (intensity/alpha) |
| // 2 2 channels of input (luminance, alpha) |
| // 3 3 channels of input (RGB) |
| // 4 4 channels of input (RGBA) |
| // l 1 channel of input (luminance) |
| // a 1 channel of input (alpha) |
| // la 2 channels of input (lum/alpha) |
| // rgb 3 channels of input (RGB) |
| // ycocg 3 channels of input (YCoCg - forces YCoCg output) |
| // ycocgj 4 channels of input (YCoCgJunk - forces YCoCg output) |
| // rgba 4 channels of input (RGBA) |
| // |
| // output descriptor: AT MOST ONE |
| // TEXT MEANING |
| // A 1 channel of output (alpha) |
| // I 1 channel of output (intensity) |
| // LA 2 channels of output (lum/alpha) |
| // RGB 3 channels of output (RGB) |
| // RGBA 4 channels of output (RGBA) |
| // DXT1 encode as a DXT1 texture (RGB unless input has RGBA) |
| // DXT3 encode as a DXT3 texture |
| // DXT5 encode as a DXT5 texture |
| // YCoCg encode as a DXT5 texture with Y in alpha, CoCg in RG |
| // D GL_DEPTH_COMPONENT |
| // NONE no input/output, don't call TexImage2D at all |
| // |
| // when reading from a file or using another interface with an explicit |
| // channel count, the input descriptor is ignored and instead the channel |
| // count is used as the input descriptor. if the file read is a DXT DDS, |
| // then it is passed directly to OpenGL in the file format. |
| // |
| // if an input descriptor is supplied but no output descriptor, the output |
| // is assumed to be the same as the input. if an output descriptor is supplied |
| // but no input descriptor, the input is assumed to be the same as the |
| // output. if neither is supplied, the input is assumed to be 4-channel. |
| // If DXT1 or YCoCG output is requested with no input, the input is assumed |
| // to be 4-channel but the alpha channel is ignored. |
| // |
| // filtering descriptor (default is no mipmaps) |
| // TEXT MEANING |
| // m generate mipmaps |
| // M mipmaps are provided, concatenated at end of data (from largest to smallest) |
| // t use trilinear filtering (default if mipmapped) |
| // b use bilinear filtering (default if not-mipmapped) |
| // n use nearest-neighbor sampling |
| // |
| // wrapping descriptor |
| // TEXT MEANING |
| // w wrap (default) |
| // c clamp-to-edge |
| // C GL_CLAMP (uses border color) |
| // |
| // If only one wrapping descriptor is supplied, it is applied to both channels. |
| // |
| // special: |
| // TEXT MEANING |
| // f input data is floats (default unsigned bytes) |
| // F input&output data is floats (default unsigned bytes) |
| // p explicitly pre-multiply the alpha |
| // P pad to power-of-two (default stretches) |
| // NP2 non-power-of-two |
| // + can overwrite the texture data with temp data |
| // ! free the texture data with "free" |
| // |
| // the properties string can also include spaces |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| #ifdef STB_GL_IMPLEMENTATION |
| #include <math.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <memory.h> |
| |
| int stbgl_hasExtension(char *ext) |
| { |
| const char *s = glGetString(GL_EXTENSIONS); |
| for(;;) { |
| char *e = ext; |
| for (;;) { |
| if (*e == 0) { |
| if (*s == 0 || *s == ' ') return 1; |
| break; |
| } |
| if (*s != *e) |
| break; |
| ++s, ++e; |
| } |
| while (*s && *s != ' ') ++s; |
| if (!*s) return 0; |
| ++s; // skip space |
| } |
| } |
| |
| void stbgl_drawRect(float x0, float y0, float x1, float y1) |
| { |
| glBegin(GL_POLYGON); |
| glTexCoord2f(0,0); glVertex2f(x0,y0); |
| glTexCoord2f(1,0); glVertex2f(x1,y0); |
| glTexCoord2f(1,1); glVertex2f(x1,y1); |
| glTexCoord2f(0,1); glVertex2f(x0,y1); |
| glEnd(); |
| } |
| |
| void stbgl_drawRectTC(float x0, float y0, float x1, float y1, float s0, float t0, float s1, float t1) |
| { |
| glBegin(GL_POLYGON); |
| glTexCoord2f(s0,t0); glVertex2f(x0,y0); |
| glTexCoord2f(s1,t0); glVertex2f(x1,y0); |
| glTexCoord2f(s1,t1); glVertex2f(x1,y1); |
| glTexCoord2f(s0,t1); glVertex2f(x0,y1); |
| glEnd(); |
| } |
| |
| void stbgl_drawBox(float x, float y, float z, float sx, float sy, float sz, int cw) |
| { |
| float x0,y0,z0,x1,y1,z1; |
| sx /=2, sy/=2, sz/=2; |
| x0 = x-sx; y0 = y-sy; z0 = z-sz; |
| x1 = x+sx; y1 = y+sy; z1 = z+sz; |
| |
| glBegin(GL_QUADS); |
| if (cw) { |
| glNormal3f(0,0,-1); |
| glTexCoord2f(0,0); glVertex3f(x0,y0,z0); |
| glTexCoord2f(1,0); glVertex3f(x1,y0,z0); |
| glTexCoord2f(1,1); glVertex3f(x1,y1,z0); |
| glTexCoord2f(0,1); glVertex3f(x0,y1,z0); |
| |
| glNormal3f(0,0,1); |
| glTexCoord2f(0,0); glVertex3f(x1,y0,z1); |
| glTexCoord2f(1,0); glVertex3f(x0,y0,z1); |
| glTexCoord2f(1,1); glVertex3f(x0,y1,z1); |
| glTexCoord2f(0,1); glVertex3f(x1,y1,z1); |
| |
| glNormal3f(-1,0,0); |
| glTexCoord2f(0,0); glVertex3f(x0,y1,z1); |
| glTexCoord2f(1,0); glVertex3f(x0,y0,z1); |
| glTexCoord2f(1,1); glVertex3f(x0,y0,z0); |
| glTexCoord2f(0,1); glVertex3f(x0,y1,z0); |
| |
| glNormal3f(1,0,0); |
| glTexCoord2f(0,0); glVertex3f(x1,y0,z1); |
| glTexCoord2f(1,0); glVertex3f(x1,y1,z1); |
| glTexCoord2f(1,1); glVertex3f(x1,y1,z0); |
| glTexCoord2f(0,1); glVertex3f(x1,y0,z0); |
| |
| glNormal3f(0,-1,0); |
| glTexCoord2f(0,0); glVertex3f(x0,y0,z1); |
| glTexCoord2f(1,0); glVertex3f(x1,y0,z1); |
| glTexCoord2f(1,1); glVertex3f(x1,y0,z0); |
| glTexCoord2f(0,1); glVertex3f(x0,y0,z0); |
| |
| glNormal3f(0,1,0); |
| glTexCoord2f(0,0); glVertex3f(x1,y1,z1); |
| glTexCoord2f(1,0); glVertex3f(x0,y1,z1); |
| glTexCoord2f(1,1); glVertex3f(x0,y1,z0); |
| glTexCoord2f(0,1); glVertex3f(x1,y1,z0); |
| } else { |
| glNormal3f(0,0,-1); |
| glTexCoord2f(0,0); glVertex3f(x0,y0,z0); |
| glTexCoord2f(0,1); glVertex3f(x0,y1,z0); |
| glTexCoord2f(1,1); glVertex3f(x1,y1,z0); |
| glTexCoord2f(1,0); glVertex3f(x1,y0,z0); |
| |
| glNormal3f(0,0,1); |
| glTexCoord2f(0,0); glVertex3f(x1,y0,z1); |
| glTexCoord2f(0,1); glVertex3f(x1,y1,z1); |
| glTexCoord2f(1,1); glVertex3f(x0,y1,z1); |
| glTexCoord2f(1,0); glVertex3f(x0,y0,z1); |
| |
| glNormal3f(-1,0,0); |
| glTexCoord2f(0,0); glVertex3f(x0,y1,z1); |
| glTexCoord2f(0,1); glVertex3f(x0,y1,z0); |
| glTexCoord2f(1,1); glVertex3f(x0,y0,z0); |
| glTexCoord2f(1,0); glVertex3f(x0,y0,z1); |
| |
| glNormal3f(1,0,0); |
| glTexCoord2f(0,0); glVertex3f(x1,y0,z1); |
| glTexCoord2f(0,1); glVertex3f(x1,y0,z0); |
| glTexCoord2f(1,1); glVertex3f(x1,y1,z0); |
| glTexCoord2f(1,0); glVertex3f(x1,y1,z1); |
| |
| glNormal3f(0,-1,0); |
| glTexCoord2f(0,0); glVertex3f(x0,y0,z1); |
| glTexCoord2f(0,1); glVertex3f(x0,y0,z0); |
| glTexCoord2f(1,1); glVertex3f(x1,y0,z0); |
| glTexCoord2f(1,0); glVertex3f(x1,y0,z1); |
| |
| glNormal3f(0,1,0); |
| glTexCoord2f(0,0); glVertex3f(x1,y1,z1); |
| glTexCoord2f(0,1); glVertex3f(x1,y1,z0); |
| glTexCoord2f(1,1); glVertex3f(x0,y1,z0); |
| glTexCoord2f(1,0); glVertex3f(x0,y1,z1); |
| } |
| glEnd(); |
| } |
| |
| void stbgl_SimpleLight(int index, float bright, float x, float y, float z) |
| { |
| float d = (float) (1.0f/sqrt(x*x+y*y+z*z)); |
| float dir[4] = { x*d,y*d,z*d,0 }, zero[4] = { 0,0,0,0 }; |
| float c[4] = { bright,bright,bright,0 }; |
| GLuint light = GL_LIGHT0 + index; |
| glLightfv(light, GL_POSITION, dir); |
| glLightfv(light, GL_DIFFUSE, c); |
| glLightfv(light, GL_AMBIENT, zero); |
| glLightfv(light, GL_SPECULAR, zero); |
| glEnable(light); |
| glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); |
| glEnable(GL_COLOR_MATERIAL); |
| } |
| |
| void stbgl_GlobalAmbient(float r, float g, float b) |
| { |
| float v[4] = { r,g,b,0 }; |
| glLightModelfv(GL_LIGHT_MODEL_AMBIENT, v); |
| } |
| |
| |
| #define stbgl_rad2deg(r) ((r)*180.0f / M_PI) |
| #define stbgl_deg2rad(r) ((r)/180.0f * M_PI) |
| |
| void stbgl_Perspective(float zoom, float max_hfov, float max_vfov, float znear, float zfar) |
| { |
| float unit_width, unit_height, aspect, vfov; |
| int data[4],w,h; |
| glGetIntegerv(GL_VIEWPORT, data); |
| w = data[2]; |
| h = data[3]; |
| aspect = (float) w / h; |
| |
| if (max_hfov <= 0) max_hfov = 179; |
| if (max_vfov <= 0) max_vfov = 179; |
| |
| // convert max_hfov, max_vfov to worldspace width at depth=1 |
| unit_width = (float) tan(stbgl_deg2rad(max_hfov/2)) * 2; |
| unit_height = (float) tan(stbgl_deg2rad(max_vfov/2)) * 2; |
| // check if hfov = max_hfov is enough to satisfy it |
| if (unit_width <= aspect * unit_height) { |
| float height = unit_width / aspect; |
| vfov = (float) atan(( height/2) / zoom); |
| } else { |
| vfov = (float) atan((unit_height/2) / zoom); |
| } |
| vfov = (float) stbgl_rad2deg(vfov * 2); |
| gluPerspective(vfov, aspect, znear, zfar); |
| } |
| |
| void stbgl_PerspectiveViewport(int x, int y, int w, int h, float zoom, float min_hfov, float min_vfov, float znear, float zfar) |
| { |
| if (znear <= 0.0001f) znear = 0.0001f; |
| glViewport(x,y,w,h); |
| glScissor(x,y,w,h); |
| glMatrixMode(GL_PROJECTION); |
| glLoadIdentity(); |
| stbgl_Perspective(zoom, min_hfov, min_vfov, znear, zfar); |
| glMatrixMode(GL_MODELVIEW); |
| } |
| |
| // point the camera along the positive X axis, Z-up |
| void stbgl_initCamera_zup_facing_x(void) |
| { |
| glRotatef(-90, 1,0,0); |
| glRotatef( 90, 0,0,1); |
| } |
| |
| // point the camera along the positive Y axis, Z-up |
| void stbgl_initCamera_zup_facing_y(void) |
| { |
| glRotatef(-90, 1,0,0); |
| } |
| |
| // setup a camera using Euler angles |
| void stbgl_positionCameraWithEulerAngles(float *loc, float *ang) |
| { |
| glRotatef(-ang[1], 0,1,0); |
| glRotatef(-ang[0], 1,0,0); |
| glRotatef(-ang[2], 0,0,1); |
| glTranslatef(-loc[0], -loc[1], -loc[2]); |
| } |
| |
| static int stbgl_m(char *a, char *b) |
| { |
| // skip first character |
| do { ++a,++b; } while (*b && *a == *b); |
| return *b == 0; |
| } |
| |
| #ifdef STBI_VERSION |
| #ifndef STBI_NO_STDIO |
| int stbgl_LoadTexture(char *filename, char *props) |
| { |
| // @TODO: handle DDS files directly |
| int res; |
| void *data; |
| int w,h,c; |
| #ifndef STBI_NO_HDR |
| if (stbi_is_hdr(filename)) { |
| data = stbi_loadf(filename, &w, &h, &c, 0); |
| if (!data) return 0; |
| res = stbgl_TexImage2D_Extra(0, w,h,data, -c, props, 0); |
| free(data); |
| return res; |
| } |
| #endif |
| |
| data = stbi_load(filename, &w, &h, &c, 0); |
| if (!data) return 0; |
| res = stbgl_TexImage2D_Extra(0, w,h,data, c, props, 0); |
| free(data); |
| return res; |
| } |
| #endif |
| #endif // STBI_VERSION |
| |
| int stbgl_TexImage2D(int texid, int w, int h, void *data, char *props) |
| { |
| return stbgl_TexImage2D_Extra(texid, w, h, data, 0, props,1); |
| } |
| |
| int stbgl_TestTexture(int w) |
| { |
| char scale_table[] = { 10,20,30,30,35,40,5,18,25,13,7,5,3,3,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0 }; |
| return stbgl_TestTextureEx(w, scale_table, 2, 140,130,200, 180,200,170); |
| } |
| |
| unsigned int stbgl_rand(void) |
| { |
| static unsigned int stbgl__rand_seed = 3248980923; // random typing |
| return stbgl__rand_seed = stbgl__rand_seed * 2147001325 + 715136305; // BCPL generator |
| } |
| |
| // wish this could be smaller, since it's so frivolous |
| int stbgl_TestTextureEx(int w, char *scale_table, int checks_log2, int r1,int g1,int b1, int r2, int b2, int g2) |
| { |
| int rt[2] = {r1,r2}, gt[2] = {g1,g2}, bt[2] = {b1,b2}; |
| signed char modded[256]; |
| int i,j, m = w-1, s,k,scale; |
| unsigned char *data = (unsigned char *) malloc(w*w*3); |
| assert((m & w) == 0); |
| data[0] = 128; |
| for (s=0; s < 16; ++s) if ((1 << s) == w) break; |
| assert(w == (1 << s)); |
| // plasma fractal noise |
| for (k=s-1; k >= 0; --k) { |
| int step = 1 << k; |
| // interpolate from "parents" |
| for (j=0; j < w; j += step*2) { |
| for (i=0; i < w; i += step*2) { |
| int i1 = i+step, j1=j+step; |
| int i2 = (i+step*2)&m, j2 = (j+step*2)&m; |
| int p00 = data[(j*w+i )*3], p01 = data[(j2*w+i )*3]; |
| int p10 = data[(j*w+i2)*3], p11 = data[(j2*w+i2)*3]; |
| data[(j*w+i1)*3] = (p00+p10)>>1; |
| data[(j1*w+i)*3] = (p00+p01)>>1; |
| data[(j1*w+i1)*3]= (p00+p01+p10+p11)>>2; |
| } |
| } |
| scale = scale_table[s-k+1]; |
| if (!scale) continue; // just interpolate down the remaining data |
| for (j=0,i=0; i < 256; i += 2, j == scale ? j=0 : ++j) |
| modded[i] = j, modded[i+1] = -j; // precompute i%scale (plus sign) |
| for (j=0; j < w; j += step) |
| for (i=0; i < w; i += step) { |
| int x = data[(j*w+i)*3] + modded[(stbgl_rand() >> 12) & 255]; |
| data[(j*w+i)*3] = x < 0 ? 0 : x > 255 ? 255 : x; |
| } |
| } |
| for (j=0; j < w; ++j) |
| for (i=0; i < w; ++i) { |
| int check = ((i^j) & (1 << (s-checks_log2))) == 0; |
| int v = data[(j*w+i)*3] >> 2; |
| data[(j*w+i)*3+0] = rt[check]-v; |
| data[(j*w+i)*3+1] = gt[check]-v; |
| data[(j*w+i)*3+2] = bt[check]-v; |
| } |
| return stbgl_TexImage2D(0, w, w, data, "3m!"); // 3 channels, mipmap, free |
| } |
| |
| #ifdef _WIN32 |
| #ifndef WINGDIAPI |
| typedef int (__stdcall *stbgl__voidfunc)(void); |
| __declspec(dllimport) stbgl__voidfunc wglGetProcAddress(char *); |
| #endif |
| #define STB__HAS_WGLPROC |
| static void (__stdcall *stbgl__CompressedTexImage2DARB)(int target, int level, |
| int internalformat, int width, |
| int height, int border, |
| int imageSize, void *data); |
| static void stbgl__initCompTex(void) |
| { |
| *((void **) &stbgl__CompressedTexImage2DARB) = (void *) wglGetProcAddress("glCompressedTexImage2DARB"); |
| } |
| #else |
| static void (*stbgl__CompressedTexImage2DARB)(int target, int level, |
| int internalformat, int width, |
| int height, int border, |
| int imageSize, void *data); |
| static void stbgl__initCompTex(void) |
| { |
| } |
| #endif // _WIN32 |
| |
| #define STBGL_COMPRESSED_RGB_S3TC_DXT1 0x83F0 |
| #define STBGL_COMPRESSED_RGBA_S3TC_DXT1 0x83F1 |
| #define STBGL_COMPRESSED_RGBA_S3TC_DXT3 0x83F2 |
| #define STBGL_COMPRESSED_RGBA_S3TC_DXT5 0x83F3 |
| |
| #ifdef STB_COMPRESS_DXT_BLOCK |
| static void stbgl__convert(uint8 *p, uint8 *q, int n, int input_desc, uint8 *end) |
| { |
| int i; |
| switch (input_desc) { |
| case GL_RED: |
| case GL_LUMINANCE: for (i=0; i < n; ++i,p+=4) p[0] = p[1] = p[2] = q[0], p[3]=255, q+=1; break; |
| case GL_ALPHA: for (i=0; i < n; ++i,p+=4) p[0] = p[1] = p[2] = 0, p[3] = q[0], q+=1; break; |
| case GL_LUMINANCE_ALPHA: for (i=0; i < n; ++i,p+=4) p[0] = p[1] = p[2] = q[0], p[3]=q[1], q+=2; break; |
| case GL_RGB: for (i=0; i < n; ++i,p+=4) p[0]=q[0],p[1]=q[1],p[2]=q[2],p[3]=255,q+=3; break; |
| case GL_RGBA: memcpy(p, q, n*4); break; |
| case GL_INTENSITY: for (i=0; i < n; ++i,p+=4) p[0] = p[1] = p[2] = p[3] = q[0], q+=1; break; |
| } |
| assert(p <= end); |
| } |
| |
| static void stbgl__compress(uint8 *p, uint8 *rgba, int w, int h, int output_desc, uint8 *end) |
| { |
| int i,j,y,y2; |
| int alpha = (output_desc == STBGL_COMPRESSED_RGBA_S3TC_DXT5); |
| for (j=0; j < w; j += 4) { |
| int x=4; |
| for (i=0; i < h; i += 4) { |
| uint8 block[16*4]; |
| if (i+3 >= w) x = w-i; |
| for (y=0; y < 4; ++y) { |
| if (j+y >= h) break; |
| memcpy(block+y*16, rgba + w*4*(j+y) + i*4, x*4); |
| } |
| if (x < 4) { |
| switch (x) { |
| case 0: assert(0); |
| case 1: |
| for (y2=0; y2 < y; ++y2) { |
| memcpy(block+y2*16+1*4, block+y2*16+0*4, 4); |
| memcpy(block+y2*16+2*4, block+y2*16+0*4, 8); |
| } |
| break; |
| case 2: |
| for (y2=0; y2 < y; ++y2) |
| memcpy(block+y2*16+2*4, block+y2*16+0*4, 8); |
| break; |
| case 3: |
| for (y2=0; y2 < y; ++y2) |
| memcpy(block+y2*16+3*4, block+y2*16+1*4, 4); |
| break; |
| } |
| } |
| y2 = 0; |
| for(; y<4; ++y,++y2) |
| memcpy(block+y*16, block+y2*16, 4*4); |
| stb_compress_dxt_block(p, block, alpha, 10); |
| p += alpha ? 16 : 8; |
| } |
| } |
| assert(p <= end); |
| } |
| #endif // STB_COMPRESS_DXT_BLOCK |
| |
| // use the reserved temporary-use enumerant range, since no |
| // OpenGL enumerants should fall in that range |
| enum |
| { |
| STBGL_UNDEFINED = 0x6000, |
| STBGL_YCOCG, |
| STBGL_YCOCGJ, |
| STBGL_GEN_MIPMAPS, |
| STBGL_MIPMAPS, |
| STBGL_NO_DOWNLOAD, |
| }; |
| |
| #define STBGL_CLAMP_TO_EDGE 0x812F |
| #define STBGL_CLAMP_TO_BORDER 0x812D |
| |
| #define STBGL_DEPTH_COMPONENT16 0x81A5 |
| #define STBGL_DEPTH_COMPONENT24 0x81A6 |
| #define STBGL_DEPTH_COMPONENT32 0x81A7 |
| |
| int stbgl_TexImage2D_Extra(int texid, int w, int h, void *data, int chan, char *props, int preserve_data) |
| { |
| static int has_s3tc = -1; // haven't checked yet |
| int free_data = 0, is_compressed = 0; |
| int pad_to_power_of_two = 0, non_power_of_two = 0; |
| int premultiply_alpha = 0; // @TODO |
| int float_tex = 0; // @TODO |
| int input_type = GL_UNSIGNED_BYTE; |
| int input_desc = STBGL_UNDEFINED; |
| int output_desc = STBGL_UNDEFINED; |
| int mipmaps = STBGL_UNDEFINED; |
| int filter = STBGL_UNDEFINED, mag_filter; |
| int wrap_s = STBGL_UNDEFINED, wrap_t = STBGL_UNDEFINED; |
| |
| // parse out the properties |
| if (props == NULL) props = ""; |
| while (*props) { |
| switch (*props) { |
| case '1' : input_desc = GL_LUMINANCE; break; |
| case '2' : input_desc = GL_LUMINANCE_ALPHA; break; |
| case '3' : input_desc = GL_RGB; break; |
| case '4' : input_desc = GL_RGBA; break; |
| case 'l' : if (props[1] == 'a') { input_desc = GL_LUMINANCE_ALPHA; ++props; } |
| else input_desc = GL_LUMINANCE; |
| break; |
| case 'a' : input_desc = GL_ALPHA; break; |
| case 'r' : if (stbgl_m(props, "rgba")) { input_desc = GL_RGBA; props += 3; break; } |
| if (stbgl_m(props, "rgb")) { input_desc = GL_RGB; props += 2; break; } |
| input_desc = GL_RED; |
| break; |
| case 'y' : if (stbgl_m(props, "ycocg")) { |
| if (props[5] == 'j') { props += 5; input_desc = STBGL_YCOCGJ; } |
| else { props += 4; input_desc = STBGL_YCOCG; } |
| break; |
| } |
| return 0; |
| case 'L' : if (props[1] == 'A') { output_desc = GL_LUMINANCE_ALPHA; ++props; } |
| else output_desc = GL_LUMINANCE; |
| break; |
| case 'I' : output_desc = GL_INTENSITY; break; |
| case 'A' : output_desc = GL_ALPHA; break; |
| case 'R' : if (stbgl_m(props, "RGBA")) { output_desc = GL_RGBA; props += 3; break; } |
| if (stbgl_m(props, "RGB")) { output_desc = GL_RGB; props += 2; break; } |
| output_desc = GL_RED; |
| break; |
| case 'Y' : if (stbgl_m(props, "YCoCg") || stbgl_m(props, "YCOCG")) { |
| props += 4; |
| output_desc = STBGL_YCOCG; |
| break; |
| } |
| return 0; |
| case 'D' : if (stbgl_m(props, "DXT")) { |
| switch (props[3]) { |
| case '1': output_desc = STBGL_COMPRESSED_RGB_S3TC_DXT1; break; |
| case '3': output_desc = STBGL_COMPRESSED_RGBA_S3TC_DXT3; break; |
| case '5': output_desc = STBGL_COMPRESSED_RGBA_S3TC_DXT5; break; |
| default: return 0; |
| } |
| props += 3; |
| } else if (stbgl_m(props, "D16")) { |
| output_desc = STBGL_DEPTH_COMPONENT16; |
| input_desc = GL_DEPTH_COMPONENT; |
| props += 2; |
| } else if (stbgl_m(props, "D24")) { |
| output_desc = STBGL_DEPTH_COMPONENT24; |
| input_desc = GL_DEPTH_COMPONENT; |
| props += 2; |
| } else if (stbgl_m(props, "D32")) { |
| output_desc = STBGL_DEPTH_COMPONENT32; |
| input_desc = GL_DEPTH_COMPONENT; |
| props += 2; |
| } else { |
| output_desc = GL_DEPTH_COMPONENT; |
| input_desc = GL_DEPTH_COMPONENT; |
| } |
| break; |
| case 'N' : if (stbgl_m(props, "NONE")) { |
| props += 3; |
| input_desc = STBGL_NO_DOWNLOAD; |
| output_desc = STBGL_NO_DOWNLOAD; |
| break; |
| } |
| if (stbgl_m(props, "NP2")) { |
| non_power_of_two = 1; |
| props += 2; |
| break; |
| } |
| return 0; |
| case 'm' : mipmaps = STBGL_GEN_MIPMAPS; break; |
| case 'M' : mipmaps = STBGL_MIPMAPS; break; |
| case 't' : filter = GL_LINEAR_MIPMAP_LINEAR; break; |
| case 'b' : filter = GL_LINEAR; break; |
| case 'n' : filter = GL_NEAREST; break; |
| case 'w' : if (wrap_s == STBGL_UNDEFINED) wrap_s = GL_REPEAT; else wrap_t = GL_REPEAT; break; |
| case 'C' : if (wrap_s == STBGL_UNDEFINED) wrap_s = STBGL_CLAMP_TO_BORDER; else wrap_t = STBGL_CLAMP_TO_BORDER; break; |
| case 'c' : if (wrap_s == STBGL_UNDEFINED) wrap_s = STBGL_CLAMP_TO_EDGE; else wrap_t = STBGL_CLAMP_TO_EDGE; break; |
| case 'f' : input_type = GL_FLOAT; break; |
| case 'F' : input_type = GL_FLOAT; float_tex = 1; break; |
| case 'p' : premultiply_alpha = 1; break; |
| case 'P' : pad_to_power_of_two = 1; break; |
| case '+' : preserve_data = 0; break; |
| case '!' : preserve_data = 0; free_data = 1; break; |
| case ' ' : break; |
| case '-' : break; |
| default : if (free_data) free(data); |
| return 0; |
| } |
| ++props; |
| } |
| |
| // override input_desc based on channel count |
| if (output_desc != STBGL_NO_DOWNLOAD) { |
| switch (abs(chan)) { |
| case 1: input_desc = GL_LUMINANCE; break; |
| case 2: input_desc = GL_LUMINANCE_ALPHA; break; |
| case 3: input_desc = GL_RGB; break; |
| case 4: input_desc = GL_RGBA; break; |
| case 0: break; |
| default: return 0; |
| } |
| } |
| |
| // override input_desc based on channel info |
| if (chan > 0) { input_type = GL_UNSIGNED_BYTE; } |
| if (chan < 0) { input_type = GL_FLOAT; } |
| |
| if (output_desc == GL_ALPHA) { |
| if (input_desc == GL_LUMINANCE) |
| input_desc = GL_ALPHA; |
| if (input_desc == GL_RGB) { |
| // force a presumably-mono image to alpha |
| // @TODO handle 'preserve_data' case? |
| if (data && !preserve_data && input_type == GL_UNSIGNED_BYTE) { |
| int i; |
| unsigned char *p = (unsigned char *) data, *q = p; |
| for (i=0; i < w*h; ++i) { |
| *q = (p[0] + 2*p[1] + p[2]) >> 2; |
| p += 3; |
| q += 1; |
| } |
| input_desc = GL_ALPHA; |
| } |
| } |
| } |
| |
| // set undefined input/output based on the other |
| if (input_desc == STBGL_UNDEFINED && output_desc == STBGL_UNDEFINED) { |
| input_desc = output_desc = GL_RGBA; |
| } else if (output_desc == STBGL_UNDEFINED) { |
| switch (input_desc) { |
| case GL_LUMINANCE: |
| case GL_ALPHA: |
| case GL_LUMINANCE_ALPHA: |
| case GL_RGB: |
| case GL_RGBA: |
| output_desc = input_desc; |
| break; |
| case GL_RED: |
| output_desc = GL_INTENSITY; |
| break; |
| case STBGL_YCOCG: |
| case STBGL_YCOCGJ: |
| output_desc = STBGL_YCOCG; |
| break; |
| default: assert(0); return 0; |
| } |
| } else if (input_desc == STBGL_UNDEFINED) { |
| switch (output_desc) { |
| case GL_LUMINANCE: |
| case GL_ALPHA: |
| case GL_LUMINANCE_ALPHA: |
| case GL_RGB: |
| case GL_RGBA: |
| input_desc = output_desc; |
| break; |
| case GL_INTENSITY: |
| input_desc = GL_RED; |
| break; |
| case STBGL_YCOCG: |
| case STBGL_COMPRESSED_RGB_S3TC_DXT1: |
| case STBGL_COMPRESSED_RGBA_S3TC_DXT3: |
| case STBGL_COMPRESSED_RGBA_S3TC_DXT5: |
| input_desc = GL_RGBA; |
| break; |
| } |
| } else { |
| if (output_desc == STBGL_COMPRESSED_RGB_S3TC_DXT1) { |
| // if input has alpha, force output alpha |
| switch (input_desc) { |
| case GL_ALPHA: |
| case GL_LUMINANCE_ALPHA: |
| case GL_RGBA: |
| output_desc = STBGL_COMPRESSED_RGBA_S3TC_DXT5; |
| break; |
| } |
| } |
| } |
| |
| switch(input_desc) { |
| case GL_LUMINANCE: |
| case GL_RED: |
| case GL_ALPHA: |
| chan = 1; |
| break; |
| case GL_LUMINANCE_ALPHA: |
| chan = 2; |
| break; |
| case GL_RGB: |
| chan = 3; |
| break; |
| case GL_RGBA: |
| chan = 4; |
| break; |
| } |
| |
| if (pad_to_power_of_two && ((w & (w-1)) || (h & (h-1)))) { |
| if (output_desc != STBGL_NO_DOWNLOAD && input_type == GL_UNSIGNED_BYTE && chan > 0) { |
| unsigned char *new_data; |
| int w2 = w, h2 = h, j; |
| while (w & (w-1)) |
| w = (w | (w>>1))+1; |
| while (h & (h-1)) |
| h = (h | (h>>1))+1; |
| new_data = malloc(w * h * chan); |
| for (j=0; j < h2; ++j) { |
| memcpy(new_data + j * w * chan, (char *) data+j*w2*chan, w2*chan); |
| memset(new_data + (j * w+w2) * chan, 0, (w-w2)*chan); |
| } |
| for (; j < h; ++j) |
| memset(new_data + j*w*chan, 0, w*chan); |
| if (free_data) |
| free(data); |
| data = new_data; |
| free_data = 1; |
| } |
| } |
| |
| switch (output_desc) { |
| case STBGL_COMPRESSED_RGB_S3TC_DXT1: |
| case STBGL_COMPRESSED_RGBA_S3TC_DXT1: |
| case STBGL_COMPRESSED_RGBA_S3TC_DXT3: |
| case STBGL_COMPRESSED_RGBA_S3TC_DXT5: |
| is_compressed = 1; |
| if (has_s3tc == -1) { |
| has_s3tc = stbgl_hasExtension("GL_EXT_texture_compression_s3tc"); |
| if (has_s3tc) stbgl__initCompTex(); |
| } |
| if (!has_s3tc) { |
| is_compressed = 0; |
| if (output_desc == STBGL_COMPRESSED_RGB_S3TC_DXT1) |
| output_desc = GL_RGB; |
| else |
| output_desc = GL_RGBA; |
| } |
| } |
| |
| if (output_desc == STBGL_YCOCG) { |
| assert(0); |
| output_desc = GL_RGB; // @TODO! |
| if (free_data) free(data); |
| return 0; |
| } |
| |
| mag_filter = 0; |
| if (mipmaps != STBGL_UNDEFINED) { |
| switch (filter) { |
| case STBGL_UNDEFINED: filter = GL_LINEAR_MIPMAP_LINEAR; break; |
| case GL_NEAREST : mag_filter = GL_NEAREST; filter = GL_LINEAR_MIPMAP_LINEAR; break; |
| case GL_LINEAR : filter = GL_LINEAR_MIPMAP_NEAREST; break; |
| } |
| } else { |
| if (filter == STBGL_UNDEFINED) |
| filter = GL_LINEAR; |
| } |
| |
| // update filtering |
| if (!mag_filter) { |
| if (filter == GL_NEAREST) |
| mag_filter = GL_NEAREST; |
| else |
| mag_filter = GL_LINEAR; |
| } |
| |
| // update wrap/clamp |
| if (wrap_s == STBGL_UNDEFINED) wrap_s = GL_REPEAT; |
| if (wrap_t == STBGL_UNDEFINED) wrap_t = wrap_s; |
| |
| // if no texture id, generate one |
| if (texid == 0) { |
| GLuint tex; |
| glGenTextures(1, &tex); |
| if (tex == 0) { if (free_data) free(data); return 0; } |
| texid = tex; |
| } |
| |
| if (data == NULL && mipmaps == STBGL_GEN_MIPMAPS) |
| mipmaps = STBGL_MIPMAPS; |
| |
| if (output_desc == STBGL_NO_DOWNLOAD) |
| mipmaps = STBGL_NO_DOWNLOAD; |
| |
| glBindTexture(GL_TEXTURE_2D, texid); |
| |
| #ifdef STB_COMPRESS_DXT_BLOCK |
| if (!is_compressed || !stbgl__CompressedTexImage2DARB || output_desc == STBGL_COMPRESSED_RGBA_S3TC_DXT3 || data == NULL) |
| #endif |
| { |
| switch (mipmaps) { |
| case STBGL_NO_DOWNLOAD: |
| break; |
| |
| case STBGL_UNDEFINED: |
| // check if actually power-of-two |
| if (non_power_of_two || ((w & (w-1)) == 0 && (h & (h-1)) == 0)) |
| glTexImage2D(GL_TEXTURE_2D, 0, output_desc, w, h, 0, input_desc, input_type, data); |
| else |
| gluBuild2DMipmaps(GL_TEXTURE_2D, output_desc, w, h, input_desc, input_type, data); |
| // not power of two, so use glu to resize (generates mipmaps needlessly) |
| break; |
| |
| case STBGL_MIPMAPS: { |
| int level = 0; |
| int size = input_type == GL_FLOAT ? sizeof(float) : 1; |
| if (data == NULL) size = 0; // reuse same block of memory for all mipmaps |
| assert((w & (w-1)) == 0 && (h & (h-1)) == 0); // verify power-of-two |
| while (w > 1 && h > 1) { |
| glTexImage2D(GL_TEXTURE_2D, level, output_desc, w, h, 0, input_desc, input_type, data); |
| data = (void *) ((char *) data + w * h * size * chan); |
| if (w > 1) w >>= 1; |
| if (h > 1) h >>= 1; |
| ++level; |
| } |
| break; |
| } |
| case STBGL_GEN_MIPMAPS: |
| gluBuild2DMipmaps(GL_TEXTURE_2D, output_desc, w, h, input_desc, input_type, data); |
| break; |
| |
| default: |
| assert(0); |
| if (free_data) free(data); |
| return 0; |
| } |
| #ifdef STB_COMPRESS_DXT_BLOCK |
| } else { |
| uint8 *out, *rgba=0, *end_out, *end_rgba; |
| int level = 0, alpha = (output_desc != STBGL_COMPRESSED_RGB_S3TC_DXT1); |
| int size = input_type == GL_FLOAT ? sizeof(float) : 1; |
| int osize = alpha ? 16 : 8; |
| if (!free_data && mipmaps == STBGL_GEN_MIPMAPS) { |
| uint8 *temp = malloc(w*h*chan); |
| if (!temp) { if (free_data) free(data); return 0; } |
| memcpy(temp, data, w*h*chan); |
| if (free_data) free(data); |
| free_data = 1; |
| data = temp; |
| } |
| if (chan != 4 || size != 1) { |
| rgba = malloc(w*h*4); |
| if (!rgba) return 0; |
| end_rgba = rgba+w*h*4; |
| } |
| out = malloc((w+3)*(h+3)/16*osize); // enough storage for the s3tc data |
| if (!out) return 0; |
| end_out = out + ((w+3)*(h+3))/16*osize; |
| |
| for(;;) { |
| if (chan != 4) |
| stbgl__convert(rgba, data, w*h, input_desc, end_rgba); |
| stbgl__compress(out, rgba ? rgba : data, w, h, output_desc, end_out); |
| stbgl__CompressedTexImage2DARB(GL_TEXTURE_2D, level, output_desc, w, h, 0, ((w+3)&~3)*((h+3)&~3)/16*osize, out); |
| //glTexImage2D(GL_TEXTURE_2D, level, alpha?GL_RGBA:GL_RGB, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba ? rgba : data); |
| |
| if (mipmaps == STBGL_UNDEFINED) break; |
| if (w <= 1 && h <= 1) break; |
| if (mipmaps == STBGL_MIPMAPS) data = (void *) ((char *) data + w * h * size * chan); |
| if (mipmaps == STBGL_GEN_MIPMAPS) { |
| int w2 = w>>1, h2=h>>1, i,j,k, s=w*chan; |
| uint8 *p = data, *q=data; |
| if (w == 1) { |
| for (j=0; j < h2; ++j) { |
| for (k=0; k < chan; ++k) |
| *p++ = (q[k] + q[s+k] + 1) >> 1; |
| q += s*2; |
| } |
| } else if (h == 1) { |
| for (i=0; i < w2; ++i) { |
| for (k=0; k < chan; ++k) |
| *p++ = (q[k] + q[k+chan] + 1) >> 1; |
| q += chan*2; |
| } |
| } else { |
| for (j=0; j < h2; ++j) { |
| for (i=0; i < w2; ++i) { |
| for (k=0; k < chan; ++k) |
| *p++ = (q[k] + q[k+chan] + q[s+k] + q[s+k+chan] + 2) >> 2; |
| q += chan*2; |
| } |
| q += s; |
| } |
| } |
| } |
| if (w > 1) w >>= 1; |
| if (h > 1) h >>= 1; |
| ++level; |
| } |
| if (out) free(out); |
| if (rgba) free(rgba); |
| #endif // STB_COMPRESS_DXT_BLOCK |
| } |
| |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); |
| |
| if (free_data) free(data); |
| return texid; |
| } |
| |
| #endif // STB_DEFINE |
| #undef STB_EXTERN |
| |
| #endif //INCLUDE_STB_GL_H |
| |
| // Extension handling... must be outside the INCLUDE_ brackets |
| |
| #if defined(STB_GLEXT_DEFINE) || defined(STB_GLEXT_DECLARE) |
| |
| #ifndef STB_GLEXT_SKIP_DURING_RECURSION |
| |
| #ifndef GL_GLEXT_VERSION |
| |
| // First check if glext.h is concatenated on the end of this file |
| // (if it's concatenated on the beginning, we'll have GL_GLEXT_VERSION) |
| |
| #define STB_GLEXT_SKIP_DURING_RECURSION |
| #include __FILE__ |
| #undef STB_GLEXT_SKIP_DURING_RECURSION |
| |
| // now check if it's still undefined; if so, try going for it by name; |
| // if this errors, that's fine, since we can't compile without it |
| |
| #ifndef GL_GLEXT_VERSION |
| #include "glext.h" |
| #endif |
| #endif |
| |
| #define GLARB(a,b) GLE(a##ARB,b##ARB) |
| #define GLEXT(a,b) GLE(a##EXT,b##EXT) |
| #define GLNV(a,b) GLE(a##NV ,b##NV) |
| #define GLATI(a,b) GLE(a##ATI,b##ATI) |
| #define GLCORE(a,b) GLE(a,b) |
| |
| #ifdef STB_GLEXT_DEFINE_DECLARE |
| #define STB_GLEXT_DEFINE STB_GLEXT_DECLARE |
| #endif |
| |
| #if defined(STB_GLEXT_DECLARE) && defined(STB_GLEXT_DEFINE) |
| #undef STB_GLEXT_DECLARE |
| #endif |
| |
| #if defined(STB_GLEXT_DECLARE) && !defined(STB_GLEXT_DEFINE) |
| #define GLE(a,b) extern PFNGL##b##PROC gl##a; |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| extern void stbgl_initExtensions(void); |
| |
| #include STB_GLEXT_DECLARE |
| |
| #ifdef __cplusplus |
| }; |
| #endif |
| |
| #else |
| |
| #ifndef STB_GLEXT_DEFINE |
| #error "Header file is screwed up somehow" |
| #endif |
| |
| #ifdef _WIN32 |
| #ifndef WINGDIAPI |
| #ifndef STB__HAS_WGLPROC |
| typedef int (__stdcall *stbgl__voidfunc)(void); |
| __declspec(dllimport) stbgl__voidfunc wglGetProcAddress(char *); |
| #endif |
| #endif |
| #define STBGL__GET_FUNC(x) wglGetProcAddress(x) |
| #endif |
| |
| #ifdef GLE |
| #undef GLE |
| #endif |
| |
| #define GLE(a,b) PFNGL##b##PROC gl##a; |
| #include STB_GLEXT_DEFINE |
| |
| #undef GLE |
| #define GLE(a,b) gl##a = (PFNGL##b##PROC) STBGL__GET_FUNC("gl" #a ); |
| |
| void stbgl_initExtensions(void) |
| { |
| #include STB_GLEXT_DEFINE |
| } |
| |
| #undef GLE |
| |
| #endif // STB_GLEXT_DECLARE |
| |
| #endif // STB_GLEXT_SKIP |
| |
| #endif // STB_GLEXT_DEFINE || STB_GLEXT_DECLARE |
