void rgluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz) { GLdouble m[16]; GLdouble x[3], y[3], z[3]; GLdouble mag; z[0] = eyex - centerx; z[1] = eyey - centery; z[2] = eyez - centerz; mag = fsqrt(z[0]*z[0] + z[1]*z[1] + z[2]*z[2]); if (mag) { z[0] /= mag; z[1] /= mag; z[2] /= mag; } y[0] = upx; y[1] = upy; y[2] = upz; x[0] = y[1]*z[2] - y[2]*z[1]; x[1] = -y[0]*z[2] + y[2]*z[0]; x[2] = y[0]*z[1] - y[1]*z[0]; y[0] = z[1]*x[2] - z[2]*x[1]; y[1] = -z[0]*x[2] + z[2]*x[0]; y[2] = z[0]*x[1] - z[1]*x[0]; mag = fsqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]); if (mag) { x[0] /= mag; x[1] /= mag; x[2] /= mag; } mag = fsqrt(y[0]*y[0] + y[1]*y[1] + y[2]*y[2]); if (mag) { y[0] /= mag; y[1] /= mag; y[2] /= mag; } #define M(row,col) m[(col<<2)+row] M(0,0) = x[0]; M(0,1) = x[1]; M(0,2) = x[2]; M(0,3) = 0.0; M(1,0) = y[0]; M(1,1) = y[1]; M(1,2) = y[2]; M(1,3) = 0.0; M(2,0) = z[0]; M(2,1) = z[1]; M(2,2) = z[2]; M(2,3) = 0.0; M(3,0) = 0.0; M(3,1) = 0.0; M(3,2) = 0.0; M(3,3) = 1.0; #undef M glMultMatrixd(m); glTranslated(-eyex, -eyey, -eyez); }
int main(int argc, char*argv[]){ uint32_t i; uint32_t result; uint32_t out; int k=0; int del = 0; int table[128]; i=0; while(i<128){ table[i]=0; i++; } k=0; i = (127 << 23) + (0 << 14); while(k < 16384*1024){ result=fsqrt_s(i); out = fsqrt(i,0); del = out - result; table[del+64] = table[del+64]+1; k++; i++; } printtable(table); return 0; }
void getRotatePoint(Ship *ship, vector *point, real32 *distance) { Node *slavenode; Ship *slave; udword count; vector dist; dbgAssertOrIgnore(ship->flags & SOF_Slaveable); //ship should be slaveable dbgAssertOrIgnore(ship->slaveinfo->slaves.num >= 5); //need enough for a pie plate! slavenode = ship->slaveinfo->slaves.head; point->x = ship->posinfo.position.x; point->y = ship->posinfo.position.y; point->z = ship->posinfo.position.z; count = 0; while (count < 5) { slave = (Ship *) listGetStructOfNode(slavenode); vecAdd(*point, *point, slave->posinfo.position); slavenode = slavenode->next; count++; } point->x /= 6.0f; point->y /= 6.0f; point->z /= 6.0f; vecSub(dist,ship->posinfo.position, *point); *distance = vecMagnitudeSquared(dist); *distance = fsqrt(*distance); }
void V_Normalize(float *a) { float s = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); float len = 1.0f / fsqrt(s); a[0] *= len; a[1] *= len; a[2] *= len; }
void print_fsqrt( uint32_t a ) { uint32_t b = fsqrt( a ); float af = getFloat(a); float bf = getFloat(b); printf("実装したfsqrt\n"); printf("小数表示 fsqrt( %f ) = %f\n", af, bf ); printf("10進数表示 fsqrt( %d ) = %d\n", a, b ); printf("16進数表示 fsqrt( %x ) = %x\n", a, b ); }
/*----------------------------------------------------------------------------- Name : vecNormalize Description : normalizes a vector (makes it a unit vector) Inputs : vector Outputs : vector is normalized Return : ----------------------------------------------------------------------------*/ void vecNormalize(vector *a) { real32 mag = fsqrt(vecMagnitudeSquared(*a)); real32 oneOverMag = 1.0f / mag; a->x *= oneOverMag; a->y *= oneOverMag; a->z *= oneOverMag; }
/*----------------------------------------------------------------------------- Name : vecCopyAndNormalize Description : copies a source vector to destination vector, and then normalizes the destination vector Inputs : src, dst Outputs : Return : ----------------------------------------------------------------------------*/ void vecCopyAndNormalize(vector *src,vector *dst) { real32 mag = fsqrt(vecMagnitudeSquared(*src)); real32 oneOverMag = 1.0f / mag; dst->x = src->x * oneOverMag; dst->y = src->y * oneOverMag; dst->z = src->z * oneOverMag; }
int plugin_tex_doit(int stype, Cast *cast, float *texvec, float *dxt, float *dyt, float *result) { float val = 0.0; float a = 1.0; float p[3]; float tv[3]; int i; int res = TEX_INT; tv[0]=(texvec[0]+1.0)/2.0; tv[1]=(texvec[1]+1.0)/2.0; tv[2]=(texvec[2]+1.0)/2.0; p[0] = cast->txtscale * tv[0]; p[1] = cast->txtscale * tv[1]; p[2] = cast->txtscale * tv[2]; for (i=0; i<cast->depth; i++) { val += a * hnoise(1.0, p[0], p[1], p[2]); p[0] *= 2.0; p[1] *= 2.0; p[2] *= 2.0; a *= 0.5; } /* always return this value */ result[0] = CLAMP (val+cast->offset, 0.0, 1.0) * pow (fabs(sqrt(tv[0]*tv[0]+tv[1]*tv[1]+tv[2]*tv[2])), cast->falloff); if(stype==1) { /* * this is r, g, b, a: */ result[1]= 0.5*result[0]; result[2]= 1.0-val; result[3]= fsqrt(fabs(result[0])); result[4]= 1.0; res |= TEX_RGB; } if(stype==2) { /* * This value is the displacement of the actual normal in * the Material calculation. */ result[5]+= val; result[6]+= 1.0-val; result[7]= 0.0; res |= TEX_NOR; } return res; }
void gensqrt_s(void) { #ifdef INTERPRET_SQRT_S gencallinterp((native_type)cached_interpreter_table.SQRT_S, 0); #else gencheck_cop1_unusable(); #ifdef __x86_64__ mov_xreg64_m64rel(RAX, (unsigned long long *)(®_cop1_simple[dst->f.cf.fs])); fld_preg64_dword(RAX); fsqrt(); mov_xreg64_m64rel(RAX, (unsigned long long *)(®_cop1_simple[dst->f.cf.fd])); fstp_preg64_dword(RAX); #else mov_eax_memoffs32((unsigned int *)(®_cop1_simple[dst->f.cf.fs])); fld_preg32_dword(EAX); fsqrt(); mov_eax_memoffs32((unsigned int *)(®_cop1_simple[dst->f.cf.fd])); fstp_preg32_dword(EAX); #endif #endif }
float Gipps::accel(const LaneObject* v, float pos, float speed, float){ float s = pos - v->getFrontPosition(); float dv = v->getSpeed() - speed; float v0Local = vns_MIN(v0*malphaV0,speedLimit); float TLocal = DT*malphaT; float vp = v->getSpeed() - dv; // safe speed float vSafe = -b * TLocal + fsqrt(b * b * TLocal * TLocal + vp * vp + 2 * b * vns_MAX(s - s0, 0.0)); float vNew = vns_MIN(vSafe, vns_MIN(v->getSpeed() + a * TLocal, v0Local)); return (vNew - v->getSpeed()) / TLocal; }
void loadhook(float x=0.0f,float y=0.0f) { FILE *file; if ((file=fopen(CONFIG,"rb"))==NULL) reloadhook(); else { VOLREN->get_tfunc()->load(file); load(file); reloadhook(); VOLREN->get_histo()->load(file); reloadhook(); VOLREN->get_tfunc()->get_escale(&GUI_re_scale,&GUI_ge_scale,&GUI_be_scale); VOLREN->get_tfunc()->get_ascale(&GUI_ra_scale,&GUI_ga_scale,&GUI_ba_scale); GUI_re_scale=fsqrt(GUI_re_scale); GUI_ge_scale=fsqrt(GUI_ge_scale); GUI_be_scale=fsqrt(GUI_be_scale); GUI_ra_scale=fsqrt(GUI_ra_scale); GUI_ga_scale=fsqrt(GUI_ga_scale); GUI_ba_scale=fsqrt(GUI_ba_scale); fclose(file); } }
void gensqrt_s() { #ifdef INTERPRET_SQRT_S gencallinterp((u32)SQRT_S, 0); #else gencheck_cop1_unusable(); mov_eax_memoffs32((u32 *)(®_cop1_simple[dst->f.cf.fs])); fld_preg32_dword(EAX); fsqrt(); mov_eax_memoffs32((u32 *)(®_cop1_simple[dst->f.cf.fd])); fstp_preg32_dword(EAX); #endif }
void gensqrt_s(void) { #ifdef INTERPRET_SQRT_S gencallinterp((unsigned int)cached_interpreter_table.SQRT_S, 0); #else gencheck_cop1_unusable(); mov_eax_memoffs32((unsigned int *)(®_cop1_simple[dst->f.cf.fs])); fld_preg32_dword(EAX); fsqrt(); mov_eax_memoffs32((unsigned int *)(®_cop1_simple[dst->f.cf.fd])); fstp_preg32_dword(EAX); #endif }
void gensqrt_d() { #ifdef INTERPRET_SQRT_D gencallinterp((unsigned long)SQRT_D, 0); #else gencheck_cop1_unusable(); mov_eax_memoffs32((unsigned long *)(®_cop1_double[dst->f.cf.fs])); fld_preg32_qword(EAX); fsqrt(); mov_eax_memoffs32((unsigned long *)(®_cop1_double[dst->f.cf.fd])); fstp_preg32_qword(EAX); #endif }
/*----------------------------------------------------------------------------- Name : vecCapMinVector Description : limits a vector's minimum magnitude from growing below a maximum magnitude Inputs : vectorToCap, minMagnitude Outputs : Return : ----------------------------------------------------------------------------*/ void vecCapMinVector(vector *vectorToCap,real32 minMagnitude) { real32 actualMag = fsqrt(vecMagnitudeSquared(*vectorToCap)); real32 ratio; if (actualMag < minMagnitude) { ratio = minMagnitude / actualMag; vectorToCap->x *= ratio; vectorToCap->y *= ratio; vectorToCap->z *= ratio; } }
void gensqrt_d(usf_state_t * state) { #ifdef INTERPRET_SQRT_D gencallinterp(state, (unsigned int)state->current_instruction_table.SQRT_D, 0); #else gencheck_cop1_unusable(state); mov_eax_memoffs32(state, (unsigned int *)(&state->reg_cop1_double[state->dst->f.cf.fs])); fld_preg32_qword(state, EAX); fsqrt(state); mov_eax_memoffs32(state, (unsigned int *)(&state->reg_cop1_double[state->dst->f.cf.fd])); fstp_preg32_qword(state, EAX); #endif }
inline f32 distToLine(f32 cx, f32 cy, f32 ax, f32 ay, f32 bx, f32 by) { f32 r_numerator = (cx-ax)*(bx-ax) + (cy-ay)*(by-ay); f32 r_denomenator = (bx-ax)*(bx-ax) + (by-ay)*(by-ay); f32 r = r_numerator / r_denomenator; f32 px = ax + r*(bx-ax); f32 py = ay + r*(by-ay); f32 s = ((ay-cy)*(bx-ax)-(ax-cx)*(by-ay) ) / r_denomenator; f32 distanceLine = fabs(s)*fsqrt(r_denomenator); return distanceLine; }
void gensqrt_s(void) { #if defined(COUNT_INSTR) inc_m32rel(&instr_count[123]); #endif #ifdef INTERPRET_SQRT_S gencallinterp((unsigned long long)cached_interpreter_table.SQRT_S, 0); #else gencheck_cop1_unusable(); mov_xreg64_m64rel(RAX, (unsigned long long *)(®_cop1_simple[dst->f.cf.fs])); fld_preg64_dword(RAX); fsqrt(); mov_xreg64_m64rel(RAX, (unsigned long long *)(®_cop1_simple[dst->f.cf.fd])); fstp_preg64_dword(RAX); #endif }
//fires the bursts for the ship bool doBurstFire(Ship *ship) { HeavyCorvetteSpec *spec = (HeavyCorvetteSpec *)ship->ShipSpecifics; GunInfo *gunInfo = ship->gunInfo; sdword numGuns = gunInfo->numGuns; //Gun *gun; sdword done; vector trajectory,heading; real32 range,one_over_range; SpaceObjRotImpTarg dummyTarg; vecSub(trajectory,spec->burstFireVector,ship->posinfo.position); range = vecMagnitudeSquared(trajectory); range = fsqrt(range); one_over_range = 1.0f/range; vecScalarMultiply(trajectory,trajectory,one_over_range); dummyTarg.objtype = OBJ_ShipType; dummyTarg.posinfo.position = spec->burstFireVector; dummyTarg.collInfo.collPosition = spec->burstFireVector; dummyTarg.currentLOD = ship->currentLOD; dummyTarg.collMyBlob = ship->collMyBlob; vecSet(dummyTarg.posinfo.velocity,0.0f,0.0f,0.0f); //track target even more precisely vecSub(heading,spec->burstFireVector,ship->posinfo.position); vecNormalize(&heading); aitrackHeadingWithFlags(ship,&heading,0.9999f,AITRACKHEADING_IGNOREUPVEC); //set special information that needs to be 'transmitted' //to the code in gunshoot. //fix later spec->bulletLifeTime = range*oneOverburstSpeed; bitSet(ship->specialFlags,SPECIAL_BurstFiring); done = gunShootGunsAtTarget(ship,&dummyTarg,0.0f,&trajectory); bitClear(ship->specialFlags,SPECIAL_BurstFiring); if(done == TRUE) { spec->cooldown = TRUE; spec->burstChargeState2 = burstCoolDownTime; } return done; }
int check_float( float a, float b ) { uint32_t a_int = getUint32_t( a ); uint32_t b_int = getUint32_t( b ); float normal_f = (float)sqrt( a ); uint32_t sqrt = getUint32_t( normal_f ); uint32_t f_sqrt = fsqrt( a_int ); if ( sqrt != f_sqrt ) { printf("数字 : %f\n", a); printf("通常 %x\n", sqrt ); printf("自作 %x\n", f_sqrt ); } uint32_t inv = getUint32_t( (float)(1.0 / a ) ); uint32_t f_inv = finv( a_int ); uint32_t div = getUint32_t( (float)(1.0 / b ) ); uint32_t f_div = finv( b_int ); return sqrt == f_sqrt && inv == f_inv && div == f_div; }
int main(void) { union data_32bit a; union data_32bit result; int select_flag; char select_buf[10]; printf("select import form :\n"); printf("float -> 0\n"); printf("32bit -> 1 (others)\n"); gets(select_buf); sscanf(select_buf, "%d\n", &select_flag); if (select_flag == 0) { printf("a.fl32 : "); scanf("%f", &a.fl32); } else { char a_str[35]; printf("詰めて入力しても可\n"); printf("- --exp--- -------fraction--------\n"); printf("a(32bit) :\n"); gets(a_str); a.uint32 = str_to_uint32(delete_space(a_str)); } printf("\n"); printf("-- a --\n"); print_data(a); printf("\n"); result.uint32 = fsqrt(a.uint32); printf("-- fsqrt(result) --\n"); print_data(result); printf("\n"); union data_32bit test; printf("-- correct answer --\n"); test.fl32 = sqrtf(a.fl32); print_data(test); return(0); }
void Matrix::rotate(float angle, const Vector & axis) { float vx = axis.x, vy = axis.y, vz = axis.z; float rcos = fcos(angle * DEG2RAD); float rsin = fsin(angle * DEG2RAD); float invrcos = (1.0f - rcos); float mag = fsqrt(vx*vx + vy*vy + vz*vz); float xx, yy, zz, xy, yz, zx; if (mag < 1.0e-6) { // Rotation vector is too small to be significant return; } // Normalize the rotation vector vx /= mag; vy /= mag; vz /= mag; xx = vx * vx; yy = vy * vy; zz = vz * vz; xy = (vx * vy * invrcos); yz = (vy * vz * invrcos); zx = (vz * vx * invrcos); // Generate the rotation matrix Matrix mr; mr.identity(); // Hehe mr.matrix[0][0] = xx + rcos * (1.0f - xx); mr.matrix[2][1] = yz - vx * rsin; mr.matrix[1][2] = yz + vx * rsin; mr.matrix[1][1] = yy + rcos * (1.0f - yy); mr.matrix[2][0] = zx + vy * rsin; mr.matrix[0][2] = zx - vy * rsin; mr.matrix[2][2] = zz + rcos * (1.0f - zz); mr.matrix[1][0] = xy - vz * rsin; mr.matrix[0][1] = xy + vz * rsin; // Multiply it onto us *this = *this * mr; }
void tutDrawLinePulse(sdword x0, sdword y0, sdword x1, sdword y1, ubyte pulsevalue, sdword segsize) { real32 x0f = (real32)x0; real32 y0f = (real32)y0; real32 x1f = (real32)x1; real32 y1f = (real32)y1; real32 diffx = (x1f - x0f); real32 diffy = (y1f - y0f); sdword segment; real32 segments; bool blendon; segments = fsqrt(diffx*diffx + diffy*diffy) / (real32)segsize; diffx /= segments; diffy /= segments; if (glCapFeatureExists(GL_LINE_SMOOTH)) { blendon = (bool)glIsEnabled(GL_BLEND); if (!blendon) glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH); } glBegin(GL_LINES); for(segment = 0; segment <= segments; segment++) { glColor3ub(pulsevalue, pulsevalue, pulsevalue); glVertex2f(primScreenToGLX((sdword)x0f), primScreenToGLY((sdword)y0f)); x0f += diffx; y0f += diffy; glVertex2f(primScreenToGLX((sdword)x0f), primScreenToGLY((sdword)y0f)); pulsevalue += 25; } glEnd(); if (glCapFeatureExists(GL_LINE_SMOOTH)) { glDisable(GL_LINE_SMOOTH); if (!blendon) glDisable(GL_BLEND); } }
void fakephong_highlight_texture (pvr_ptr_t highlight, unsigned int xsize, unsigned int ysize, float hardness) { uint8 *tmphilight; unsigned int x, y; float norm[3] = {0.0, 0.0, 1.0}; const float xscale = (float) (xsize - 1) / 2.0f; const float yscale = (float) (ysize - 1) / 2.0f; tmphilight = malloc (xsize * ysize); /* We need a way to map 2D texture coordinates to points on a unit hemisphere, such that interpolating linearly along the texture approximates travelling smoothly along a great circle around the hemisphere. Not sure how best to do this. Maybe a parabolic texture? Using x, y coords unaltered and choosing z on the surface of the sphere. Only the circular part of the texture is used. */ for (y = 0; y < ysize; y++) for (x = 0; x < xsize; x++) { float reflection[3]; float dot; reflection[0] = (x - xscale) / xscale; reflection[1] = (y - yscale) / yscale; reflection[2] = fsqrt (1.0 - reflection[0] * reflection[0] - reflection[1] * reflection[1]); dot = vec_dot (reflection, norm); tmphilight[y * ysize + x] = 255.0 * powf (dot, hardness); } assert (highlight != 0); pvr_txr_load_ex (tmphilight, highlight, xsize, ysize, PVR_TXRLOAD_8BPP); free (tmphilight); }
void printSqrt (uint32_t in) { union uint32_f a, c; char aa[33],cc[33]; a.i = in; if (fpclassify (a.f) != FP_NORMAL) return; c.i = fsqrt (a.i); if (fpclassify (c.f) != FP_NORMAL) return; for (int t = 0; t < 32;++t) { aa[31 - t] = a.i & (1 << t) ? '1' : '0'; cc[31 - t] = c.i & (1 << t) ? '1' : '0'; } aa[32] = '\0'; cc[32] = '\0'; // 非正規化数とかはやらない if (isnormal (a.f)) { if (!isnan (c.f)) printf ("%s\t%s\n",aa,cc); } }
void wkTradeInit(void) { sdword index; Node *objnode = universe.ShipList.head; Ship *ship; real32 mass; index = 0; while (objnode != NULL) { ship = (Ship *)listGetStructOfNode(objnode); dbgAssertOrIgnore(ship->objtype == OBJ_ShipType); wkTradeShips[index].ship = ship; mass = ship->staticinfo->staticheader.mass / WK_MASS_SCALE; wkTradeShips[index].x = 0.0f; wkTradeShips[index].y = 0.0f; wkTradeShips[index].vx = 0.0f; wkTradeShips[index].vy = 0.0f; wkTradeShips[index].ang = 0.0f; wkTradeShips[index].vang = 0.0f; wkTradeShips[index].vangacc = WK_ANGULAR_ACC / fsqrt(mass); wkTradeShips[index].vangmax = WK_ANGULAR_MAXVEL / fsqrt(fsqrt(mass)); wkTradeShips[index].acc = WK_LINEAR_ACC / fsqrt(mass); wkTradeShips[index].maxvel = WK_LINEAR_MAXVEL; wkTradeShips[index].revacc = WK_LINEAR_REVACC / fsqrt(mass); wkTradeShips[index].strafeacc = WK_STRAFE_ACC / fsqrt(mass); wkTradeShips[index].controlthrust = 0; wkTradeShips[index].controlrot = 0; wkTradeShips[index].controlstrafe = 0; wkTradeShips[index].controlfire = 0; index++; objnode = objnode->next; } wkTradeShips[index].ship = NULL; }
static void do_emu(struct info * info) { unsigned short code; temp_real tmp; char * address; if (I387.cwd & I387.swd & 0x3f) I387.swd |= 0x8000; else I387.swd &= 0x7fff; ORIG_EIP = EIP; /* 0x0007 means user code space */ if (CS != 0x000F) { printk("math_emulate: %04x:%08x\n\r",CS,EIP); panic("Math emulation needed in kernel"); } code = get_fs_word((unsigned short *) EIP); bswapw(code); code &= 0x7ff; I387.fip = EIP; *(unsigned short *) &I387.fcs = CS; *(1+(unsigned short *) &I387.fcs) = code; EIP += 2; switch (code) { case 0x1d0: /* fnop */ return; case 0x1d1: case 0x1d2: case 0x1d3: case 0x1d4: case 0x1d5: case 0x1d6: case 0x1d7: math_abort(info,SIGILL); case 0x1e0: ST(0).exponent ^= 0x8000; return; case 0x1e1: ST(0).exponent &= 0x7fff; return; case 0x1e2: case 0x1e3: math_abort(info,SIGILL); case 0x1e4: ftst(PST(0)); return; case 0x1e5: printk("fxam not implemented\n\r"); math_abort(info,SIGILL); case 0x1e6: case 0x1e7: math_abort(info,SIGILL); case 0x1e8: fpush(); ST(0) = CONST1; return; case 0x1e9: fpush(); ST(0) = CONSTL2T; return; case 0x1ea: fpush(); ST(0) = CONSTL2E; return; case 0x1eb: fpush(); ST(0) = CONSTPI; return; case 0x1ec: fpush(); ST(0) = CONSTLG2; return; case 0x1ed: fpush(); ST(0) = CONSTLN2; return; case 0x1ee: fpush(); ST(0) = CONSTZ; return; case 0x1ef: math_abort(info,SIGILL); case 0x1fa: fsqrt(PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x1f0: case 0x1f1: case 0x1f2: case 0x1f3: case 0x1f4: case 0x1f5: case 0x1f6: case 0x1f7: case 0x1f8: case 0x1f9: case 0x1fb: case 0x1fd: case 0x1fe: case 0x1ff: printk("%04x fxxx not implemented\n\r",code + 0xd800); math_abort(info,SIGILL); case 0x1fc: frndint(PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x2e9: fucom(PST(1),PST(0)); fpop(); fpop(); return; case 0x3d0: case 0x3d1: return; case 0x3e2: I387.swd &= 0x7f00; return; case 0x3e3: I387.cwd = 0x037f; I387.swd = 0x0000; I387.twd = 0x0000; return; case 0x3e4: return; case 0x6d9: fcom(PST(1),PST(0)); fpop(); fpop(); return; case 0x7e0: *(short *) &EAX = I387.swd; return; } switch (code >> 3) { case 0x18: fadd(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x19: fmul(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x1a: fcom(PST(code & 7),PST(0)); return; case 0x1b: fcom(PST(code & 7),PST(0)); fpop(); return; case 0x1c: real_to_real(&ST(code & 7),&tmp); tmp.exponent ^= 0x8000; fadd(PST(0),&tmp,&tmp); real_to_real(&tmp,&ST(0)); return; case 0x1d: ST(0).exponent ^= 0x8000; fadd(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x1e: fdiv(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x1f: fdiv(PST(code & 7),PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 0x38: fpush(); ST(0) = ST((code+1) & 7); return; case 0x39: fxchg(&ST(0),&ST(code & 7)); return; case 0x3b: ST(code & 7) = ST(0); fpop(); return; case 0x98: fadd(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0x99: fmul(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0x9a: fcom(PST(code & 7),PST(0)); return; case 0x9b: fcom(PST(code & 7),PST(0)); fpop(); return; case 0x9c: ST(code & 7).exponent ^= 0x8000; fadd(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0x9d: real_to_real(&ST(0),&tmp); tmp.exponent ^= 0x8000; fadd(PST(code & 7),&tmp,&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0x9e: fdiv(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0x9f: fdiv(PST(code & 7),PST(0),&tmp); real_to_real(&tmp,&ST(code & 7)); return; case 0xb8: printk("ffree not implemented\n\r"); math_abort(info,SIGILL); case 0xb9: fxchg(&ST(0),&ST(code & 7)); return; case 0xba: ST(code & 7) = ST(0); return; case 0xbb: ST(code & 7) = ST(0); fpop(); return; case 0xbc: fucom(PST(code & 7),PST(0)); return; case 0xbd: fucom(PST(code & 7),PST(0)); fpop(); return; case 0xd8: fadd(PST(code & 7),PST(0),&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xd9: fmul(PST(code & 7),PST(0),&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xda: fcom(PST(code & 7),PST(0)); fpop(); return; case 0xdc: ST(code & 7).exponent ^= 0x8000; fadd(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xdd: real_to_real(&ST(0),&tmp); tmp.exponent ^= 0x8000; fadd(PST(code & 7),&tmp,&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xde: fdiv(PST(0),PST(code & 7),&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xdf: fdiv(PST(code & 7),PST(0),&tmp); real_to_real(&tmp,&ST(code & 7)); fpop(); return; case 0xf8: printk("ffree not implemented\n\r"); math_abort(info,SIGILL); fpop(); return; case 0xf9: fxchg(&ST(0),&ST(code & 7)); return; case 0xfa: case 0xfb: ST(code & 7) = ST(0); fpop(); return; } switch ((code>>3) & 0xe7) { case 0x22: put_short_real(PST(0),info,code); return; case 0x23: put_short_real(PST(0),info,code); fpop(); return; case 0x24: address = ea(info,code); for (code = 0 ; code < 7 ; code++) { ((long *) & I387)[code] = get_fs_long((unsigned long *) address); address += 4; } return; case 0x25: address = ea(info,code); *(unsigned short *) &I387.cwd = get_fs_word((unsigned short *) address); return; case 0x26: address = ea(info,code); verify_area(address,28); for (code = 0 ; code < 7 ; code++) { put_fs_long( ((long *) & I387)[code], (unsigned long *) address); address += 4; } return; case 0x27: address = ea(info,code); verify_area(address,2); put_fs_word(I387.cwd,(short *) address); return; case 0x62: put_long_int(PST(0),info,code); return; case 0x63: put_long_int(PST(0),info,code); fpop(); return; case 0x65: fpush(); get_temp_real(&tmp,info,code); real_to_real(&tmp,&ST(0)); return; case 0x67: put_temp_real(PST(0),info,code); fpop(); return; case 0xa2: put_long_real(PST(0),info,code); return; case 0xa3: put_long_real(PST(0),info,code); fpop(); return; case 0xa4: address = ea(info,code); for (code = 0 ; code < 27 ; code++) { ((long *) & I387)[code] = get_fs_long((unsigned long *) address); address += 4; } return; case 0xa6: address = ea(info,code); verify_area(address,108); for (code = 0 ; code < 27 ; code++) { put_fs_long( ((long *) & I387)[code], (unsigned long *) address); address += 4; } I387.cwd = 0x037f; I387.swd = 0x0000; I387.twd = 0x0000; return; case 0xa7: address = ea(info,code); verify_area(address,2); put_fs_word(I387.swd,(short *) address); return; case 0xe2: put_short_int(PST(0),info,code); return; case 0xe3: put_short_int(PST(0),info,code); fpop(); return; case 0xe4: fpush(); get_BCD(&tmp,info,code); real_to_real(&tmp,&ST(0)); return; case 0xe5: fpush(); get_longlong_int(&tmp,info,code); real_to_real(&tmp,&ST(0)); return; case 0xe6: put_BCD(PST(0),info,code); fpop(); return; case 0xe7: put_longlong_int(PST(0),info,code); fpop(); return; } switch (code >> 9) { case 0: get_short_real(&tmp,info,code); break; case 1: get_long_int(&tmp,info,code); break; case 2: get_long_real(&tmp,info,code); break; case 4: get_short_int(&tmp,info,code); } switch ((code>>3) & 0x27) { case 0: fadd(&tmp,PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 1: fmul(&tmp,PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 2: fcom(&tmp,PST(0)); return; case 3: fcom(&tmp,PST(0)); fpop(); return; case 4: tmp.exponent ^= 0x8000; fadd(&tmp,PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 5: ST(0).exponent ^= 0x8000; fadd(&tmp,PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; case 6: fdiv(PST(0),&tmp,&tmp); real_to_real(&tmp,&ST(0)); return; case 7: fdiv(&tmp,PST(0),&tmp); real_to_real(&tmp,&ST(0)); return; } if ((code & 0x138) == 0x100) { fpush(); real_to_real(&tmp,&ST(0)); return; } printk("Unknown math-insns: %04x:%08x %04x\n\r",CS,EIP,code); math_abort(info,SIGFPE); }
void test_mode_7 () { MODE_7_PARAMS params; BITMAP *tile, *sprite, *buffer; PALETTE pal; int quit = FALSE; fixed angle = itofix (0); fixed x = 0, y = 0; fixed dx = 0, dy = 0; fixed speed = 0; int i, j, r2; params.space_z = itofix (50); params.scale_x = ftofix (200.0); params.scale_y = ftofix (200.0); params.obj_scale_x = ftofix (50.0); params.obj_scale_y = ftofix (50.0); params.horizon = 20; // to avoid flicker the program makes use of a double-buffering system buffer = create_bitmap (screen->w, screen->h); // create a 64x64 tile bitmap and draw something on it. tile = create_bitmap (64, 64); for (i = 0; i < 32; i++) { for (j = i; j < 32; j++) { putpixel (tile, i, j, i); putpixel (tile, i, 63-j, i); putpixel (tile, 63-i, j, i); putpixel (tile, 63-i, 63-j, i); putpixel (tile, j, i, i); putpixel (tile, j, 63-i, i); putpixel (tile, 63-j, i, i); putpixel (tile, 63-j, 63-i, i); } } text_mode (-1); // Create another bitmap and draw something to it. // This bitmap contains the object. sprite = create_bitmap (64, 64); clear (sprite); for (i = 0; i < 64; i++) { for (j = 0; j < 64; j++) { r2 = (32 - i) * (32 - i) + (32 - j) * (32 - j); if (r2 < 30 * 30) { r2 = (24 - i) * (24 - i) + (24 - j) * (24 - j); putpixel (sprite, i, j, 127 - fixtoi(fsqrt(itofix(r2)))); } } } // create a palette // colors for the tiles for (i = 0; i < 64; i++) { pal[i].r = i; pal[i].g = i; pal[i].b = 0; } // colors for the object for (i = 0; i < 32; i++) { pal[i+64].r = 0; pal[i+64].g = 0; pal[i+64].b = 2 * i; pal[i+96].r = 2 * i; pal[i+96].g = 2 * i; pal[i+96].b = 63; } set_palette (pal); while (!quit) { // act on keyboard input if (key[KEY_ESC]) quit = TRUE; if (key[KEY_UP] && speed < itofix (5)) speed += ftofix (0.1); if (key[KEY_DOWN] && speed > itofix (-5)) speed -= ftofix (0.1); if (key[KEY_LEFT]) angle = (angle - itofix (3)) & 0xFFFFFF; if (key[KEY_RIGHT]) angle = (angle + itofix (3)) & 0xFFFFFF; if (key[KEY_Z]) params.space_z += itofix(5); if (key[KEY_X]) params.space_z -= itofix(5); if (key[KEY_Q]) params.scale_x = fmul (params.scale_x, ftofix (1.5)); if (key[KEY_W]) params.scale_x = fdiv (params.scale_x, ftofix (1.5)); if (key[KEY_E]) params.scale_y = fmul (params.scale_y, ftofix (1.5)); if (key[KEY_R]) params.scale_y = fdiv (params.scale_y, ftofix (1.5)); if (key[KEY_H]) params.horizon++; if (key[KEY_J]) params.horizon--; dx = fmul (speed, fcos (angle)); dy = fmul (speed, fsin (angle)); x += dx; y += dy; mode_7 (buffer, tile, angle, x, y, params); draw_object (buffer, sprite, angle, x, y, params); vsync(); blit (buffer, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H); } destroy_bitmap (tile); destroy_bitmap (sprite); destroy_bitmap (buffer); }
address InterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) { // rbx,: methodOop // rcx: scratrch // rsi: sender sp if (!InlineIntrinsics) return NULL; // Generate a vanilla entry address entry_point = __ pc(); // These don't need a safepoint check because they aren't virtually // callable. We won't enter these intrinsics from compiled code. // If in the future we added an intrinsic which was virtually callable // we'd have to worry about how to safepoint so that this code is used. // mathematical functions inlined by compiler // (interpreter must provide identical implementation // in order to avoid monotonicity bugs when switching // from interpreter to compiler in the middle of some // computation) // // stack: [ ret adr ] <-- rsp // [ lo(arg) ] // [ hi(arg) ] // // Note: For JDK 1.2 StrictMath doesn't exist and Math.sin/cos/sqrt are // native methods. Interpreter::method_kind(...) does a check for // native methods first before checking for intrinsic methods and // thus will never select this entry point. Make sure it is not // called accidentally since the SharedRuntime entry points will // not work for JDK 1.2. // // We no longer need to check for JDK 1.2 since it's EOL'ed. // The following check existed in pre 1.6 implementation, // if (Universe::is_jdk12x_version()) { // __ should_not_reach_here(); // } // Universe::is_jdk12x_version() always returns false since // the JDK version is not yet determined when this method is called. // This method is called during interpreter_init() whereas // JDK version is only determined when universe2_init() is called. // Note: For JDK 1.3 StrictMath exists and Math.sin/cos/sqrt are // java methods. Interpreter::method_kind(...) will select // this entry point for the corresponding methods in JDK 1.3. // get argument __ fld_d(Address(rsp, 1*wordSize)); switch (kind) { case Interpreter::java_lang_math_sin : __ trigfunc('s'); break; case Interpreter::java_lang_math_cos : __ trigfunc('c'); break; case Interpreter::java_lang_math_tan : __ trigfunc('t'); break; case Interpreter::java_lang_math_sqrt: __ fsqrt(); break; case Interpreter::java_lang_math_abs: __ fabs(); break; case Interpreter::java_lang_math_log: __ flog(); // Store to stack to convert 80bit precision back to 64bits __ push_fTOS(); __ pop_fTOS(); break; case Interpreter::java_lang_math_log10: __ flog10(); // Store to stack to convert 80bit precision back to 64bits __ push_fTOS(); __ pop_fTOS(); break; default : ShouldNotReachHere(); } // return double result in xmm0 for interpreter and compilers. if (UseSSE >= 2) { __ subptr(rsp, 2*wordSize); __ fstp_d(Address(rsp, 0)); __ movdbl(xmm0, Address(rsp, 0)); __ addptr(rsp, 2*wordSize); } // done, result in FPU ST(0) or XMM0 __ pop(rdi); // get return address __ mov(rsp, rsi); // set sp to sender sp __ jmp(rdi); return entry_point; }
void cSkeleton<_DataType>::FlagNonUniformGradient() { int i, j, k, l, m, n, Idx, loc[8]; int NumNonunifromVoxels, IsNonuniform; float AveVec_f[3], DotProduct_f, Tempf; printf ("\n"); printf ("Flag NonUniform Gradient() ... \n"); fflush(stdout); for (k=1; k<Depth_mi-1; k++) { for (j=1; j<Height_mi-1; j++) { for (i=1; i<Width_mi-1; i++) { loc[0] = Index (i, j, k); if (VoxelFlags_muc[loc[0]]==FLAG_EMPTY || VoxelFlags_muc[loc[0]]==FLAG_NONUNIFORM) continue; if (Distance_mi[loc[0]]<=1) continue; for (m=0; m<3; m++) AveVec_f[m] = 0.0; Idx = 0; for (n=k; n<=k+1; n++) { for (m=j; m<=j+1; m++) { for (l=i; l<=i+1; l++) { loc[Idx] = Index (l, m, n); AveVec_f[0] += GVFDistance_mf[loc[Idx]*3 + 0]; AveVec_f[1] += GVFDistance_mf[loc[Idx]*3 + 1]; AveVec_f[2] += GVFDistance_mf[loc[Idx]*3 + 2]; Idx++; } } } for (l=0; l<3; l++) AveVec_f[l] /= 8.0; // When the vector length is zero, then mark the voxels as nonuniform voxels Tempf = fsqrt (AveVec_f[0]*AveVec_f[0] + AveVec_f[1]*AveVec_f[1] + AveVec_f[2]*AveVec_f[2]); if (Tempf<1e-6) { for (m=0; m<8; m++) VoxelFlags_muc[loc[m]] = FLAG_NONUNIFORM; continue; } IsNonuniform = false; for (m=0; m<8; m++) { DotProduct_f = 0; for (l=0; l<3; l++) { DotProduct_f += AveVec_f[l]*GVFDistance_mf[loc[m]*3 + l]; } if (DotProduct_f<=0) { IsNonuniform = true; break; } } if (IsNonuniform) { for (m=0; m<8; m++) VoxelFlags_muc[loc[m]] = FLAG_NONUNIFORM; } } } } NumNonunifromVoxels = 0; for (i=0; i<WHD_mi; i++) { if (VoxelFlags_muc[i]==FLAG_NONUNIFORM) NumNonunifromVoxels++; } printf ("Num. Nonuniform Voxels = %d\n", NumNonunifromVoxels); printf ("Num. Segmented Voxels = %d\n", NumSegmentedVoxels_mi); printf ("Num. Nonuniform / NumSegmented = %f %%\n", (float)NumNonunifromVoxels/NumSegmentedVoxels_mi*100.0); printf ("Num. Nonuniform / Total Num. Voxels = %f %%\n", (double)NumNonunifromVoxels/WHD_mi*100.0); fflush (stdout); }