void drawCenteredString(char* str, int32 scale, u16 y)
{
if(!str)return;
int l=strlen(str);
drawString(str, RGB15(31,31,31), scale, inttof32(128)-(l*scale)*4, inttof32(y));
}
//-------------------------------------------------------
void renderPyramid(int angle){
//-------------------------------------------------------
glPushMatrix();
glTranslatef(0, 0, -4);
glRotatef32i(degreesToAngle(angle), inttof32(1),inttof32(1),inttof32(1));
glBegin(GL_QUADS);
glColor3b(255,0,0); glVertex3f(-1.0f, -1.0f, 1.0f);
glColor3b(0,255,0); glVertex3f( 1.0f, -1.0f, 1.0f);
glColor3b(0,0,255); glVertex3f( 1.0f, -1.0f, -1.0f);
glColor3b(255,255,0); glVertex3f(-1.0f, -1.0f, -1.0f);
glEnd();
glBegin(GL_TRIANGLES);
glColor3b(255,0,0); glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3b(0,255,0); glVertex3f(-1.0f, -1.0f, 1.0f);
glColor3b(0,0,255); glVertex3f( 1.0f, -1.0f, 1.0f);
glColor3b(255,0,0); glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3b(0,255,0); glVertex3f(-1.0f, -1.0f, -1.0f);
glColor3b(0,0,255); glVertex3f( 1.0f, -1.0f, -1.0f);
glColor3b(255,0,0); glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3b(0,255,0); glVertex3f(-1.0f, -1.0f, 1.0f);
glColor3b(0,0,255); glVertex3f(-1.0f, -1.0f, -1.0f);
glColor3b(255,0,0); glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3b(0,255,0); glVertex3f( 1.0f, -1.0f, 1.0f);
glColor3b(0,0,255); glVertex3f( 1.0f, -1.0f, -1.0f);
glEnd();
glPopMatrix(1);
}
RubiksCube::RubiksCube()
{
Position.X=inttof32(-1);
Position.Y=inttof32(-1);
Position.Z=inttof32(-1);
Size=inttof32(2);
rotateSensitivity=2;
twistSensitivity=2;
controlStyle=0;
setDefaultColours();
Reset();
}
//---------------------------------------------------------------------------------
void glRotatef32i(int angle, int32 x, int32 y, int32 z) {
//---------------------------------------------------------------------------------
int32 axis[3];
int32 sine = SIN[angle & LUT_MASK];
int32 cosine = COS[angle & LUT_MASK];
int32 one_minus_cosine = inttof32(1) - cosine;
axis[0]=x;
axis[1]=y;
axis[2]=z;
normalizef32(axis); // should require passed in normalized?
MATRIX_MULT3x3 = cosine + mulf32(one_minus_cosine, mulf32(axis[0], axis[0]));
MATRIX_MULT3x3 = mulf32(one_minus_cosine, mulf32(axis[0], axis[1])) - mulf32(axis[2], sine);
MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[2]) + mulf32(axis[1], sine);
MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[1]) + mulf32(axis[2], sine);
MATRIX_MULT3x3 = cosine + mulf32(mulf32(one_minus_cosine, axis[1]), axis[1]);
MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[1]), axis[2]) - mulf32(axis[0], sine);
MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[0]), axis[2]) - mulf32(axis[1], sine);
MATRIX_MULT3x3 = mulf32(mulf32(one_minus_cosine, axis[1]), axis[2]) + mulf32(axis[0], sine);
MATRIX_MULT3x3 = cosine + mulf32(mulf32(one_minus_cosine, axis[2]), axis[2]);
}
void getClosestLights(vect3D tilepos, light_struct** ll1, light_struct** ll2, light_struct** ll3, int32* dd1, int32* dd2, int32* dd3)
{
if(!ll1 || !ll2 || !ll3 || !dd1 || !dd2 || !dd3)return;
light_struct *l1, *l2, *l3;
int32 d1, d2, d3;
d1=d2=d3=inttof32(300);
l1=l2=l3=NULL;
int i;
for(i=0;i<NUMLIGHTS;i++)
{
if(lights[i].used)
{
light_struct* l=&lights[i];
// NOGBA("%d %d %d", l->position.x, l->position.y, l->position.z);
int32 d=(tilepos.x-l->position.x)*(tilepos.x-l->position.x)+/*((tilepos.y-l->position.y)*(tilepos.y-l->position.y))/16+*/(tilepos.z-l->position.z)*(tilepos.z-l->position.z);
if(d<d1){d3=d2;d2=d1;d1=d;
l3=l2;l2=l1;l1=l;}
else if(d<d2){d3=d2;d2=d;
l3=l2;l2=l;}
else if(d<d3){d3=d;
l3=l;}
}
}
*ll1=l1;
*ll2=l2;
*ll3=l3;
*dd1=d1;
*dd2=d2;
*dd3=d3;
}
vect3D getClosestPointRectangle(vect3D p, vect3D s, vect3D o)
{
vect3D u1, u2;
int32 x,y,sx,sy;
// NOGBA("p: %d %d %d",p.x,p.y,p.z);
// NOGBA("o: %d %d %d",o.x,o.y,o.z);
if(s.x){sx=abs(s.x);u1=vect((s.x>0)?inttof32(1):(-inttof32(1)),0,0);}
else{sx=abs(s.y);u1=vect(0,(s.y>0)?inttof32(1):(-inttof32(1)),0);}
if(s.z){sy=abs(s.z);u2=vect(0,0,(s.z>0)?inttof32(1):(-inttof32(1)));}
else{sy=abs(s.y);u2=vect(0,(s.y>0)?inttof32(1):(-inttof32(1)),0);}
o=vectDifference(o,p);
x=dotProduct(o,u1);y=dotProduct(o,u2);
// NOGBA("x, y: %d %d",x,y);
// NOGBA("sx, sy: %d %d",sx,sy);
bool r=true;
r=r&&x<sx&&x>=0;
r=r&&y<sy&&y>=0;
if(r)return addVect(p,vect(mulf32(x,u1.x)+mulf32(y,u2.x), mulf32(x,u1.y)+mulf32(y,u2.y), mulf32(x,u1.z)+mulf32(y,u2.z)));
if(x<0)
{
x=0;
if(y<0)y=0;
else if(y>sy)y=sy;
}else if(x>sx)
{
x=sx;
if(y<0)y=0;
else if(y>sy)y=sy;
}else if(y<0)
{
y=0;
if(x<0)x=0;
else if(x>sx)y=sx;
}else if(y>sy)
{
y=sy;
if(x<0)x=0;
else if(x>sx)x=sx;
}
return addVect(p,vect(mulf32(x,u1.x)+mulf32(y,u2.x), mulf32(x,u1.y)+mulf32(y,u2.y), mulf32(x,u1.z)+mulf32(y,u2.z)));
}
//---------------------------------------------------------------------------------
// Draws a 3x3 side of the rubiks cube. as with DrawTile, assumes that all rotation
// has already been performed.
//---------------------------------------------------------------------------------
void RubiksCube::DrawLine(RubikLine line, int32 x, int32 y, int32 z, int32 size) {
//---------------------------------------------------------------------------------
int color; // generate an int to signify tile colour (see enum RC_Color)
glBegin(GL_QUADS); //start drawin squares
for(int i=0; i<3; i++)
{
color = line.tile[i].color; //get this tile's colour
DrawTile(color, x, y + mulf32(inttof32(i),size), z, size, false); // draw the tile at (i,j)
}
glEnd(); // stop drawin squares
}
//---------------------------------------------------------------------------------
// Draws a 3x3 side of the rubiks cube. as with DrawTile, assumes that all rotation
// has already been performed.
//---------------------------------------------------------------------------------
void RubiksCube::DrawSide(RubikSide side, int sideNum, int32 x, int32 y, int32 z, int32 size, bool picking) {
//---------------------------------------------------------------------------------
int color; // generate an int to signify tile colour (see enum RC_Color)
glBegin(GL_QUADS); //start drawin squares
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
{
color = side.tile[i][j].color; //get this tile's colour
if(picking) startCheck(); // if picking...
DrawTile( color,
x + mulf32(inttof32(i),divf32(size,inttof32(3))),
y + mulf32(inttof32(j),divf32(size,inttof32(3))),
z,
divf32(size,inttof32(3)),
picking); // draw the tile at (i,j)
if(picking) endCheck(sideNum, i, j); // if picking...
}
}
glEnd(); // stop drawin squares
}
void Starfield_Draw(Starfield *starfield)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrthof32(0, inttof32(4), 0, inttof32(3), 0, inttof32(40));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluLookAtf32(0, 0, inttof32(1),
0, 0, 0,
0, inttof32(1), 0);
glPolyFmt(POLY_ALPHA(0x1f) | POLY_CULL_NONE);
for (int i = 0; i < num_stars; i++) {
StarfieldStar *star = &starfield->stars[i];
Starfield_DrawStar(star);
}
glPopMatrix(1);
}
void laserProgression(room_struct* r, vect3D* origin, vect3D* destination, vect3D dir)
{
if(!r || !origin || !destination)return;
vect3D ip;
vect3D l=*origin;
vect3D v=vectDifference(addVect(l,vectMult(dir,32)),convertSize(vect(r->position.x,0,r->position.y)));
gridCell_struct* gc=getCurrentCell(r,l);
while(gc && !collideGridCell(gc, NULL, v, dir, inttof32(100), &ip, NULL))
{
l=addVect(l,vectMult(dir,CELLSIZE*TILESIZE*2));
gc=getCurrentCell(r,l);
}
if(gc)*destination=addVect(ip,convertSize(vect(r->position.x,0,r->position.y)));
}
void drawTurretStuff(turret_struct* t)
{
if(!t || !t->used || t->dead)return;
drawLaser(t->laserOrigin,t->laserDestination);
if(t->laserThroughPortal)drawLaser(t->laserOrigin2,t->laserDestination2);
//TEMP TEST BILLBOARD
vect3D u1=vect(t->OBB->transformationMatrix[0],t->OBB->transformationMatrix[3],t->OBB->transformationMatrix[6]);
vect3D u2=vect(t->OBB->transformationMatrix[1],t->OBB->transformationMatrix[4],t->OBB->transformationMatrix[7]);
vect3D u3=vect(t->OBB->transformationMatrix[2],t->OBB->transformationMatrix[5],t->OBB->transformationMatrix[8]);
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_BACK | POLY_ID(63));
GFX_COLOR=RGB15(31,31,31);
applyMTL(turretShotTexture);
if(t->drawShot[0])
{
glPushMatrix();
glTranslatef32(t->laserOrigin.x, t->laserOrigin.y, t->laserOrigin.z);
glTranslatef32(u3.x/128, u3.y/128, u3.z/128);
glTranslatef32(u1.x/32, u1.y/32, u1.z/32);
glScalef32(inttof32(1)/16,inttof32(1)/16,inttof32(1)/16);
glRotatef32i(t->shotAngle[0],u3.x,u3.y,u3.z);
glBegin(GL_QUADS);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
glVertex3v16(-u1.x/2-u2.x, -u1.y/2-u2.y, -u1.z/2-u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(0));
glVertex3v16(+u1.x/2-u2.x, +u1.y/2-u2.y, +u1.z/2-u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(64));
glVertex3v16(+u1.x/2+u2.x, +u1.y/2+u2.y, +u1.z/2+u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
glVertex3v16(-u1.x/2+u2.x, -u1.y/2+u2.y, -u1.z/2+u2.z);
glPopMatrix(1);
}
if(t->drawShot[1])
{
glPushMatrix();
glTranslatef32(t->laserOrigin.x, t->laserOrigin.y, t->laserOrigin.z);
glTranslatef32(u3.x/128, u3.y/128, u3.z/128);
glTranslatef32(-u1.x/32, -u1.y/32, -u1.z/32);
glScalef32(inttof32(1)/16,inttof32(1)/16,inttof32(1)/16);
glRotatef32i(t->shotAngle[1],u3.x,u3.y,u3.z);
glBegin(GL_QUADS);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
glVertex3v16(-u1.x/2-u2.x, -u1.y/2-u2.y, -u1.z/2-u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(0));
glVertex3v16(+u1.x/2-u2.x, +u1.y/2-u2.y, +u1.z/2-u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(32), inttot16(64));
glVertex3v16(+u1.x/2+u2.x, +u1.y/2+u2.y, +u1.z/2+u2.z);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
glVertex3v16(-u1.x/2+u2.x, -u1.y/2+u2.y, -u1.z/2+u2.z);
glPopMatrix(1);
}
}
void updateLineOfTouch(s16 x, s16 y)
{
vect3D o=vect(inttof32(x),inttof32(y),inttof32(0));
vect3D v=vect(0,0,-inttof32(1));
getUnprojectedZLine(&editorCamera, x, y, &o, &v);
transformRay(&o, &v);
lineOfTouchOrigin=o;
lineOfTouchVector=vectMultInt(normalize(v),-1);
planeOfTouch[0]=evalVectMatrix33(editorCamera.transformationMatrix,vect(inttof32(1),0,0));
planeOfTouch[1]=evalVectMatrix33(editorCamera.transformationMatrix,vect(0,inttof32(1),0));
// NOGBA("LOT %d %d %d",lineOfTouchOrigin.x,lineOfTouchOrigin.y,lineOfTouchOrigin.z);
}
//---------------------------------------------------------------------------------
// Draw a single tile of the rubik's cube. assumes all necessary rotation has
// been performed already.
//---------------------------------------------------------------------------------
void RubiksCube::DrawTile(int color, int32 x, int32 y, int32 z, int32 size, bool picking)
{
int16 blackbit = f32tov16(divf32(size, inttof32(20)));
int16 vx, vy, vz, vsize;
vx = f32tov16(x);
vy = f32tov16(y);
vz = f32tov16(z);
vsize = f32tov16(size);
if(!picking) SetRCColor(color); //if we're not picking, then we need the right colour
// Draw the coloured part of the tile (sans black bits):
glVertex3v16(vx + blackbit, vy + blackbit, vz);
glVertex3v16(vx + vsize - blackbit, vy + blackbit, vz);
glVertex3v16(vx + vsize - blackbit, vy + vsize - blackbit, vz);
glVertex3v16(vx + blackbit, vy + vsize - blackbit, vz);
if(!picking) //if we're not picking, better draw in the black bits too
{
glColor3f(0,0,0);
//top
glVertex3v16(vx, vy, vz + blackbit);
glVertex3v16(vx + vsize, vy, vz + blackbit);
glVertex3v16(vx + vsize - blackbit, vy + blackbit, vz);
glVertex3v16(vx + blackbit, vy + blackbit, vz);
//right
glVertex3v16(vx + vsize - blackbit, vy + blackbit, vz);
glVertex3v16(vx + vsize, vy, vz + blackbit);
glVertex3v16(vx + vsize, vy + vsize, vz + blackbit);
glVertex3v16(vx + vsize - blackbit, vy + vsize - blackbit, vz);
//bottom
glVertex3v16(vx + blackbit, vy + vsize - blackbit, vz);
glVertex3v16(vx + vsize - blackbit, vy + vsize - blackbit, vz);
glVertex3v16(vx + vsize, vy + vsize, vz + blackbit);
glVertex3v16(vx, vy + vsize, vz + blackbit);
//left
glVertex3v16(vx, vy, vz + blackbit);
glVertex3v16(vx + blackbit, vy + blackbit, vz);
glVertex3v16(vx + blackbit, vy + vsize - blackbit, vz);
glVertex3v16(vx, vy + vsize, vz + blackbit);
}
}
void initRoomEdition(void)
{
initLights();
initBlocks();
initEntities();
initInterface();
initEditorRoom(&editorRoom);
initContextButtons();
initSelection(NULL);
initCamera(&editorCamera);
// initProjectionMatrixOrtho(&editorCamera, inttof32(-128), inttof32(127),inttof32(-96), inttof32(95), inttof32(-1000), inttof32(1000));
initProjectionMatrix(&editorCamera, 70*90, inttof32(4)/3, inttof32(1)/10, inttof32(1000)); //TEMP?
editorCamera.position=vect(0,0,0);
editorTranslation=vect(0,0,inttof32(-1));
editorScale=inttof32(1);
lineOfTouchOrigin=vect(0,0,0);
lineOfTouchVector=vect(0,0,0);
currentScreen=false;
//initial camera setup
rotateMatrixY(editorCamera.transformationMatrix, 2048+384, true);
rotateMatrixX(editorCamera.transformationMatrix, 1024+128, false);
editorScale=inttof32(8*20);
//controls stuff
touchRead(¤tTouch);
oldTouch=currentTouch;
//cosmetics
glSetOutlineColor(0,RGB15(0,0,0));
glSetOutlineColor(1,RGB15(29,15,3));
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
glMaterialf(GL_DIFFUSE, RGB15(24,24,24));
glMaterialf(GL_SPECULAR, RGB15(0,0,0));
glMaterialf(GL_EMISSION, RGB15(0,0,0));
glSetToonTableRange(0, 2, RGB15(8,8,8));
glSetToonTableRange(3, 31, RGB15(24,24,24));
glLight(0, RGB15(31,31,31), cosLerp(4096)>>3, 0, sinLerp(4096)>>3);
}
void roomEditorControls(void)
{
//TEMP CONTROLS
// if(keysHeld() & KEY_R)editorScale+=inttof32(2);
// if(keysHeld() & KEY_L)editorScale-=inttof32(2);
if(keysHeld() & KEY_R)moveCameraImmediate(&editorCamera, vect(0,0,inttof32(1)/32));
if(keysHeld() & KEY_L)moveCameraImmediate(&editorCamera, vect(0,0,-inttof32(1)/32));
if(keysHeld() & KEY_UP)moveCameraImmediate(&editorCamera, vect(0,inttof32(1)/32,0));
else if(keysHeld() & KEY_DOWN)moveCameraImmediate(&editorCamera, vect(0,-inttof32(1)/32,0));
if(keysHeld() & KEY_RIGHT)moveCameraImmediate(&editorCamera, vect(inttof32(1)/32,0,0));
else if(keysHeld() & KEY_LEFT)moveCameraImmediate(&editorCamera, vect(-inttof32(1)/32,0,0));
if(keysHeld() & KEY_Y)rotateMatrixY(editorCamera.transformationMatrix, 256, true);
if(keysHeld() & KEY_A)rotateMatrixY(editorCamera.transformationMatrix, -256, true);
if(keysHeld() & KEY_B)rotateMatrixX(editorCamera.transformationMatrix, 256, false);
if(keysHeld() & KEY_X)rotateMatrixX(editorCamera.transformationMatrix, -256, false);
// if(keysHeld() & KEY_START){writeMapEditor(&editorRoom, "fat:/test.map");}
if(keysDown() & KEY_SELECT){switchScreens();}
// if((keysHeld() & KEY_R) && (keysHeld() & KEY_L))changeState(&editorState);
}
void RubiksCube::Draw(touchPosition touchXY)
{
int viewport[]={0,0,255,191}; // used later for gluPickMatrix()
int16 vx, vy, vz, vsize;
vx = f32tov16(Position.X);
vy = f32tov16(Position.Y);
vz = f32tov16(Position.Z);
vsize = f32tov16(Size);
glPushMatrix();
{
glRotateY(90);
glRotateZ(180);
if(Twisting||AutoTwisting)
{
int ax=0;
// Rotate so we draw the cube the right way round
while(ax<Twist.axis)
{
glRotateX(90);
glRotateZ(90);
ax++;
}
if(Twist.position==0 || Twist.position==3) glRotateZ(Twist.rotation);
DrawSide(Twist.left.side,Twist.axis,Position.X,Position.Y,Position.Z,Size,false);
glBegin(GL_QUADS);
glColor3f(0,0,0);
glVertex3v16(vx + vsize, vy, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx, vy, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx, vy + vsize, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx + vsize, vy + vsize, vz + f32tov16(divf32(Size,inttof32(3))));
glEnd();
if(Twist.position==0 || Twist.position==3) glRotateZ(-Twist.rotation);
glRotateY(180);
if(Twist.position==2 || Twist.position==3) glRotateZ(-Twist.rotation);
DrawSide(Twist.right.side,Twist.axis+3,Position.X,Position.Y,Position.Z,Size,false);
glBegin(GL_QUADS);
glColor3f(0,0,0);
glVertex3v16(vx + vsize, vy, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx, vy, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx, vy + vsize, vz + f32tov16(divf32(Size,inttof32(3))));
glVertex3v16(vx + vsize, vy + vsize, vz + f32tov16(divf32(Size,inttof32(3))));
glEnd();
if(Twist.position==2 || Twist.position==3) glRotateZ(Twist.rotation);
glRotateY(90);
glRotateX(-90);
if(Twist.position==1 || Twist.position==3) glRotateX(Twist.rotation);
glBegin(GL_QUADS);
glColor3f(0,0,0);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3))), vy, vz);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3))), vy + vsize, vz);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3))), vy + vsize, vz + vsize);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3))), vy, vz + vsize);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3)))*2, vy, vz);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3)))*2, vy, vz + vsize);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3)))*2, vy + vsize, vz + vsize);
glVertex3v16(vx + f32tov16(divf32(Size,inttof32(3)))*2, vy + vsize, vz);
glEnd();
if(Twist.position==1 || Twist.position==3) glRotateX(-Twist.rotation);
for(int i=0;i<4;i++)
{
if(Twist.position==0) glRotateX(Twist.rotation);
DrawLine(Twist.left.line[i],Position.X,Position.Y,Position.Z,Size/3);
if(Twist.position==0) glRotateX(-Twist.rotation);
if(Twist.position==1) glRotateX(Twist.rotation);
DrawLine(Twist.middle.line[i],Position.X+(Size/3),Position.Y,Position.Z,Size/3);
if(Twist.position==1) glRotateX(-Twist.rotation);
if(Twist.position==2) glRotateX(Twist.rotation);
DrawLine(Twist.right.line[i],Position.X+(Size/3*2),Position.Y,Position.Z,Size/3);
if(Twist.position==2) glRotateX(-Twist.rotation);
glRotateX(90);
}
}else{
for(int i=0;i<3;i++)
{
DrawSide(Side[i],i,Position.X,Position.Y,Position.Z,Size, false);
glRotateY(180);
DrawSide(Side[i+3],i+3,Position.X,Position.Y,Position.Z,Size, false);
glRotateX(90);
glRotateZ(-90);
}
}
}
glPopMatrix(1);
if(Picking)
{
glPushMatrix();
for(int i=0;i<3;i++)
clicked[i]=0;
closeW = 0x7FFFFFFF; //reset the distance
//set the viewport to just off-screen, this hides all rendering that will be done during picking
glViewport(0,192,0,192);
// setup the projection matrix for picking
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPickMatrix((touchXY.px),(191-touchXY.py),4,4,viewport); // render only what is below the cursor
gluPerspective(70, 256.0 / 192.0, 0.1, 20); // this must be the same as the original perspective matrix
glMatrixMode(GL_MODELVIEW); // switch back to modifying the modelview matrix for drawing
{
glRotateY(90);
glRotateZ(180);
for(int i=0;i<3;i++)
{
DrawSide(Side[i],i,Position.X,Position.Y,Position.Z,Size, true);
glRotateY(180);
DrawSide(Side[i+3],i+3,Position.X,Position.Y,Position.Z,Size, true);
glRotateX(90);
glRotateZ(-90);
}
}
glViewport(0,0,255,191);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 20);
glMatrixMode(GL_MODELVIEW);
if(closeW<0x7FFFFFFF)
{
if(Painting)
{
if(Side[clicked[0]].tile[clicked[1]][clicked[2]].color!=paintColour)
{
if(undoQueue.numEntries==0)
{
undoQueue.numEntries++;
undoQueue.currentEntry=0;
}
else if(undoQueue.currentEntry < (undoQueue.numEntries-1))
{
undoQueue.currentEntry++;
undoQueue.numEntries=undoQueue.currentEntry+1;
}
else if(undoQueue.numEntries==20)
{
for(int i=0; i<19; i++)
{
undoQueue.entry[i]=undoQueue.entry[i+1];
}
}
else
{
undoQueue.numEntries++;
undoQueue.currentEntry++;
}
undoQueue.entry[undoQueue.currentEntry].from=Side[clicked[0]].tile[clicked[1]][clicked[2]].color;
undoQueue.entry[undoQueue.currentEntry].to=paintColour;
for(int i=0; i<3; i++)
undoQueue.entry[undoQueue.currentEntry].position[i]=clicked[i];
Side[clicked[0]].tile[clicked[1]][clicked[2]].color=paintColour;
}
}else{
Grabbing=true;
Picking=false;
}
}
glPopMatrix(1);
}else{
//Twisting=false;
}
}
void RubiksCube::Grab(VECTOR touchVector)
{
tvf32[0]+=floattof32(touchVector.X);
tvf32[1]+=floattof32(touchVector.Y);
tvf32[2]=0;
if(f32toint(sqrtf32(mulf32(tvf32[0],tvf32[0])+mulf32(tvf32[1],tvf32[1])+mulf32(tvf32[2],tvf32[2])))>5)
{
VECTOR upv, rightv, rotduv, rotdrv;
int32 uvf32[3];//up vector as f32
int32 rvf32[3];//right vector
int32 magup, magright;
m4x4 grabMatrix;//container for the Position Matrix
vectorFromSide(upv, rightv, clicked[0]);
//printf ("Initial Vector:\n %f, ", tmpv.X);
//printf("%f, ", tmpv.Y);
//printf("%f\n", tmpv.Z);
glGetFixed(GL_GET_MATRIX_POSITION, (int32*)&grabMatrix);
glMatrixMode(GL_MODELVIEW);
//rotate the up vector thru the projection matrix
//and cast it to f32
RotateVector(grabMatrix, upv, rotduv);
uvf32[0]=floattof32(rotduv.X);
uvf32[1]=floattof32(rotduv.Y);
uvf32[2]=floattof32(rotduv.Z);
//rinse and repeat with the right vector
RotateVector(grabMatrix, rightv, rotdrv);
rvf32[0]=floattof32(rotdrv.X);
rvf32[1]=floattof32(rotdrv.Y);
rvf32[2]=floattof32(rotdrv.Z);
if(controlStyle)
{
int32 suvf32[3];
int32 srvf32[3];
suvf32[0]=0;
suvf32[1]=inttof32(1);
suvf32[2]=0;
srvf32[0]=inttof32(1);
srvf32[1]=0;
srvf32[2]=0;
magup=dotf32(uvf32, suvf32);
magright=dotf32(uvf32, srvf32);
if(abs(magup)>abs(magright))
{
for(int i=0; i<3; i++)
{
if(magup>0)
{
rvf32[i]=srvf32[i];
uvf32[i]=suvf32[i];
}
else
{
rvf32[i]=-srvf32[i];
uvf32[i]=-suvf32[i];
}
}
} else {
for(int i=0; i<3; i++)
{
if(magright>0)
{
uvf32[i]=srvf32[i];
rvf32[i]=-suvf32[i];
}
else
{
uvf32[i]=-srvf32[i];
rvf32[i]=suvf32[i];
}
}
}
}
magup=dotf32(uvf32, tvf32);
magright=dotf32(rvf32, tvf32);
if(magup || magright)
{
int32 tmp[2];
if(abs(magup)>abs(magright))
{
tmp[0]=uvf32[0];
tmp[1]=uvf32[1];
unitVector((int32*)tmp);
InitTwist(true, tmp);
}else{
tmp[0]=rvf32[0];
tmp[1]=rvf32[1];
unitVector((int32*)tmp);
InitTwist(false, tmp);
}
Twisting=true;
Grabbing=false;
tvf32[0]=0;
tvf32[1]=0;
}
}
}
static inline void render1(void)
{
scanKeys();
// cpuEndSlice();
playerControls(NULL);
updateControls();
// iprintf("controls : %d \n",cpuEndSlice());
updatePlayer(NULL);
// iprintf("player : %d \n",cpuEndSlice());
updatePortals();
updateTurrets();
updateBigButtons();
updateTimedButtons();
updateEnergyDevices();
updateEnergyBalls();
updatePlatforms();
updateCubeDispensers();
updateEmancipators();
updateEmancipationGrids();
updateDoors();
updateWallDoors();
// iprintf("updates : %d \n",cpuEndSlice());
// if(currentPortal)GFX_CLEAR_COLOR=currentPortal->color|(31<<16);
// else GFX_CLEAR_COLOR=0;
u16 color=getCurrentPortalColor(getPlayer()->object->position);
// NOGBA("col %d",color);
// GFX_CLEAR_COLOR=color|(31<<16);
GFX_CLEAR_COLOR=RGB15(0,0,0)|(31<<16);
#ifdef DEBUG_GAME
if(fifoCheckValue32(FIFO_USER_08))iprintf("\x1b[0J");
while(fifoCheckValue32(FIFO_USER_08)){int32 cnt=fifoGetValue32(FIFO_USER_08);iprintf("ALERT %d \n",cnt);NOGBA("ALERT %d \n",cnt);}
#else
while(fifoCheckValue32(FIFO_USER_08)){int32 cnt=fifoGetValue32(FIFO_USER_08);NOGBA("ALERT %d \n",cnt);}
#endif
projectCamera(NULL);
glPushMatrix();
glScalef32(SCALEFACT,SCALEFACT,SCALEFACT);
renderGun(NULL);
transformCamera(NULL);
cpuEndSlice();
// drawRoomsGame(128, color);
drawRoomsGame(0, color);
// drawCell(getCurrentCell(getPlayer()->currentRoom,getPlayerCamera()->position));
// iprintf("room : %d \n",cpuEndSlice());
updateParticles();
drawParticles();
// iprintf("particles : %d \n",cpuEndSlice());
drawOBBs();
// iprintf("OBBs : %d \n",cpuEndSlice());
drawBigButtons();
drawTimedButtons();
drawEnergyDevices();
drawEnergyBalls();
drawPlatforms();
drawCubeDispensers();
drawTurretsStuff();
drawEmancipators();
drawEmancipationGrids();
drawDoors();
drawWallDoors(NULL);
drawSludge(&gameRoom);
// iprintf("stuff : %d \n",cpuEndSlice());
drawPortal(&portal1);
drawPortal(&portal2);
glPopMatrix(1);
//HUD TEST
if(levelInfoCounter>0 && (levelTitle || levelAuthor))
{
levelInfoCounter--;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrthof32(inttof32(0), inttof32(255), inttof32(191), inttof32(0), -inttof32(1), inttof32(1));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
if(levelTitle)drawCenteredString(levelTitle, inttof32(17)/10, (82));
if(levelAuthor)drawCenteredString(levelAuthor, inttof32(1), (100));
glPopMatrix(1);
glMatrixMode(GL_PROJECTION);
glPopMatrix(1);
}
glFlush(0);
}
void initDoor(door_struct* d, room_struct* r, vect3D position, bool orientation)
{
if(!d || !r)return;
//for collisions
rectangle_struct rec;
rec.material=NULL;
if(!orientation){rec.position=addVect(position,vect(-1,0,0)); rec.size=vect(2,8,0); rec.normal=vect(0,0,inttof32(1));}
else {rec.position=addVect(position,vect(0,0,-1)); rec.size=vect(0,8,2); rec.normal=vect(inttof32(1),0,0);}
d->rectangle[0]=addRoomRectangle(r, rec, NULL, false);
if(d->rectangle[0])d->rectangle[0]->hide=true;
rec.position.y+=rec.size.y;
rec.size.y=-rec.size.y;
d->rectangle[1]=addRoomRectangle(r, rec, NULL, false);
if(d->rectangle[1])d->rectangle[1]->hide=true;
initModelInstance(&d->modelInstance, &doorModel);
d->position=convertVect(vect(position.x+r->position.x, position.y, position.z+r->position.y));
d->orientation=orientation;
d->active=false;
d->used=true;
}
void menuFrame(void)
{
if(!d3dScreen)initProjectionMatrix(&menuCamera, 70*90, inttof32(4)/3, inttof32(2), inttof32(1000));
else initProjectionMatrixBottom(&menuCamera, 70*90, inttof32(4)/3, inttof32(2), inttof32(1000));
projectCamera(&menuCamera);
glLoadIdentity();
glLight(0, RGB15(31,31,31), cosLerp(lightAngle)>>3, 0, sinLerp(lightAngle)>>3);
GFX_CLEAR_COLOR=RGB15(0,0,0)|(31<<16);
scanKeys();
touchRead(¤tTouch);
if((keysHeld() & KEY_R) && (keysHeld() & KEY_L))changeState(&menuState);
if(keysHeld() & KEY_R)tempState.position=addVect(tempState.position,vect(0,0,inttof32(1)/64));
if(keysHeld() & KEY_L)tempState.position=addVect(tempState.position,vect(0,0,-inttof32(1)/64));
if(keysHeld() & KEY_UP)tempState.position=addVect(tempState.position,vect(0,inttof32(1)/64,0));
if(keysHeld() & KEY_DOWN)tempState.position=addVect(tempState.position,vect(0,-inttof32(1)/64,0));
if(keysHeld() & KEY_RIGHT)tempState.position=addVect(tempState.position,vect(inttof32(1)/64,0,0));
if(keysHeld() & KEY_LEFT)tempState.position=addVect(tempState.position,vect(-inttof32(1)/64,0,0));
//TEMP (updateCamera stuff)
menuCamera.viewPosition=menuCamera.position;
// if(keysHeld() & KEY_A)lightAngle+=128;
// else if(keysHeld() & KEY_B)lightAngle-=128;
if(keysHeld() & KEY_A)tempState.angle.x+=64;
if(keysHeld() & KEY_B)tempState.angle.x-=64;
if(keysHeld() & KEY_X)tempState.angle.y+=64;
if(keysHeld() & KEY_Y)tempState.angle.y-=64;
if(keysHeld() & KEY_START)tempState.angle.z+=64;
if(keysHeld() & KEY_SELECT)tempState.angle.z-=64;
// if(keysUp() & KEY_TOUCH)
// {
// if(tempbool)testTransition=startCameraTransition(&cameraStates[1],&cameraStates[0],64);
// else testTransition=startCameraTransition(&cameraStates[0],&cameraStates[1],64);
// tempbool^=1;
// }
if(!(keysHeld() & KEY_TOUCH)) updateSimpleGui(-1, -1);
else updateSimpleGui(currentTouch.px, currentTouch.py);
// applyCameraState(&menuCamera,&tempState);
updateCameraTransition(&menuCamera,&testTransition);
drawMenuScene();
switch(d3dScreen)
{
case true:
drawSimpleGui();
updateMenuScene();
break;
default:
if(logoAlpha)drawLogo();
break;
}
glFlush(0);
swiWaitForVBlank();
updateD3D();
}
void drawLogo(void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrthof32(inttof32(0), inttof32(255), inttof32(191), inttof32(0), -inttof32(1), inttof32(1));
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
applyMTL(logoMain);
glScalef32(inttof32(256),inttof32(128),inttof32(1));
glBegin(GL_QUADS);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
glVertex3v16(inttof32(0), inttof32(0), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(256), inttot16(0));
glVertex3v16(inttof32(1), inttof32(0), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(256), inttot16(128));
glVertex3v16(inttof32(1), inttof32(1), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(128));
glVertex3v16(inttof32(0), inttof32(1), inttof32(0));
glPopMatrix(1);
glPushMatrix();
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE);
applyMTL(logoRotate);
glTranslate3f32(inttof32(90+32),inttof32(28+32),-inttof32(1)/16);
glRotateZi(logoAngle+=32);
glTranslate3f32(-inttof32(32),-inttof32(32),0);
glScalef32(inttof32(64),inttof32(64),inttof32(1));
glBegin(GL_QUADS);
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(0));
glVertex3v16(inttof32(0), inttof32(0), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(64), inttot16(0));
glVertex3v16(inttof32(1), inttof32(0), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(64), inttot16(64));
glVertex3v16(inttof32(1), inttof32(1), inttof32(0));
GFX_TEX_COORD = TEXTURE_PACK(inttot16(0), inttot16(64));
glVertex3v16(inttof32(0), inttof32(1), inttof32(0));
glPopMatrix(1);
}
