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); }