forked from KolibriOS/kolibrios
242 lines
4.6 KiB
C
242 lines
4.6 KiB
C
#include "zgl.h"
|
|
|
|
void gl_print_matrix( const float *m)
|
|
{
|
|
int i;
|
|
|
|
for (i=0;i<4;i++) {
|
|
fprintf(stderr,"%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] );
|
|
}
|
|
}
|
|
|
|
static inline void gl_matrix_update(GLContext *c)
|
|
{
|
|
c->matrix_model_projection_updated=(c->matrix_mode<=1);
|
|
}
|
|
|
|
|
|
void glopMatrixMode(GLContext *c,GLParam *p)
|
|
{
|
|
int mode=p[1].i;
|
|
switch(mode) {
|
|
case GL_MODELVIEW:
|
|
c->matrix_mode=0;
|
|
break;
|
|
case GL_PROJECTION:
|
|
c->matrix_mode=1;
|
|
break;
|
|
case GL_TEXTURE:
|
|
c->matrix_mode=2;
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
}
|
|
|
|
void glopLoadMatrix(GLContext *c,GLParam *p)
|
|
{
|
|
M4 *m;
|
|
int i;
|
|
|
|
GLParam *q;
|
|
|
|
m=c->matrix_stack_ptr[c->matrix_mode];
|
|
q=p+1;
|
|
|
|
for(i=0;i<4;i++) {
|
|
m->m[0][i]=q[0].f;
|
|
m->m[1][i]=q[1].f;
|
|
m->m[2][i]=q[2].f;
|
|
m->m[3][i]=q[3].f;
|
|
q+=4;
|
|
}
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
void glopLoadIdentity(GLContext *c,GLParam *p)
|
|
{
|
|
|
|
gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]);
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
void glopMultMatrix(GLContext *c,GLParam *p)
|
|
{
|
|
M4 m;
|
|
int i;
|
|
|
|
GLParam *q;
|
|
q=p+1;
|
|
|
|
for(i=0;i<4;i++) {
|
|
m.m[0][i]=q[0].f;
|
|
m.m[1][i]=q[1].f;
|
|
m.m[2][i]=q[2].f;
|
|
m.m[3][i]=q[3].f;
|
|
q+=4;
|
|
}
|
|
|
|
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
|
|
void glopPushMatrix(GLContext *c,GLParam *p)
|
|
{
|
|
int n=c->matrix_mode;
|
|
M4 *m;
|
|
|
|
assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 )
|
|
< c->matrix_stack_depth_max[n] );
|
|
|
|
m=++c->matrix_stack_ptr[n];
|
|
|
|
gl_M4_Move(&m[0],&m[-1]);
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
void glopPopMatrix(GLContext *c,GLParam *p)
|
|
{
|
|
int n=c->matrix_mode;
|
|
|
|
assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] );
|
|
c->matrix_stack_ptr[n]--;
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
|
|
void glopRotate(GLContext *c,GLParam *p)
|
|
{
|
|
M4 m;
|
|
float u[3];
|
|
float angle;
|
|
int dir_code;
|
|
|
|
angle = p[1].f * M_PI / 180.0;
|
|
u[0]=p[2].f;
|
|
u[1]=p[3].f;
|
|
u[2]=p[4].f;
|
|
|
|
/* simple case detection */
|
|
dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0);
|
|
|
|
switch(dir_code) {
|
|
case 0:
|
|
gl_M4_Id(&m);
|
|
break;
|
|
case 4:
|
|
if (u[0] < 0) angle=-angle;
|
|
gl_M4_Rotate(&m,angle,0);
|
|
break;
|
|
case 2:
|
|
if (u[1] < 0) angle=-angle;
|
|
gl_M4_Rotate(&m,angle,1);
|
|
break;
|
|
case 1:
|
|
if (u[2] < 0) angle=-angle;
|
|
gl_M4_Rotate(&m,angle,2);
|
|
break;
|
|
default:
|
|
{
|
|
float cost, sint;
|
|
|
|
/* normalize vector */
|
|
float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2];
|
|
if (len == 0.0f) return;
|
|
len = 1.0f / sqrt(len);
|
|
u[0] *= len;
|
|
u[1] *= len;
|
|
u[2] *= len;
|
|
|
|
/* store cos and sin values */
|
|
cost=cos(angle);
|
|
sint=sin(angle);
|
|
|
|
/* fill in the values */
|
|
m.m[3][0]=m.m[3][1]=m.m[3][2]=
|
|
m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f;
|
|
m.m[3][3]=1.0f;
|
|
|
|
/* do the math */
|
|
m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]);
|
|
m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint;
|
|
m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint;
|
|
m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint;
|
|
m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]);
|
|
m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint;
|
|
m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint;
|
|
m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint;
|
|
m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]);
|
|
}
|
|
}
|
|
|
|
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
void glopScale(GLContext *c,GLParam *p)
|
|
{
|
|
float *m;
|
|
float x=p[1].f,y=p[2].f,z=p[3].f;
|
|
|
|
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
|
|
|
|
m[0] *= x; m[1] *= y; m[2] *= z;
|
|
m[4] *= x; m[5] *= y; m[6] *= z;
|
|
m[8] *= x; m[9] *= y; m[10] *= z;
|
|
m[12] *= x; m[13] *= y; m[14] *= z;
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
void glopTranslate(GLContext *c,GLParam *p)
|
|
{
|
|
float *m;
|
|
float x=p[1].f,y=p[2].f,z=p[3].f;
|
|
|
|
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0];
|
|
|
|
m[3] = m[0] * x + m[1] * y + m[2] * z + m[3];
|
|
m[7] = m[4] * x + m[5] * y + m[6] * z + m[7];
|
|
m[11] = m[8] * x + m[9] * y + m[10] * z + m[11];
|
|
m[15] = m[12] * x + m[13] * y + m[14] * z + m[15];
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|
|
|
|
void glopFrustum(GLContext *c,GLParam *p)
|
|
{
|
|
float *r;
|
|
M4 m;
|
|
float left=p[1].f;
|
|
float right=p[2].f;
|
|
float bottom=p[3].f;
|
|
float top=p[4].f;
|
|
float near=p[5].f;
|
|
float farp=p[6].f;
|
|
float x,y,A,B,C,D;
|
|
|
|
x = (2.0*near) / (right-left);
|
|
y = (2.0*near) / (top-bottom);
|
|
A = (right+left) / (right-left);
|
|
B = (top+bottom) / (top-bottom);
|
|
C = -(farp+near) / ( farp-near);
|
|
D = -(2.0*farp*near) / (farp-near);
|
|
|
|
r=&m.m[0][0];
|
|
r[0]= x; r[1]=0; r[2]=A; r[3]=0;
|
|
r[4]= 0; r[5]=y; r[6]=B; r[7]=0;
|
|
r[8]= 0; r[9]=0; r[10]=C; r[11]=D;
|
|
r[12]= 0; r[13]=0; r[14]=-1; r[15]=0;
|
|
|
|
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m);
|
|
|
|
gl_matrix_update(c);
|
|
}
|
|
|