#include "private.h"
#include "drawing.h"
HeliGLBlendFuncSeparatePtr heliGLBlendFuncSeparatePtr;
HeliGLStencilOpSeparatePtr heliGLStencilOpSeparatePtr;
HeliGLTexImage2DMultisamplePtr heliGLTexImage2DMultisamplePtr;
HeliGLGenFramebuffersPtr heliGLGenFramebuffersPtr;
HeliGLDeleteFramebuffersPtr heliGLDeleteFramebuffersPtr;
HeliGLBindFramebufferPtr heliGLBindFramebufferPtr;
HeliGLBlitFramebufferPtr heliGLBlitFramebufferPtr;
HeliGLFramebufferRenderbufferPtr heliGLFramebufferRenderbufferPtr;
HeliGLFramebufferTexture2DPtr heliGLFramebufferTexture2DPtr;
HeliGLCheckFramebufferStatusPtr heliGLCheckFramebufferStatusPtr;
HeliGLGenRenderbuffersPtr heliGLGenRenderbuffersPtr;
HeliGLDeleteRenderbuffersPtr heliGLDeleteRenderbuffersPtr;
HeliGLBindRenderbufferPtr heliGLBindRenderbufferPtr;
HeliGLRenderbufferStoragePtr heliGLRenderbufferStoragePtr;
HeliGLRenderbufferStorageMultisamplePtr heliGLRenderbufferStorageMultisamplePtr;
unsigned int heliGLWindowFramebufferReadId = 0;
unsigned int heliGLWindowFramebufferDrawId = 0;
double heliGLGetAAResolution() {
if (!heliGLIsIntegerClipping()) return 0;
double proj[16] = {};
double model[16] = {};
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
double full[16] = {};
double fullinv[16] = {};
heliMatrix4Mult(full, proj, model);
full[8] = 0, full[9] = 0, full[10] = 1, full[11] = 0; // assume z is zero
if (!heliMatrix4Invert(fullinv, full)) return 0;
if (fabs(fullinv[15]) < HELI_PRECISION_SQR) return 0; // bad perspective
double k = 1/fullinv[15];
if ( fabs(fullinv[3]*k) > 1e-5
|| fabs(fullinv[7]*k) > 1e-5 ) return 0; // perspective distortion
int rect[4] = {}; // x, y, w, h
glGetIntegerv(GL_VIEWPORT, rect);
double w = rect[2], h = rect[3];
double m00 = fullinv[0]*k*2/w, m01 = fullinv[1]*k*2/w,
m10 = fullinv[4]*k*2/h, m11 = fullinv[5]*k*2/h;
double l0 = sqrt(m00*m00 + m01*m01);
double l1 = sqrt(m10*m10 + m11*m11);
if (l0 > l1) { double l = l0; l0 = l1; l1 = l; }
if (l0 < HELI_PRECISION || l1 < HELI_PRECISION) return 0;
if (l0/l1 < 0.75) return 0; // to big aspect ratio
return sqrt(l0*l1);
}
double heliGLGetPixelSize() {
double proj[16] = {};
double model[16] = {};
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
double full[16] = {};
double fullinv[16] = {};
heliMatrix4Mult(full, proj, model);
full[8] = 0, full[9] = 0, full[10] = 1, full[11] = 0; // assume z is zero
if (!heliMatrix4Invert(fullinv, full)) return 0;
if (fabs(fullinv[15]) <= HELI_PRECISION_SQR) return 0; // bad perspective
double k = 1/fullinv[15];
if ( fabs(fullinv[3]*k) > 1e-5
|| fabs(fullinv[7]*k) > 1e-5 ) return 0; // perspective distortion
int rect[4] = {}; // x, y, w, h
glGetIntegerv(GL_VIEWPORT, rect);
double w = rect[2], h = rect[3];
double m00 = fullinv[0]*k*2/w, m01 = fullinv[1]*k*2/w,
m10 = fullinv[4]*k*2/h, m11 = fullinv[5]*k*2/h;
double l0 = sqrt(m00*m00 + m01*m01);
double l1 = sqrt(m10*m10 + m11*m11);
if (l0 > l1) { double l = l0; l0 = l1; l1 = l; }
if (l0 <= HELI_PRECISION && l1 <= HELI_PRECISION) return 0;
double l = sqrt(l0*l1);
return l <= HELI_PRECISION ? 0 : l;
}
static int isInteger(double x)
{ return fabs(floor(x + 0.5) - x) > 0.01; }
int heliGLIsIntegerClipping() {
double proj[16] = {};
double model[16] = {};
double viewproj[16] = {};
double viewmodel[16] = {};
int rect[4] = {}; // x, y, w, h
glGetIntegerv(GL_VIEWPORT, rect);
double hw = 0.5*rect[2], hh = 0.5*rect[3];
double view[16] = {
hw, 0, 0, 0,
0,-hh, 0, 0,
0, 0, 1, 0,
hw, hh, 0, 1 };
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
heliMatrix4Mult(viewproj, view, proj);
heliMatrix4Mult(viewmodel, viewproj, model);
int badMatrix = FALSE;
if (fabs(viewmodel[15]) < HELI_PRECISION_SQR) badMatrix = TRUE; // bad perspective
double k = badMatrix ? 0 : 1/viewmodel[15];
if ( fabs(viewmodel[3]*k) > 1e-5
|| fabs(viewmodel[7]*k) > 1e-5 ) badMatrix = TRUE; // perspective distortion
HeliGLCommonState s;
const int clipCount = (int)(sizeof(s.clipPlanes)/sizeof(*s.clipPlanes));
//glGetIntegerv(GL_MAX_CLIP_PLANES, &clipCount);
double eq[4] = {}, eqv[4] = {};
for(int i = 0; i < clipCount; ++i) {
if (!glIsEnabled(GL_CLIP_PLANE0 + i)) continue;
if (badMatrix) return FALSE;
glGetClipPlane(GL_CLIP_PLANE0 + i, eq);
heliMatrix4MultVec(eqv, viewproj, eq);
double a = (eqv[0] + eqv[2]*viewmodel[2])*k;
double b = (eqv[1] + eqv[2]*viewmodel[6])*k;
double c = eqv[2]*viewmodel[14]*k + 1;
if (fabs(a) > 1e-5 && fabs(b) > 1e-5) return FALSE;
if (fabs(a) > 1e-5 && !isInteger(c/a)) return FALSE;
if (fabs(b) > 1e-5 && !isInteger(b/a)) return FALSE;
}
return TRUE;
}
int heliGLBackTransform(double *x, double *y) {
double proj[16] = {};
double model[16] = {};
double viewproj[16] = {};
double viewmodel[16] = {};
double inv[16] = {};
double v[2][4] = {
{ *x, *y, 0, 1 },
{ *x, *y, 1, 1 } };
double vv[2][4] = {};
*x = 0; *y = 0;
int rect[4] = {}; // x, y, w, h
glGetIntegerv(GL_VIEWPORT, rect);
double hw = 0.5*rect[2], hh = 0.5*rect[3];
double view[16] = {
hw, 0, 0, 0,
0,-hh, 0, 0,
0, 0, 1, 0,
hw, hh, 0, 1 };
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetDoublev(GL_MODELVIEW_MATRIX, model);
heliMatrix4Mult(viewproj, view, proj);
heliMatrix4Mult(viewmodel, viewproj, model);
if (!heliMatrix4Invert(inv, viewmodel)) return FALSE;
heliMatrix4MultVec(vv[0], inv, v[0]);
heliMatrix4MultVec(vv[1], inv, v[1]);
double l = vv[0][2] - vv[1][2];
if (fabs(l) <= HELI_PRECISION) return FALSE;
l = vv[0][2]/l;
double kw = vv[0][3] + (vv[1][3] - vv[0][3])*l;
if (fabs(kw) <= HELI_PRECISION) return FALSE;
kw = 1/kw;
*x = (vv[0][0] + (vv[1][0] - vv[0][0])*l)*kw;
*y = (vv[0][1] + (vv[1][1] - vv[0][1])*l)*kw;
return TRUE;
}
void heliGLGetCommonState(HeliGLCommonState *state, unsigned int flags) {
memset(state, 0, sizeof(*state));
state->flags = flags;
if (state->flags & STATE_TRANSFORM)
glGetDoublev(GL_MODELVIEW_MATRIX, state->modelviewMatrix);
if (state->flags & STATE_CLIP) {
const int clipCount = (int)(sizeof(state->clipPlanes)/sizeof(*state->clipPlanes));
for(int i = 0; i < clipCount; ++i) {
state->clipPlanes[i].enabled = glIsEnabled(GL_CLIP_PLANE0 + i) != 0;
glGetClipPlane(GL_CLIP_PLANE0 + i, state->clipPlanes[i].equation);
}
}
if (state->flags & STATE_TARGET_FRAMEBUFFER) {
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (int*)&state->framebuffer_read_id);
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (int*)&state->framebuffer_draw_id);
}
if (state->flags & STATE_TARGET_VIEWPORT)
glGetIntegerv(GL_VIEWPORT, state->viewport);
if (state->flags & STATE_TARGET_PROJECTION)
glGetDoublev(GL_PROJECTION_MATRIX, state->projectionMatrix);
if (state->flags & STATE_BACKGROUND)
glGetDoublev(GL_COLOR_CLEAR_VALUE, state->clearColor);
}
void heliGLSetCommonState(const HeliGLCommonState *state) {
int loadClip = state->flags & STATE_CLIP;
int loadTransform = state->flags & STATE_TRANSFORM;
if (loadClip) {
unsigned int mode;
glGetIntegerv(GL_MATRIX_MODE, (int*)&mode);
glMatrixMode(GL_MODELVIEW);
if (!loadTransform) glPushMatrix();
const int clipCount = (int)(sizeof(state->clipPlanes)/sizeof(*state->clipPlanes));
for(int i = 0; i < clipCount; ++i) {
if (state->clipPlanes[i].enabled) glEnable(GL_CLIP_PLANE0+i);
else glDisable(GL_CLIP_PLANE0+i);
glClipPlane(GL_CLIP_PLANE0+i, state->clipPlanes[i].equation);
}
if (!loadTransform) glPopMatrix(); else glLoadMatrixd(state->modelviewMatrix);
glMatrixMode(mode);
} else
if (loadTransform) {
unsigned int mode;
glGetIntegerv(GL_MATRIX_MODE, (int*)&mode);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixd(state->modelviewMatrix);
glMatrixMode(mode);
}
if (state->flags & STATE_TARGET_FRAMEBUFFER) {
if (heliGLBindFramebufferPtr) {
heliGLBindFramebufferPtr(GL_DRAW_FRAMEBUFFER, state->framebuffer_draw_id);
heliGLBindFramebufferPtr(GL_READ_FRAMEBUFFER, state->framebuffer_read_id);
}
}
if (state->flags & STATE_TARGET_VIEWPORT)
glViewport(state->viewport[0], state->viewport[1], state->viewport[2], state->viewport[3]);
if (state->flags & STATE_TARGET_PROJECTION) {
unsigned int mode;
glGetIntegerv(GL_MATRIX_MODE, (int*)&mode);
glMatrixMode(GL_PROJECTION);
glLoadMatrixd(state->projectionMatrix);
glMatrixMode(mode);
}
if (state->flags & STATE_BACKGROUND)
glClearColor(state->clearColor[0], state->clearColor[1], state->clearColor[2], state->clearColor[3]);
}