Hri7566
/
sm64coopdx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change GL_LEGACY to only use GL1.1 (1.2?) features

This commit is contained in:
fgsfds 2020-08-29 02:13:07 +03:00
parent 655427f10f
commit 73c6c9105f
1 changed files with 283 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

587
src/pc/gfx/gfx_opengl_legacy.c
View File

@ -3,6 +3,7 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <assert.h> #include <assert.h>
#include <unistd.h>
#ifndef _LANGUAGE_C #ifndef _LANGUAGE_C
# define _LANGUAGE_C # define _LANGUAGE_C
@ -32,40 +33,11 @@
# endif # endif
#endif #endif
// redefine this if using a different GL loader
#define mglGetProcAddress(name) SDL_GL_GetProcAddress(name)
// we'll define and load it manually in init, just in case
typedef void (*PFNMGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void *pointer);
static PFNMGLFOGCOORDPOINTERPROC mglFogCoordPointer = NULL;
// since these can have different names, might as well redefine them to a single one
#undef GL_FOG_COORD_SRC
#undef GL_FOG_COORD
#undef GL_FOG_COORD_ARRAY
#define GL_FOG_COORD_SRC 0x8450
#define GL_FOG_COORD 0x8451
#define GL_FOG_COORD_ARRAY 0x8457
#include "../platform.h" #include "../platform.h"
#include "gfx_cc.h" #include "gfx_cc.h"
#include "gfx_rendering_api.h" #include "gfx_rendering_api.h"
#include "macros.h" #include "macros.h"
enum MixFlags {
SH_MF_OVERRIDE_ALPHA = 1,
SH_MF_MULTIPLY = 2,
SH_MF_MIX = 4,
SH_MF_SINGLE = 8,
SH_MF_MULTIPLY_ALPHA = 16,
SH_MF_MIX_ALPHA = 32,
SH_MF_SINGLE_ALPHA = 64,
SH_MF_INPUT_ALPHA = 128,
};
enum MixType { enum MixType {
SH_MT_NONE, SH_MT_NONE,
SH_MT_TEXTURE, SH_MT_TEXTURE,
@ -76,119 +48,121 @@ enum MixType {
}; };
struct ShaderProgram { struct ShaderProgram {
bool enabled;
uint32_t shader_id; uint32_t shader_id;
struct CCFeatures cc;
enum MixType mix; enum MixType mix;
uint32_t mix_flags;
bool texture_used[2]; bool texture_used[2];
int texture_ord[2];
int num_inputs; int num_inputs;
}; };
struct SamplerState {
GLenum min_filter;
GLenum mag_filter;
GLenum wrap_s;
GLenum wrap_t;
GLuint tex;
};
static struct ShaderProgram shader_program_pool[64]; static struct ShaderProgram shader_program_pool[64];
static uint8_t shader_program_pool_size; static uint8_t shader_program_pool_size;
static struct ShaderProgram *cur_shader = NULL; static struct ShaderProgram *cur_shader = NULL;
static struct SamplerState tmu_state[2];
static const float *cur_buf = NULL; static const float *cur_buf = NULL;
static const float *cur_fog_ofs = NULL; static const float *cur_fog_ofs = NULL;
static size_t cur_buf_size = 0; static size_t cur_buf_size = 0;
static size_t cur_buf_num_tris = 0; static size_t cur_buf_num_tris = 0;
static size_t cur_buf_stride = 0; static size_t cur_buf_stride = 0;
static bool gl_blend = false; static bool gl_blend = false;
static bool gl_adv_fog = false;
static bool gl_npot = false;
static bool gl_multitexture = false;
static void *scale_buf = NULL;
static int scale_buf_size = 0;
static float c_mix[] = { 0.f, 0.f, 0.f, 1.f };
static float c_invmix[] = { 1.f, 1.f, 1.f, 1.f };
static const float c_white[] = { 1.f, 1.f, 1.f, 1.f }; static const float c_white[] = { 1.f, 1.f, 1.f, 1.f };
// from https://github.com/z2442/sm64-port
static void resample_32bit(const uint32_t *in, const int inwidth, const int inheight, uint32_t *out, const int outwidth, const int outheight) {
int i, j;
const uint32_t *inrow;
uint32_t frac, fracstep;
fracstep = inwidth * 0x10000 / outwidth;
for (i = 0; i < outheight; i++, out += outwidth) {
inrow = in + inwidth * (i * inheight / outheight);
frac = fracstep >> 1;
for (j = 0; j < outwidth; j += 4) {
out[j] = inrow[frac >> 16];
frac += fracstep;
out[j + 1] = inrow[frac >> 16];
frac += fracstep;
out[j + 2] = inrow[frac >> 16];
frac += fracstep;
out[j + 3] = inrow[frac >> 16];
frac += fracstep;
}
}
}
static inline uint32_t next_pot(uint32_t v) {
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
static inline uint32_t is_pot(const uint32_t v) {
return (v & (v - 1)) == 0;
}
static bool gfx_opengl_z_is_from_0_to_1(void) { static bool gfx_opengl_z_is_from_0_to_1(void) {
return false; return false;
} }
#define TEXENV_COMBINE_ON() glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE) static inline GLenum texenv_set_color(UNUSED struct ShaderProgram *prg) {
#define TEXENV_COMBINE_OFF() glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) return GL_MODULATE;
#define TEXENV_COMBINE_OP(num, cval, aval) \
do { \
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND ## num ## _RGB, cval); \
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND ## num ## _ALPHA, aval); \
} while (0)
#define TEXENV_COMBINE_SET1(what, mode, val) \
do { \
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ ## what, mode); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ ## what, val); \
} while (0)
#define TEXENV_COMBINE_SET2(what, mode, val1, val2) \
do { \
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ ## what, mode); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ ## what, val1); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ ## what, val2); \
} while (0)
#define TEXENV_COMBINE_SET3(what, mode, val1, val2, val3) \
do { \
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ ## what, mode); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ ## what, val1); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ ## what, val2); \
glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_ ## what, val3); \
} while (0)
static inline void texenv_set_texture_color(struct ShaderProgram *prg) {
glActiveTexture(GL_TEXTURE0);
if (prg->mix_flags & SH_MF_OVERRIDE_ALPHA) {
TEXENV_COMBINE_ON();
if (prg->mix_flags & SH_MF_SINGLE_ALPHA) {
if (prg->mix_flags & SH_MF_MULTIPLY) {
// keep the alpha but modulate the color
const GLenum alphasrc = (prg->mix_flags & SH_MF_INPUT_ALPHA) ? GL_PRIMARY_COLOR : GL_TEXTURE;
TEXENV_COMBINE_SET2(RGB, GL_MODULATE, GL_TEXTURE, GL_PRIMARY_COLOR);
TEXENV_COMBINE_SET1(ALPHA, GL_REPLACE, alphasrc);
} else {
// somehow makes it keep the color while taking the alpha from primary color
TEXENV_COMBINE_SET1(RGB, GL_REPLACE, GL_TEXTURE);
}
} else { // if (prg->mix_flags & SH_MF_SINGLE) {
if (prg->mix_flags & SH_MF_MULTIPLY_ALPHA) {
// modulate the alpha but keep the color
TEXENV_COMBINE_SET2(ALPHA, GL_MODULATE, GL_TEXTURE, GL_PRIMARY_COLOR);
TEXENV_COMBINE_SET1(RGB, GL_REPLACE, GL_TEXTURE);
} else {
// somehow makes it keep the alpha
TEXENV_COMBINE_SET1(ALPHA, GL_REPLACE, GL_TEXTURE);
}
}
// TODO: MIX and the other one
} else if (prg->mix_flags & SH_MF_MULTIPLY) {
// TODO: is this right?
TEXENV_COMBINE_OFF();
} else if (prg->mix_flags & SH_MF_MIX) {
TEXENV_COMBINE_ON();
// HACK: determine this using flags and not this crap
if (prg->num_inputs > 1) {
// out.rgb = mix(color0.rgb, color1.rgb, texel0.rgb);
// no color1 tho, so mix with white (texenv color is set in init())
TEXENV_COMBINE_OP(2, GL_SRC_COLOR, GL_SRC_ALPHA);
TEXENV_COMBINE_SET3(RGB, GL_INTERPOLATE, GL_CONSTANT, GL_PRIMARY_COLOR, GL_TEXTURE);
TEXENV_COMBINE_SET1(ALPHA, GL_REPLACE, GL_CONSTANT);
} else {
// out.rgb = mix(color0.rgb, texel0.rgb, texel0.a);
TEXENV_COMBINE_OP(2, GL_SRC_ALPHA, GL_SRC_ALPHA);
TEXENV_COMBINE_SET3(RGB, GL_INTERPOLATE, GL_TEXTURE, GL_PRIMARY_COLOR, GL_TEXTURE);
}
} else {
TEXENV_COMBINE_OFF();
}
} }
static inline void texenv_set_texture_texture(UNUSED struct ShaderProgram *prg) { static inline GLenum texenv_set_texture(UNUSED struct ShaderProgram *prg) {
glActiveTexture(GL_TEXTURE0); return GL_MODULATE;
TEXENV_COMBINE_OFF(); }
glActiveTexture(GL_TEXTURE1);
TEXENV_COMBINE_ON(); static inline GLenum texenv_set_texture_color(struct ShaderProgram *prg) {
// out.rgb = mix(texel0.rgb, texel1.rgb, color0.rgb); GLenum mode;
TEXENV_COMBINE_OP(2, GL_SRC_COLOR, GL_SRC_ALPHA);
TEXENV_COMBINE_SET3(RGB, GL_INTERPOLATE, GL_PREVIOUS, GL_TEXTURE, GL_PRIMARY_COLOR); // HACK: lord forgive me for this, but this is easier
// out.a = texel0.a;
TEXENV_COMBINE_SET1(ALPHA, GL_REPLACE, GL_PREVIOUS); switch (prg->shader_id) {
case 0x0000038D: // mario's eyes
case 0x01045A00: // peach letter
case 0x01200A00: // intro copyright fade in
mode = GL_DECAL;
break;
case 0x00000551: // goddard
mode = GL_BLEND;
break;
default:
mode = GL_MODULATE;
break;
}
return mode;
}
static inline GLenum texenv_set_texture_texture(UNUSED struct ShaderProgram *prg) {
return GL_MODULATE;
} }
static void gfx_opengl_apply_shader(struct ShaderProgram *prg) { static void gfx_opengl_apply_shader(struct ShaderProgram *prg) {
@ -199,31 +173,19 @@ static void gfx_opengl_apply_shader(struct ShaderProgram *prg) {
ofs += 4; ofs += 4;
// have texture(s), specify same texcoords for every active texture // have texture(s), specify same texcoords for every active texture
for (int i = 0; i < 2; ++i) { if (prg->texture_used[0] || prg->texture_used[1]) {
if (prg->texture_used[i]) { glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE0 + i); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0 + i); glTexCoordPointer(2, GL_FLOAT, cur_buf_stride, ofs);
glActiveTexture(GL_TEXTURE0 + i); ofs += 2;
glEnableClientState(GL_TEXTURE_COORD_ARRAY); } else {
glTexCoordPointer(2, GL_FLOAT, cur_buf_stride, ofs); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_2D);
ofs += 2;
}
} }
if (prg->shader_id & SHADER_OPT_FOG) { if (prg->shader_id & SHADER_OPT_FOG) {
// fog requested, we can deal with it in one of two ways // blend it on top of normal tris later
if (gl_adv_fog) { cur_fog_ofs = ofs;
// if GL_EXT_fog_coord is available, use the provided fog factor as scaled depth for GL fog
const float fogrgb[] = { ofs[0], ofs[1], ofs[2] };
glEnable(GL_FOG);
glFogfv(GL_FOG_COLOR, fogrgb); // color is the same for all verts, only intensity is different
glEnableClientState(GL_FOG_COORD_ARRAY);
mglFogCoordPointer(GL_FLOAT, cur_buf_stride, ofs + 3); // point it to alpha, which is fog factor
} else {
// if there's no fog coords available, blend it on top of normal tris later
cur_fog_ofs = ofs;
}
ofs += 4; ofs += 4;
} }
@ -232,139 +194,112 @@ static void gfx_opengl_apply_shader(struct ShaderProgram *prg) {
// TODO: more than one color (maybe glSecondaryColorPointer?) // TODO: more than one color (maybe glSecondaryColorPointer?)
// HACK: if there's a texture and two colors, one of them is likely for speculars or some shit (see mario head) // HACK: if there's a texture and two colors, one of them is likely for speculars or some shit (see mario head)
// if there's two colors but no texture, the real color is likely the second one // if there's two colors but no texture, the real color is likely the second one
const int hack = (prg->num_inputs > 1) * (4 - (int)prg->texture_used[0]); // HACKHACK: alpha is 0 in the transition shader (0x01A00045), maybe figure out the flags instead
glEnableClientState(GL_COLOR_ARRAY); const int vlen = (prg->cc.opt_alpha && prg->shader_id != 0x01A00045) ? 4 : 3;
glColorPointer(4, GL_FLOAT, cur_buf_stride, ofs + hack); const int hack = vlen * (prg->num_inputs > 1);
ofs += 4 * prg->num_inputs;
if (prg->texture_used[1] && prg->cc.do_mix[0]) {
// HACK: when two textures are mixed by vertex color, store the color
// it will be used later when rendering two texture passes
c_mix[0] = *(ofs + hack + 0);
c_mix[1] = *(ofs + hack + 1);
c_mix[2] = *(ofs + hack + 2);
c_invmix[0] = 1.f - c_mix[0];
c_invmix[1] = 1.f - c_mix[1];
c_invmix[2] = 1.f - c_mix[2];
glDisableClientState(GL_COLOR_ARRAY);
glColor3f(c_mix[0], c_mix[1], c_mix[2]);
} else {
// otherwise use vertex colors as normal
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(vlen, GL_FLOAT, cur_buf_stride, ofs + hack);
}
ofs += prg->num_inputs * vlen;
} else {
glDisableClientState(GL_COLOR_ARRAY);
} }
if (prg->shader_id & SHADER_OPT_TEXTURE_EDGE) { if (!prg->enabled) {
// (horrible) alpha discard // we only need to do this once
glEnable(GL_ALPHA_TEST); prg->enabled = true;
glAlphaFunc(GL_GREATER, 0.3f);
}
// configure formulae if (prg->shader_id & SHADER_OPT_TEXTURE_EDGE) {
switch (prg->mix) { // (horrible) alpha discard
case SH_MT_TEXTURE: glEnable(GL_ALPHA_TEST);
glActiveTexture(GL_TEXTURE0); glAlphaFunc(GL_GREATER, 0.666f);
TEXENV_COMBINE_OFF(); } else {
break; glDisable(GL_ALPHA_TEST);
}
case SH_MT_TEXTURE_COLOR: // configure texenv
texenv_set_texture_color(prg); GLenum mode;
break; switch (prg->mix) {
case SH_MT_TEXTURE: mode = texenv_set_texture(prg); break;
case SH_MT_TEXTURE_TEXTURE: case SH_MT_TEXTURE_TEXTURE: mode = texenv_set_texture_texture(prg); break;
texenv_set_texture_texture(prg); case SH_MT_TEXTURE_COLOR: mode = texenv_set_texture_color(prg); break;
break; default: mode = texenv_set_color(prg); break;
}
default: glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode);
break;
} }
} }
static void gfx_opengl_unload_shader(struct ShaderProgram *old_prg) { static void gfx_opengl_unload_shader(struct ShaderProgram *old_prg) {
if (cur_shader == old_prg || old_prg == NULL) if (cur_shader && (cur_shader == old_prg || !old_prg)) {
cur_shader->enabled = false;
cur_shader = NULL; cur_shader = NULL;
}
glClientActiveTexture(GL_TEXTURE0);
glActiveTexture(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE1);
glActiveTexture(GL_TEXTURE1);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_TEXTURE1);
glDisable(GL_TEXTURE0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_FOG);
cur_fog_ofs = NULL; // clear fog colors cur_fog_ofs = NULL; // clear fog colors
glDisableClientState(GL_COLOR_ARRAY);
if (gl_adv_fog) glDisableClientState(GL_FOG_COORD_ARRAY);
} }
static void gfx_opengl_load_shader(struct ShaderProgram *new_prg) { static void gfx_opengl_load_shader(struct ShaderProgram *new_prg) {
cur_shader = new_prg; cur_shader = new_prg;
// gfx_opengl_apply_shader(cur_shader); if (cur_shader)
cur_shader->enabled = false;
} }
static struct ShaderProgram *gfx_opengl_create_and_load_new_shader(uint32_t shader_id) { static struct ShaderProgram *gfx_opengl_create_and_load_new_shader(uint32_t shader_id) {
uint8_t c[2][4]; struct CCFeatures ccf;
for (int i = 0; i < 4; i++) { gfx_cc_get_features(shader_id, &ccf);
c[0][i] = (shader_id >> (i * 3)) & 7;
c[1][i] = (shader_id >> (12 + i * 3)) & 7;
}
bool used_textures[2] = {0, 0};
int num_inputs = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 4; j++) {
if (c[i][j] >= SHADER_INPUT_1 && c[i][j] <= SHADER_INPUT_4) {
if (c[i][j] > num_inputs) {
num_inputs = c[i][j];
}
}
if (c[i][j] == SHADER_TEXEL0 || c[i][j] == SHADER_TEXEL0A) {
used_textures[0] = true;
}
if (c[i][j] == SHADER_TEXEL1) {
used_textures[1] = true;
}
}
}
const bool color_alpha_same = (shader_id & 0xfff) == ((shader_id >> 12) & 0xfff);
const bool do_multiply[2] = {c[0][1] == 0 && c[0][3] == 0, c[1][1] == 0 && c[1][3] == 0};
const bool do_mix[2] = {c[0][1] == c[0][3], c[1][1] == c[1][3]};
const bool do_single[2] = {c[0][2] == 0, c[1][2] == 0};
struct ShaderProgram *prg = &shader_program_pool[shader_program_pool_size++]; struct ShaderProgram *prg = &shader_program_pool[shader_program_pool_size++];
prg->shader_id = shader_id; prg->shader_id = shader_id;
prg->num_inputs = num_inputs; prg->cc = ccf;
prg->texture_used[0] = used_textures[0]; prg->num_inputs = ccf.num_inputs;
prg->texture_used[1] = used_textures[1]; prg->texture_used[0] = ccf.used_textures[0];
prg->texture_used[1] = ccf.used_textures[1];
if (used_textures[0] && used_textures[1]) if (ccf.used_textures[0] && ccf.used_textures[1]) {
prg->mix = SH_MT_TEXTURE_TEXTURE; prg->mix = SH_MT_TEXTURE_TEXTURE;
else if (used_textures[0] && num_inputs) if (ccf.do_single[1]) {
prg->texture_ord[0] = 1;
prg->texture_ord[1] = 0;
} else {
prg->texture_ord[0] = 0;
prg->texture_ord[1] = 1;
}
} else if (ccf.used_textures[0] && ccf.num_inputs) {
prg->mix = SH_MT_TEXTURE_COLOR; prg->mix = SH_MT_TEXTURE_COLOR;
else if (used_textures[0]) } else if (ccf.used_textures[0]) {
prg->mix = SH_MT_TEXTURE; prg->mix = SH_MT_TEXTURE;
else if (num_inputs > 1) } else if (ccf.num_inputs > 1) {
prg->mix = SH_MT_COLOR_COLOR; prg->mix = SH_MT_COLOR_COLOR;
else if (num_inputs) } else if (ccf.num_inputs) {
prg->mix = SH_MT_COLOR; prg->mix = SH_MT_COLOR;
if (do_single[0]) prg->mix_flags |= SH_MF_SINGLE;
if (do_multiply[0]) prg->mix_flags |= SH_MF_MULTIPLY;
if (do_mix[0]) prg->mix_flags |= SH_MF_MIX;
if (!color_alpha_same && (shader_id & SHADER_OPT_ALPHA)) {
prg->mix_flags |= SH_MF_OVERRIDE_ALPHA;
if (do_single[1]) prg->mix_flags |= SH_MF_SINGLE_ALPHA;
if (do_multiply[1]) prg->mix_flags |= SH_MF_MULTIPLY_ALPHA;
if (do_mix[1]) prg->mix_flags |= SH_MF_MIX_ALPHA;
if (c[1][3] < SHADER_TEXEL0) prg->mix_flags |= SH_MF_INPUT_ALPHA;
} }
prg->enabled = false;
gfx_opengl_load_shader(prg); gfx_opengl_load_shader(prg);
return prg; return prg;
} }
static struct ShaderProgram *gfx_opengl_lookup_shader(uint32_t shader_id) { static struct ShaderProgram *gfx_opengl_lookup_shader(uint32_t shader_id) {
for (size_t i = 0; i < shader_program_pool_size; i++) { for (size_t i = 0; i < shader_program_pool_size; i++)
if (shader_program_pool[i].shader_id == shader_id) { if (shader_program_pool[i].shader_id == shader_id)
return &shader_program_pool[i]; return &shader_program_pool[i];
}
}
return NULL; return NULL;
} }
@ -381,35 +316,72 @@ static GLuint gfx_opengl_new_texture(void) {
} }
static void gfx_opengl_select_texture(int tile, GLuint texture_id) { static void gfx_opengl_select_texture(int tile, GLuint texture_id) {
glActiveTexture(GL_TEXTURE0 + tile); tmu_state[tile].tex = texture_id; // remember this for multitexturing later
glBindTexture(GL_TEXTURE_2D, texture_id); glBindTexture(GL_TEXTURE_2D, texture_id);
} }
static void gfx_opengl_upload_texture(uint8_t *rgba32_buf, int width, int height) { static inline void *gfx_opengl_scale_texture(const uint8_t *data, const int w, const int h, const int to_w, const int to_h) {
const int psize = to_w * to_h * 4;
// realloc scale buffer if it's too small
if (psize > scale_buf_size) {
scale_buf = realloc(scale_buf, psize);
if (!scale_buf) sys_fatal("Out of memory allocating NPOT scale buffer\n");
scale_buf_size = psize;
}
resample_32bit((const uint32_t *)data, w, h, scale_buf, to_w, to_h);
return scale_buf;
}
static void gfx_opengl_upload_texture(const uint8_t *rgba32_buf, int width, int height) {
if (!gl_npot) {
// we don't support non power of two textures, scale to next power of two if necessary
if (!is_pot(width) || !is_pot(height)) {
const int pwidth = next_pot(width);
const int pheight = next_pot(height);
rgba32_buf = gfx_opengl_scale_texture(rgba32_buf, width, height, pwidth, pheight);
width = pwidth;
height = pheight;
}
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba32_buf); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba32_buf);
} }
static uint32_t gfx_cm_to_opengl(uint32_t val) { static inline GLenum gfx_cm_to_opengl(uint32_t val) {
if (val & G_TX_CLAMP) if (val & G_TX_CLAMP) return GL_CLAMP_TO_EDGE;
return GL_CLAMP_TO_EDGE;
return (val & G_TX_MIRROR) ? GL_MIRRORED_REPEAT : GL_REPEAT; return (val & G_TX_MIRROR) ? GL_MIRRORED_REPEAT : GL_REPEAT;
} }
static inline void gfx_opengl_apply_tmu_state(const int tile) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, tmu_state[tile].min_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, tmu_state[tile].mag_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, tmu_state[tile].wrap_s);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tmu_state[tile].wrap_t);
}
static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) { static void gfx_opengl_set_sampler_parameters(int tile, bool linear_filter, uint32_t cms, uint32_t cmt) {
const GLenum filter = linear_filter ? GL_LINEAR : GL_NEAREST; const GLenum filter = linear_filter ? GL_LINEAR : GL_NEAREST;
glActiveTexture(GL_TEXTURE0 + tile);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); const GLenum wrap_s = gfx_cm_to_opengl(cms);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); const GLenum wrap_t = gfx_cm_to_opengl(cmt);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, gfx_cm_to_opengl(cms));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, gfx_cm_to_opengl(cmt)); tmu_state[tile].min_filter = filter;
tmu_state[tile].mag_filter = filter;
tmu_state[tile].wrap_s = wrap_s;
tmu_state[tile].wrap_t = wrap_t;
// set state for the first texture right away
if (!tile) gfx_opengl_apply_tmu_state(tile);
} }
static void gfx_opengl_set_depth_test(bool depth_test) { static void gfx_opengl_set_depth_test(bool depth_test) {
if (depth_test) { if (depth_test)
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
} else { else
glDisable(GL_DEPTH_TEST); glDisable(GL_DEPTH_TEST);
}
} }
static void gfx_opengl_set_depth_mask(bool z_upd) { static void gfx_opengl_set_depth_mask(bool z_upd) {
@ -436,26 +408,19 @@ static void gfx_opengl_set_scissor(int x, int y, int width, int height) {
static void gfx_opengl_set_use_alpha(bool use_alpha) { static void gfx_opengl_set_use_alpha(bool use_alpha) {
gl_blend = use_alpha; gl_blend = use_alpha;
if (use_alpha) { if (use_alpha)
glEnable(GL_BLEND); glEnable(GL_BLEND);
} else { else
glDisable(GL_BLEND); glDisable(GL_BLEND);
}
} }
// draws the same triangles as plain fog color + fog intensity as alpha // draws the same triangles as plain fog color + fog intensity as alpha
// on top of the normal tris and blends them to achieve sort of the same effect // on top of the normal tris and blends them to achieve sort of the same effect
// as fog would // as fog would
static inline void gfx_opengl_blend_fog_tris(void) { static inline void gfx_opengl_pass_fog(void) {
// if a texture was used, replace it with fog color instead, but still keep the alpha // if texturing is enabled, disable it, since we're blending colors
if (cur_shader->texture_used[0]) { if (cur_shader->texture_used[0] || cur_shader->texture_used[1])
glActiveTexture(GL_TEXTURE0); glDisable(GL_TEXTURE_2D);
TEXENV_COMBINE_ON();
// out.rgb = input0.rgb
TEXENV_COMBINE_SET1(RGB, GL_REPLACE, GL_PRIMARY_COLOR);
// out.a = texel0.a * input0.a
TEXENV_COMBINE_SET2(ALPHA, GL_MODULATE, GL_TEXTURE, GL_PRIMARY_COLOR);
}
glEnableClientState(GL_COLOR_ARRAY); // enable color array temporarily glEnableClientState(GL_COLOR_ARRAY); // enable color array temporarily
glColorPointer(4, GL_FLOAT, cur_buf_stride, cur_fog_ofs); // set fog colors as primary colors glColorPointer(4, GL_FLOAT, cur_buf_stride, cur_fog_ofs); // set fog colors as primary colors
@ -467,11 +432,38 @@ static inline void gfx_opengl_blend_fog_tris(void) {
glDepthFunc(GL_LESS); // set back to default glDepthFunc(GL_LESS); // set back to default
if (!gl_blend) glDisable(GL_BLEND); // disable blending if it was disabled if (!gl_blend) glDisable(GL_BLEND); // disable blending if it was disabled
glDisableClientState(GL_COLOR_ARRAY); // will get reenabled later anyway glDisableClientState(GL_COLOR_ARRAY); // will get reenabled later anyway
// if texturing was enabled, re-enable it
if (cur_shader->texture_used[0] || cur_shader->texture_used[1])
glEnable(GL_TEXTURE_2D);
}
// this assumes the two textures are combined like so:
// result = mix(tex0.rgb, tex1.rgb, vertex.rgb)
static inline void gfx_opengl_pass_mix_texture(void) {
// set second texture
glBindTexture(GL_TEXTURE_2D, tmu_state[cur_shader->texture_ord[1]].tex);
gfx_opengl_apply_tmu_state(cur_shader->texture_ord[1]);
if (!gl_blend) glEnable(GL_BLEND); // enable blending temporarily
glBlendFunc(GL_ONE, GL_ONE); // additive blending
glDepthFunc(GL_LEQUAL); // Z is the same as the base triangles
// draw the same triangles, but with the inverse of the mix color
glColor3f(c_invmix[0], c_invmix[1], c_invmix[2]);
glDrawArrays(GL_TRIANGLES, 0, 3 * cur_buf_num_tris);
glColor3f(1.f, 1.f, 1.f); // reset color
glDepthFunc(GL_LESS); // set back to default
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // same here
if (!gl_blend) glDisable(GL_BLEND); // disable blending if it was disabled
// set old texture
glBindTexture(GL_TEXTURE_2D, tmu_state[cur_shader->texture_ord[0]].tex);
gfx_opengl_apply_tmu_state(cur_shader->texture_ord[0]);
} }
static void gfx_opengl_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) { static void gfx_opengl_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_t buf_vbo_num_tris) {
//printf("flushing %d tris\n", buf_vbo_num_tris);
cur_buf = buf_vbo; cur_buf = buf_vbo;
cur_buf_size = buf_vbo_len * 4; cur_buf_size = buf_vbo_len * 4;
cur_buf_num_tris = buf_vbo_num_tris; cur_buf_num_tris = buf_vbo_num_tris;
@ -479,10 +471,17 @@ static void gfx_opengl_draw_triangles(float buf_vbo[], size_t buf_vbo_len, size_
gfx_opengl_apply_shader(cur_shader); gfx_opengl_apply_shader(cur_shader);
// if there's two textures, set primary texture first
if (cur_shader->texture_used[1])
glBindTexture(GL_TEXTURE_2D, tmu_state[cur_shader->texture_ord[0]].tex);
glDrawArrays(GL_TRIANGLES, 0, 3 * cur_buf_num_tris); glDrawArrays(GL_TRIANGLES, 0, 3 * cur_buf_num_tris);
// if there's two textures, draw polys with the second texture
if (cur_shader->texture_used[1]) gfx_opengl_pass_mix_texture();
// cur_fog_ofs is only set if GL_EXT_fog_coord isn't used // cur_fog_ofs is only set if GL_EXT_fog_coord isn't used
if (cur_fog_ofs) gfx_opengl_blend_fog_tris(); if (cur_fog_ofs) gfx_opengl_pass_fog();
} }
static inline bool gl_check_ext(const char *name) { static inline bool gl_check_ext(const char *name) {
@ -492,7 +491,7 @@ static inline bool gl_check_ext(const char *name) {
extstr = (const char *)glGetString(GL_EXTENSIONS); extstr = (const char *)glGetString(GL_EXTENSIONS);
if (!strstr(extstr, name)) { if (!strstr(extstr, name)) {
fprintf(stderr, "GL extension not supported: %s\n", name); printf("GL extension not supported: %s\n", name);
return false; return false;
} }
@ -526,54 +525,34 @@ static void gfx_opengl_init(void) {
int vmajor, vminor; int vmajor, vminor;
bool is_es = false; bool is_es = false;
gl_get_version(&vmajor, &vminor, &is_es); gl_get_version(&vmajor, &vminor, &is_es);
if (vmajor < 2 && vminor < 2 && !is_es) if ((vmajor < 2 && vminor < 1) || is_es)
sys_fatal("OpenGL 1.2+ is required.\nReported version: %s%d.%d", is_es ? "ES" : "", vmajor, vminor); sys_fatal("OpenGL 1.1+ is required.\nReported version: %s%d.%d\n", is_es ? "ES" : "", vmajor, vminor);
// check extensions that we need // check if we support non power of two textures
const bool supported = gl_npot = gl_check_ext("GL_ARB_texture_non_power_of_two");
gl_check_ext("GL_ARB_multitexture") && if (!gl_npot) {
gl_check_ext("GL_ARB_texture_env_combine"); // don't support NPOT textures, prepare buffer for rescaling
// this will be realloc'd as necessary
if (!supported) scale_buf_size = 64 * 64 * 4;
sys_fatal("required GL extensions are not supported"); scale_buf = malloc(scale_buf_size);
if (!scale_buf) sys_fatal("Out of memory allocating for NPOT scale buffer\n");
gl_adv_fog = false;
// check whether we can use advanced fog shit
const bool fog_ext =
vmajor > 1 || vminor > 3 ||
gl_check_ext("GL_EXT_fog_coord") ||
gl_check_ext("GL_ARB_fog_coord");
if (fog_ext) {
// try to load manually, as this might be an extension, and even then the ext list may lie
mglFogCoordPointer = mglGetProcAddress("glFogCoordPointer");
if (!mglFogCoordPointer) mglFogCoordPointer = mglGetProcAddress("glFogCoordPointerEXT");
if (!mglFogCoordPointer) mglFogCoordPointer = mglGetProcAddress("glFogCoordPointerARB");
if (!mglFogCoordPointer)
printf("glFogCoordPointer is not actually available, it won't be used.\n");
else
gl_adv_fog = true; // appears to be all good
} }
// check if we support multitexturing
gl_multitexture = vmajor > 1 || vminor > 2 || gl_check_ext("GL_ARB_multitexture");
printf("GL_VERSION = %s\n", glGetString(GL_VERSION)); printf("GL_VERSION = %s\n", glGetString(GL_VERSION));
printf("GL_EXTENSIONS =\n%s\n", glGetString(GL_EXTENSIONS)); printf("GL_EXTENSIONS =\n%s\n", glGetString(GL_EXTENSIONS));
if (gl_adv_fog) {
// set fog params, they never change
printf("GL_EXT_fog_coord available, using that for fog\n");
glFogi(GL_FOG_COORD_SRC, GL_FOG_COORD);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 0.0f);
glFogf(GL_FOG_END, 1.0f);
}
// these also never change // these also never change
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
// glDisable(GL_DITHER);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, c_white); glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, c_white);
TEXENV_COMBINE_OP(0, GL_SRC_COLOR, GL_SRC_ALPHA);
TEXENV_COMBINE_OP(1, GL_SRC_COLOR, GL_SRC_ALPHA);
} }
static void gfx_opengl_on_resize(void) { static void gfx_opengl_on_resize(void) {