void gl4es_glLightModelf(GLenum pname, GLfloat param) {
//printf("%sglLightModelf(%04X, %.2f)\n", (state.list.compiling)?"list":"", pname, param);
if (glstate->list.compiling && glstate->list.active) {
GLfloat dummy[4];
dummy[0]=param;
gl4es_glLightModelfv(pname, dummy);
return;
}
LOAD_GLES(glLightModelf);
switch (pname) {
case GL_LIGHT_MODEL_AMBIENT:
case GL_LIGHT_MODEL_TWO_SIDE:
errorGL();
gles_glLightModelf(pname, param);
break;
default:
errorShim(GL_INVALID_ENUM);
//printf("stubbed glLightModelf(%i, %.2f)\n", pname, param);
break;
}
}
void gl4es_glPopAttrib() {
//printf("glPopAttrib()\n");
noerrorShim();
if ((glstate->list.compiling || glstate->gl_batch) && glstate->list.active) {
NewStage(glstate->list.active, STAGE_POP);
glstate->list.active->popattribute = true;
return;
}
if (glstate->stack == NULL || glstate->stack->len == 0) {
errorShim(GL_STACK_UNDERFLOW);
return;
}
glstack_t *cur = glstate->stack + glstate->stack->len-1;
if (cur->mask & GL_COLOR_BUFFER_BIT) {
enable_disable(GL_ALPHA_TEST, cur->alpha_test);
gl4es_glAlphaFunc(cur->alpha_test_func, cur->alpha_test_ref);
enable_disable(GL_BLEND, cur->blend);
gl4es_glBlendFunc(cur->blend_src_func, cur->blend_dst_func);
enable_disable(GL_DITHER, cur->dither);
enable_disable(GL_COLOR_LOGIC_OP, cur->color_logic_op);
gl4es_glLogicOp(cur->logic_op);
GLfloat *c;
gl4es_glClearColor(v4(cur->clear_color));
gl4es_glColorMask(v4(cur->color_mask));
}
if (cur->mask & GL_CURRENT_BIT) {
gl4es_glColor4f(v4(cur->color));
gl4es_glNormal3f(v3(cur->normal));
gl4es_glTexCoord4f(v4(cur->tex));
}
if (cur->mask & GL_DEPTH_BUFFER_BIT) {
enable_disable(GL_DEPTH_TEST, cur->depth_test);
gl4es_glDepthFunc(cur->depth_func);
gl4es_glClearDepth(cur->clear_depth);
gl4es_glDepthMask(cur->depth_mask);
}
if (cur->mask & GL_ENABLE_BIT) {
int i;
enable_disable(GL_ALPHA_TEST, cur->alpha_test);
enable_disable(GL_AUTO_NORMAL, cur->autonormal);
enable_disable(GL_BLEND, cur->blend);
GLint max_clip_planes;
gl4es_glGetIntegerv(GL_MAX_CLIP_PLANES, &max_clip_planes);
for (i = 0; i < max_clip_planes; i++) {
enable_disable(GL_CLIP_PLANE0 + i, *(cur->clip_planes_enabled + i));
}
enable_disable(GL_COLOR_MATERIAL, cur->colormaterial);
enable_disable(GL_CULL_FACE, cur->cull_face);
enable_disable(GL_DEPTH_TEST, cur->depth_test);
enable_disable(GL_DITHER, cur->dither);
enable_disable(GL_FOG, cur->fog);
for (i = 0; i < hardext.maxlights; i++) {
enable_disable(GL_LIGHT0 + i, *(cur->lights_enabled + i));
}
enable_disable(GL_LIGHTING, cur->lighting);
enable_disable(GL_LINE_SMOOTH, cur->line_smooth);
enable_disable(GL_LINE_STIPPLE, cur->line_stipple);
enable_disable(GL_COLOR_LOGIC_OP, cur->color_logic_op);
//TODO: GL_INDEX_LOGIC_OP
//TODO: GL_MAP1_x
//TODO: GL_MAP2_x
enable_disable(GL_MULTISAMPLE, cur->multisample);
enable_disable(GL_NORMALIZE, cur->normalize);
enable_disable(GL_POINT_SMOOTH, cur->point_smooth);
//TODO: GL_POLYGON_OFFSET_LINE
enable_disable(GL_POLYGON_OFFSET_FILL, cur->polygon_offset_fill);
//TODO: GL_POLYGON_OFFSET_POINT
//TODO: GL_POLYGON_SMOOTH
//TODO: GL_POLYGON_STIPPLE
enable_disable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur->sample_alpha_to_coverage);
enable_disable(GL_SAMPLE_ALPHA_TO_ONE, cur->sample_alpha_to_one);
enable_disable(GL_SAMPLE_COVERAGE, cur->sample_coverage);
enable_disable(GL_SCISSOR_TEST, cur->scissor_test);
enable_disable(GL_STENCIL_TEST, cur->stencil_test);
enable_disable(GL_POINT_SPRITE, cur->pointsprite);
int a;
int old_tex = glstate->texture.active;
for (a=0; a<hardext.maxtex; a++) {
if(glstate->enable.texture[a] != cur->tex_enabled[a]) {
gl4es_glActiveTexture(GL_TEXTURE0+a);
for (int j=0; j<ENABLED_TEXTURE_LAST; j++) {
const GLuint t = cur->tex_enabled[a] & (1<<j);
if ((glstate->enable.texture[a] & (1<<j)) != t) {
enable_disable(to_target(j), t);
}
}
}
glstate->enable.texgen_r[a] = cur->texgen_r[a];
glstate->enable.texgen_s[a] = cur->texgen_s[a];
glstate->enable.texgen_t[a] = cur->texgen_t[a];
glstate->enable.texgen_q[a] = cur->texgen_q[a];
}
if (glstate->texture.active != old_tex) gl4es_glActiveTexture(GL_TEXTURE0+old_tex);
}
if (cur->mask & GL_FOG_BIT) {
enable_disable(GL_FOG, cur->fog);
gl4es_glFogfv(GL_FOG_COLOR, cur->fog_color);
gl4es_glFogf(GL_FOG_DENSITY, cur->fog_density);
gl4es_glFogf(GL_FOG_START, cur->fog_start);
gl4es_glFogf(GL_FOG_END, cur->fog_end);
gl4es_glFogf(GL_FOG_MODE, cur->fog_mode);
}
if (cur->mask & GL_HINT_BIT) {
gl4es_glHint(GL_PERSPECTIVE_CORRECTION_HINT, cur->perspective_hint);
gl4es_glHint(GL_POINT_SMOOTH_HINT, cur->point_smooth_hint);
gl4es_glHint(GL_LINE_SMOOTH_HINT, cur->line_smooth_hint);
gl4es_glHint(GL_FOG_HINT, cur->fog_hint);
gl4es_glHint(GL_GENERATE_MIPMAP_HINT, cur->mipmap_hint);
for (int i=GL4ES_HINT_FIRST; i<GL4ES_HINT_LAST; i++)
gl4es_glHint(i, cur->gles4_hint[i-GL4ES_HINT_FIRST]);
}
if (cur->mask & GL_LIGHTING_BIT) {
enable_disable(GL_LIGHTING, cur->lighting);
gl4es_glLightModelfv(GL_LIGHT_MODEL_AMBIENT, cur->light_model_ambient);
gl4es_glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, cur->light_model_two_side);
int i;
int j=0;
for (i = 0; i < hardext.maxlights; i++) {
enable_disable(GL_LIGHT0 + i, *(cur->lights_enabled + i));
#define L(A) gl4es_glLightfv(GL_LIGHT0 + i, A, cur->lights+j); j+=4
L(GL_AMBIENT);
L(GL_DIFFUSE);
L(GL_SPECULAR);
L(GL_POSITION);
L(GL_SPOT_CUTOFF);
L(GL_SPOT_DIRECTION);
L(GL_SPOT_EXPONENT);
L(GL_CONSTANT_ATTENUATION);
L(GL_LINEAR_ATTENUATION);
L(GL_QUADRATIC_ATTENUATION);
#undef L
}
j=0;
#define M(A) gl4es_glMaterialfv(GL_FRONT_AND_BACK, A, cur->materials+j); j+=4
M(GL_AMBIENT);
M(GL_DIFFUSE);
M(GL_SPECULAR);
M(GL_EMISSION);
M(GL_SHININESS); // handle both face at some point?
#undef M
gl4es_glShadeModel(cur->shade_model);
}
// GL_LIST_BIT
if (cur->mask & GL_LIST_BIT) {
gl4es_glListBase(cur->list_base);
}
if (cur->mask & GL_LINE_BIT) {
enable_disable(GL_LINE_SMOOTH, cur->line_smooth);
// TODO: stipple stuff here
gl4es_glLineWidth(cur->line_width);
}
if (cur->mask & GL_MULTISAMPLE_BIT) {
enable_disable(GL_MULTISAMPLE, cur->multisample);
enable_disable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur->sample_alpha_to_coverage);
enable_disable(GL_SAMPLE_ALPHA_TO_ONE, cur->sample_alpha_to_one);
enable_disable(GL_SAMPLE_COVERAGE, cur->sample_coverage);
}
if (cur->mask & GL_POINT_BIT) {
enable_disable(GL_POINT_SMOOTH, cur->point_smooth);
gl4es_glPointSize(cur->point_size);
if(hardext.pointsprite) {
enable_disable(GL_POINT_SPRITE, cur->pointsprite);
int a;
for (a=0; a<hardext.maxtex; a++) {
if(glstate->texture.pscoordreplace[a]!=cur->pscoordreplace[a]) {
gl4es_glActiveTexture(GL_TEXTURE0+a);
gl4es_glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, cur->pscoordreplace[a]);
}
}
if (glstate->texture.active!= cur->active) gl4es_glActiveTexture(GL_TEXTURE0+cur->active);
}
}
if (cur->mask & GL_SCISSOR_BIT) {
enable_disable(GL_SCISSOR_TEST, cur->scissor_test);
gl4es_glScissor(v4(cur->scissor_box));
}
if (cur->mask & GL_STENCIL_BUFFER_BIT) {
enable_disable(GL_STENCIL_TEST, cur->stencil_test);
gl4es_glStencilFunc(cur->stencil_func, cur->stencil_ref, cur->stencil_mask);
//TODO: Stencil value mask
gl4es_glStencilOp(cur->stencil_sfail, cur->stencil_dpfail, cur->stencil_dppass);
gl4es_glClearStencil(cur->stencil_clearvalue);
//TODO: Stencil buffer writemask
}
if (cur->mask & GL_TEXTURE_BIT) {
int a;
//TODO: Enable bit for the 4 texture coordinates
for (a=0; a<hardext.maxtex; a++) {
glstate->enable.texgen_r[a] = cur->texgen_r[a];
glstate->enable.texgen_s[a] = cur->texgen_s[a];
glstate->enable.texgen_t[a] = cur->texgen_t[a];
glstate->enable.texgen_q[a] = cur->texgen_q[a];
glstate->texgen[a] = cur->texgen[a]; // all mode and planes per texture in 1 line
for (int j=0; j<ENABLED_TEXTURE_LAST; j++)
if ((cur->texture[a][j]==0 && glstate->texture.bound[a][j] != 0) || (cur->texture[a][j]!=0 && glstate->texture.bound[a][j]==0)) {
gl4es_glActiveTexture(GL_TEXTURE0+a);
gl4es_glBindTexture(to_target(j), cur->texture[a][j]);
}
}
if (glstate->texture.active!= cur->active) gl4es_glActiveTexture(GL_TEXTURE0+cur->active);
}
if (cur->mask & GL_PIXEL_MODE_BIT) {
GLenum pixel_name[] = {GL_RED_BIAS, GL_RED_SCALE, GL_GREEN_BIAS, GL_GREEN_SCALE, GL_BLUE_BIAS, GL_BLUE_SCALE, GL_ALPHA_BIAS, GL_ALPHA_SCALE};
int i;
for (i=0; i<8; i++)
gl4es_glPixelTransferf(pixel_name[i], cur->pixel_scale_bias[i]);
//TODO: GL_DEPTH_BIAS & GL_DEPTH_SCALE (probably difficult)
//TODO: GL_INDEX_OFFEST & GL_INDEX_SHIFT
//TODO: GL_MAP_COLOR & GL_MAP_STENCIL (probably difficult too)
gl4es_glPixelZoom(cur->pixel_zoomx, cur->pixel_zoomy);
}
if (cur->mask & GL_TRANSFORM_BIT) {
if (!(cur->mask & GL_ENABLE_BIT)) {
int i;
GLint max_clip_planes;
gl4es_glGetIntegerv(GL_MAX_CLIP_PLANES, &max_clip_planes);
for (i = 0; i < max_clip_planes; i++) {
enable_disable(GL_CLIP_PLANE0 + i, *(cur->clip_planes_enabled + i));
}
}
gl4es_glMatrixMode(cur->matrix_mode);
enable_disable(GL_NORMALIZE, cur->normalize_flag);
enable_disable(GL_RESCALE_NORMAL, cur->rescale_normal_flag);
}
if (cur->mask & GL_VIEWPORT_BIT) {
gl4es_glViewport(cur->viewport_size[0], cur->viewport_size[1], cur->viewport_size[2], cur->viewport_size[3]);
gl4es_glDepthRangef(cur->depth_range[0], cur->depth_range[1]);
}
maybe_free(cur->clip_planes_enabled);
maybe_free(cur->clip_planes);
maybe_free(cur->lights_enabled);
maybe_free(cur->lights);
maybe_free(cur->materials);
glstate->stack->len--;
}
