Vec3<float> Scene::calculate_shadowing_optimal_point(Vec3<float> near_values[4],Vec3<float> far_values[4], float &radius) { float max_top=near_values[0].y,max_bot=near_values[0].y,max_right=near_values[0].x,max_left=near_values[0].x; float depth=0; for(int i=0;i<4;i++) { float cur_max_right = maxf(near_values[i].x,far_values[i].x); float cur_max_left = minf(near_values[i].x,far_values[i].x); float cur_max_top = maxf(near_values[i].y,far_values[i].y); float cur_max_bot = minf(near_values[i].y,far_values[i].y); max_top=maxf(max_top,cur_max_top); max_bot=minf(max_bot,cur_max_bot); max_right=maxf(max_right,cur_max_right); max_left=minf(max_left,cur_max_left); depth+=(near_values[0].z+far_values[0].z); } float max_height=max_top-max_bot; float max_width=max_right-max_left; radius=maxf(max_height,max_width); return Vec3<float>((max_right+max_left)/2,(max_top+max_bot)/2,depth/8); }
// input : spread weighted energy *werg, spread energy *erg // output: masking threshold *erg after applying the tonality-offset static void ApplyTonalityOffset ( float* erg0, float* erg1, const float* werg0, const float* werg1 ) { int n; float Offset; float quot; // calculation of the masked threshold in the partition range for ( n = 0; n < PART_LONG; n++ ) { quot = *werg0++ / *erg0; if (quot <= 0.05737540597f) Offset = O_MAX; else if (quot < 0.5871011603f ) Offset = FAC1 * POW (quot, FAC2); else Offset = O_MIN; *erg0++ *= iw[n] * minf(MinVal[n], Offset); quot = *werg1++ / *erg1; if (quot <= 0.05737540597f) Offset = O_MAX; else if (quot < 0.5871011603f ) Offset = FAC1 * POW (quot, FAC2); else Offset = O_MIN; *erg1++ *= iw[n] * minf(MinVal[n], Offset); } return; }
static void morpho_erode(CompBuf *cbuf) { int x, y; float *p, *rectf = cbuf->rect; for (y = 0; y < cbuf->y; y++) { for (x = 0; x < cbuf->x - 1; x++) { p = rectf + cbuf->x * y + x; *p = minf(*p, *(p + 1)); } } for (y = 0; y < cbuf->y; y++) { for (x = cbuf->x - 1; x >= 1; x--) { p = rectf + cbuf->x * y + x; *p = minf(*p, *(p - 1)); } } for (x = 0; x < cbuf->x; x++) { for (y = 0; y < cbuf->y - 1; y++) { p = rectf + cbuf->x * y + x; *p = minf(*p, *(p + cbuf->x)); } } for (x = 0; x < cbuf->x; x++) { for (y = cbuf->y - 1; y >= 1; y--) { p = rectf + cbuf->x * y + x; *p = minf(*p, *(p - cbuf->x)); } } }
void sreScissors::UpdateWithProjectedPoint(float x, float y, double z) { if (z >= - 1.001d) { // Beyond the near plane. z = maxd(- 1.0d, z); double depth = 0.5d * z + 0.5d; near = mind(depth, near); far = maxd(depth, far); left = minf(x, left); right = maxf(x, right); bottom = minf(y, bottom); top = maxf(y, top); return; } sreMessage(SRE_MESSAGE_WARNING, "Unexpected vertex in front of the near plane in UpdateWorldSpaceBoundingHull " "z = %lf", z); // In front of the near plane. near = 0; far = 1.0; // We know that the light volume intersects the frustum, so it must extend to // both sides of the near plane. // Assume it fills the whole viewport (not optimal). left = - 1.0f; right = 1.0f; bottom = - 1.0f; top = 1.0f; }
std::pair<int, int> find_min_max(int a[], int length) { int min(0), max(0), i(0); if (length % 2) { min = a[0]; max = a[0]; i = 1; } else { min = minf(a[0], a[1]); max = maxf(a[0], a[1]); i = 2; } for (; i < length; i += 2) { int min2(0), max2(0); if (a[i] < a[i+1]) { min2 = a[i]; max2 = a[i+1]; } else { max2 = a[i]; min2 = a[i+1]; } min = minf(min, min2); max = maxf(max, max2); } return std::make_pair(min, max); }
/** * @brief * Calculate the Time Interval. * */ double getTimeInterval(structMesh *mesh, physics *phy, double CFL){ double dt; dt = mesh->dx/phy->u; dt = minf(dt, mesh->dy/phy->v); dt = minf(dt, pow(mesh->dx, 2)/phy->Dx); dt = minf(dt, pow(mesh->dy, 2)/phy->Dy); return dt*CFL; }
struct aabb* aabb_merge(struct aabb* rb, const struct aabb* b1, const struct aabb* b2) { struct vec4f minpt; struct vec4f maxpt; vec3_setf(&minpt, minf(b1->minpt.x, b2->minpt.x), minf(b1->minpt.y, b2->minpt.y), minf(b1->minpt.z, b2->minpt.z)); vec3_setf(&maxpt, maxf(b1->maxpt.x, b2->maxpt.x), maxf(b1->maxpt.y, b2->maxpt.y), maxf(b1->maxpt.z, b2->maxpt.z)); return aabb_setv(rb, &minpt, &maxpt); }
static ALvoid ALdistortionState_update(ALdistortionState *state, ALCdevice *Device, const ALeffectslot *Slot) { ALfloat frequency = (ALfloat)Device->Frequency; ALfloat bandwidth; ALfloat cutoff; ALfloat edge; /* Store distorted signal attenuation settings */ state->attenuation = Slot->EffectProps.Distortion.Gain; /* Store waveshaper edge settings */ edge = sinf(Slot->EffectProps.Distortion.Edge * (F_PI_2)); edge = minf(edge, 0.99f); state->edge_coeff = 2.0f * edge / (1.0f-edge); /* Lowpass filter */ cutoff = Slot->EffectProps.Distortion.LowpassCutoff; /* Bandwidth value is constant in octaves */ bandwidth = (cutoff / 2.0f) / (cutoff * 0.67f); ALfilterState_setParams(&state->lowpass, ALfilterType_LowPass, 1.0f, cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth) ); /* Bandpass filter */ cutoff = Slot->EffectProps.Distortion.EQCenter; /* Convert bandwidth in Hz to octaves */ bandwidth = Slot->EffectProps.Distortion.EQBandwidth / (cutoff * 0.67f); ALfilterState_setParams(&state->bandpass, ALfilterType_BandPass, 1.0f, cutoff / (frequency*4.0f), calc_rcpQ_from_bandwidth(cutoff / (frequency*4.0f), bandwidth) ); ComputeAmbientGains(Device, Slot->Gain, state->Gain); }
/* Calculates the normalized HRTF transition factor (delta) from the changes * in gain and listener to source angle between updates. The result is a * normalized delta factor that can be used to calculate moving HRIR stepping * values. */ ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3]) { ALfloat gainChange, angleChange, change; // Calculate the normalized dB gain change. newGain = maxf(newGain, 0.0001f); oldGain = maxf(oldGain, 0.0001f); gainChange = fabsf(log10f(newGain / oldGain) / log10f(0.0001f)); // Calculate the normalized listener to source angle change when there is // enough gain to notice it. angleChange = 0.0f; if(gainChange > 0.0001f || newGain > 0.0001f) { // No angle change when the directions are equal or degenerate (when // both have zero length). if(newdir[0]-olddir[0] || newdir[1]-olddir[1] || newdir[2]-olddir[2]) angleChange = acosf(olddir[0]*newdir[0] + olddir[1]*newdir[1] + olddir[2]*newdir[2]) / F_PI; } // Use the largest of the two changes for the delta factor, and apply a // significance shaping function to it. change = maxf(angleChange * 25.0f, gainChange) * 2.0f; return minf(change, 1.0f); }
// NoiseShaper for a subband void QuantizeSubbandWithNoiseShaping ( unsigned int* qu_output, const float* input, const int res, float* errors, const float* FIR ) { float signal; float mult = A [res]; float invmult = C [res]; int offset = D [res]; int n, quant; memset(errors, 0, 6 * sizeof *errors); // arghh, it produces pops on each frame boundary! for ( n = 0; n < 36; n++) { signal = input[n] * NoiseInjectionCompensation1D [res] - (FIR[5]*errors[n+0] + FIR[4]*errors[n+1] + FIR[3]*errors[n+2] + FIR[2]*errors[n+3] + FIR[1]*errors[n+4] + FIR[0]*errors[n+5]); quant = mpc_lrintf(signal * mult); // calculate the current error and save it for error refeeding errors [n + 6] = invmult * quant - signal * NoiseInjectionCompensation1D [res]; // limitation to +/-D quant = minf ( quant, +offset ); quant = maxf ( quant, -offset ); qu_output[n] = (unsigned int)(quant + offset); } }
int image_hsi_of_block(void *image_, int x, int y, float *hue, float *saturation, float *intensity) { struct image *image = image_; int i, j, n, w, h; unsigned char *rgb; w = BLOCK_WIDTH; h = BLOCK_HEIGHT; if(x+w > image_width(image_)) w -= image_width(image_)-x; if(y+h > image_height(image_)) h -= image_height(image_)-y; rgb = image->rgb + x + (y * bytes_per_scanline(image)); for(i = 0, n = 0; i < h; i++, rgb += 3*(image_width(image_)-w)) { for(j = 0; j < w; j++, n++, rgb += 3, hue++, saturation++, intensity++) { float r, g, b, sum; sum = rgb[0] + rgb[1] + rgb[2] + EPSILON_F; r = (float)rgb[0] / sum; g = (float)rgb[1] / sum; b = (float)rgb[2] / sum; *hue = acosf((0.5 * ((r-g) + (r-b))) / (EPSILON_F + sqrtf(((r-g)*(r-g)) + ((r-b) * (g-b))))); if(b > g) *hue = (2.0*M_PI_F) - *hue; *saturation = 1.0 - 3.0 * minf(r, g, b); *intensity = (float)(rgb[0]+rgb[1]+rgb[2]) / 765.0; } } return n; }
int main(int argc, char** argv) { TestBox t; MidiInfo minf("midifiles/Cisei.kar"); //open file (open initialize also ticklength of file, resolution.....) if(minf.isValid()) minf.readInfo(&t); //if you have a valid midi, read all info filling t else return ERR_NOTMIDI; minf.readInfo(); //now try to call readInfo without parameters. What happens? Nothing special but.. Tick* inf = minf.getInfo();//you can use defaul struct Tick Info *n = inf[22320].info; unsigned char* buf; while((n != NULL) && (buf = n->nextInfo())) printf("\nInfo :%s", buf); printf("\n\nNumber of ticks: %d Resolution: %dtpb Length: %dsec.\n", minf.getTickLength(), minf.getResolution(), minf.getSecondLenght()); return 0; }
/* Calculates the fade time from the changes in gain and listener to source * angle between updates. The result is a the time, in seconds, for the * transition to complete. */ static ALfloat CalcFadeTime(ALfloat oldGain, ALfloat newGain, const aluVector *olddir, const aluVector *newdir) { ALfloat gainChange, angleChange, change; /* Calculate the normalized dB gain change. */ newGain = maxf(newGain, 0.0001f); oldGain = maxf(oldGain, 0.0001f); gainChange = fabsf(log10f(newGain / oldGain) / log10f(0.0001f)); /* Calculate the angle change only when there is enough gain to notice it. */ angleChange = 0.0f; if(gainChange > 0.0001f || newGain > 0.0001f) { /* No angle change when the directions are equal or degenerate (when * both have zero length). */ if(newdir->v[0] != olddir->v[0] || newdir->v[1] != olddir->v[1] || newdir->v[2] != olddir->v[2]) { ALfloat dotp = aluDotproduct(olddir, newdir); angleChange = acosf(clampf(dotp, -1.0f, 1.0f)) / F_PI; } } /* Use the largest of the two changes, and apply a significance shaping * function to it. The result is then scaled to cover a 15ms transition * range. */ change = maxf(angleChange * 25.0f, gainChange) * 2.0f; return minf(change, 1.0f) * 0.015f; }
int main() { int n,min=0; scanf("%d",&n); printf("%d\n",n); int i,a[n],max=0; for(i=0;i<n;i++) { scanf("%d",&a[i]); if(max<a[i]) max=a[i]; } while(max>0) { int c=0; for(i=0;i<n;i++) { min=minf(&a,n); a[i]=a[i]-min; if(a[i]>0) c++; } printf("%d\n",c); } return 0; }
// input : previous simultaneous masking threshold *preThr, // current simultaneous masking threshold *simThr // output: update of *preThr for next call, // current masking threshold *partThr static void PreechoControl ( float* partThr0, float* preThr0, const float* simThr0, float* partThr1, float* preThr1, const float* simThr1 ) { int n; for ( n = 0; n < PART_LONG; n++ ) { *partThr0++ = minf ( *simThr0, *preThr0 * PREFAC_LONG); *partThr1++ = minf ( *simThr1, *preThr1 * PREFAC_LONG); *preThr0++ = *simThr0++; *preThr1++ = *simThr1++; } return; }
static float cube(float *pos, float *size) { float d[3]; float dst; abs3f(d, pos); sub3f(d, d, size); dst = minf(maxf(d[0], maxf(d[1],d[2])),0.0); max3f(d, d,(float[]){0,0,0});
double vertex_to_segment_vertical_dist(double x,double y, double x1,double y1, double x2,double y2) //xy - vertex x1,y1, x2,y2 - line segment { if ((x1<=x && x<=x2) || (x2<=x && x<=x1)) { if (x1==x2) {return fabs(minf(y-y2,y-y1));} else {return fabs(y-y1-(y2-y1)*(x-x1)/(x2-x1));} } return -1; }
void handle_mousemove(SDL_MouseMotionEvent motion) { if (motion.state & 1) { // left-drag float mousex = motion.x; float mousey = Surf_Display->h - motion.y; float w = Surf_Display->w; float h = Surf_Display->h; float dim = minf(w, h); transX = gXmouseDown - (mousex / w) * 200.0 * w / dim / zoomFactor; transY = gYmouseDown - (mousey / h) * 200.0 * h / dim / zoomFactor; } }
void GameState::updateCamera( float dt ) { vec3 shipPos = ship->transform.position(); vec3 shipVel = ship->rigidBody().vel(); vec3 oldCamPos = ( *_scene->camera() )->transform.position(); vec3 maxCamPos = shipPos; // If the ship is moving enough, we'll start moving the camera ahead so the // player can see where they're moving float seekAheadFactor = minf( 40.f, vec3::length( shipVel ) * .4f ); maxCamPos += ship->transform.forward() * seekAheadFactor; // The camera should pull back from target that it follows (this ship) when the target moves maxCamPos.z = shipPos.z - ( 9.5f + seekAheadFactor ); vec3 desiredCamPos = vec3::lerp( oldCamPos, maxCamPos, minf( 8.f * dt, 0.65f ) ); ( *_scene->camera() )->transform.position( desiredCamPos ); }
void collect_statistics(CallStatP call_stats) { int i=0; CallStat min=call_stats[0], max=call_stats[0], mean=call_stats[0]; CallStat stddev; memset(&stddev, 0, sizeof(CallStat)); for (i=1; i<g_num_repeats; ++i) { min.real_time=minf(min.real_time, call_stats[i].real_time); min.user_time=minf(min.user_time, call_stats[i].user_time); min.sys_time=minf(min.sys_time, call_stats[i].sys_time); max.real_time=maxf(max.real_time, call_stats[i].real_time); max.user_time=maxf(max.user_time, call_stats[i].user_time); max.sys_time=maxf(max.sys_time, call_stats[i].sys_time); mean.real_time+=call_stats[i].real_time; mean.user_time+=call_stats[i].user_time; mean.sys_time+=call_stats[i].sys_time; } mean.real_time/=g_num_repeats; mean.user_time/=g_num_repeats; mean.sys_time/=g_num_repeats; for (i=0; i<g_num_repeats; ++i) { float d1=call_stats[i].real_time-mean.real_time; stddev.real_time+=d1*d1; float d2=call_stats[i].user_time-mean.user_time; stddev.real_time+=d2*d2; float d3=call_stats[i].sys_time-mean.sys_time; stddev.sys_time+=d3*d3; } stddev.real_time=sqrt(stddev.real_time/g_num_repeats); stddev.user_time=sqrt(stddev.user_time/g_num_repeats); stddev.sys_time=sqrt(stddev.sys_time/g_num_repeats); callstat_print(g_output_stream, &mean, "mean", g_output_format); callstat_print(g_output_stream, &min, "min", g_output_format); callstat_print(g_output_stream, &max, "max", g_output_format); callstat_print(g_output_stream, &stddev, "stddev", g_output_format); callstat_print_sep(g_output_stream, g_output_format); }
void draw_button(BITMAP *bmp, int x, int y, int w, int h, int col, const char *txt, bool selected, bool disabled) { int col1 = makecol( minf(255,getr(col)*1.3f), minf(255,getg(col)*1.3f), minf(255,getb(col)*1.3f) ); int col2 = makecol( getr(col)*0.7f, getg(col)*0.7f, getb(col)*0.7f ); int col3 = makecol( minf(255,getr(col)*1.7f), minf(255,getg(col)*1.7f), minf(255,getb(col)*1.7f) ); if(disabled) { col1 = makecol(130,130,130); col2 = makecol(50,50,50); col3 = makecol(170,170,170); col = makecol(100,100,100); } else if(selected) { rect(bmp, x-2,y-2, x+w+3,y+h+3, makecol(210,210,0)); rect(bmp, x-1,y-1, x+w+2,y+h+2, makecol(255,255,0)); col3 = makecol(255,255,255); } rectfill(bmp, x,y, x+w,y+h, col); line(bmp, x,y, x+w,y, col1); line(bmp, x+w,y, x+w,y+h, col1); line(bmp, x,y+1, x+w,y+1, col1); line(bmp, x+w+1,y, x+w+1,y+h, col1); line(bmp, x,y+h, x+w,y+h, col2); line(bmp, x,y, x,y+h, col2); line(bmp, x,y+h+1, x+w,y+h+1, col2); line(bmp, x+1,y, x+1,y+h, col2); textout_ex(bmp, font2, txt, x + (w/2) - (text_length(font2,txt)/2), y + (h/2) - (text_height(font2)/2), col3, -1); }
// calculation of the spreading function static void Spread ( PsyModel* m ) { int i; int j; float tmpx; float tmpy; float tmpz; float x; // calculation of the spreading-function for all occuring values for ( i = 0; i < PART_LONG; i++ ) { // i is masking Partition, Source for ( j = 0; j < PART_LONG; j++ ) { // j is masking Partition, Target tmpx = LongPart2Bark (m, j) - LongPart2Bark (m, i);// Difference of the partitions in Bark tmpy = tmpz = 0.; // tmpz = 0: no dip if ( tmpx < 0 ) { // downwards (S1) tmpy = -32.f * tmpx; // 32 dB per Bark, e33 (10) } else if ( tmpx > 0 ) { // upwards (S2) #if 0 x = (wl[i]+wh[i])/2 * (float)(SampleFreq / 2000)/512; // center frequency in kHz ??????? if (i==0) x = 0.5f * (float)(SampleFreq / 2000)/512; // if first spectral line #else x = i ? MPC_WL[i]+MPC_WH[i] : 1; x *= m->SampleFreq / 1000. / 2048; // center frequency in kHz #endif // dB/Bark tmpy = (22.f + 0.23f / x) * tmpx; // e33 (10) // dip (up to 6 dB) tmpz = 8 * minf ( (tmpx-0.5f) * (tmpx-0.5f) - 2 * (tmpx-0.5f), 0.f ); } // calculate coefficient m->tables.SPRD[i][j] = POW10 ( -0.1 * (tmpy+tmpz) ); // [Source] [Target] } } // Normierung e33 (10) for ( i = 0; i < PART_LONG; i++ ) { // i is masked Partition float norm = 0.f; for ( j = 0; j < PART_LONG; j++ ) // j is masking Partition norm += m->tables.SPRD [j] [i]; for ( j = 0; j < PART_LONG; j++ ) // j is masking Partition m->tables.SPRD [j] [i] /= norm; } }
// input : energy spectrums erg[4][128] (4 delayed FFTs) // Energy of the last short block *preerg in short partitions // PreechoFac declares allowed traved of the masking threshold // output: masking threshold *thr in short partitions // Energy of the last short block *preerg in short partitions static void CalcShortThreshold ( PsyModel* m, const float erg [4] [128], const float ShortThr, float* thr, float old_erg [2][PART_SHORT], int* transient ) { const int* index_lo = wl_short; // lower FFT-index const int* index_hi = wh_short; // upper FFT-index const float* iwidth = iw_short; // inverse partition-width int k; int n; int l; float new_erg; float th, TransDetect = m->TransDetect; const float* ep; for ( k = 0; k < PART_SHORT; k++ ) { transient [k] = 0; th = old_erg [0][k]; for ( n = 0; n < 4; n++ ) { ep = erg[n] + index_lo [k]; l = index_hi [k] - index_lo [k]; new_erg = *ep++; while (l--) new_erg += *ep++; // e = Short_Partition-energy in piece n if ( new_erg > old_erg [0][k] ) { // bigger than the old? if ( new_erg > old_erg [0][k] * TransDetect || new_erg > old_erg [1][k] * TransDetect*2 ) // is signal transient? transient [k] = 1; } else { th = minf ( th, new_erg ); // assume short threshold = engr*PreechoFac } old_erg [1][k] = old_erg [0][k]; old_erg [0][k] = new_erg; // save the current one } thr [k] = th * ShortThr * *iwidth++; // pull out and multiply only when transient[k]=1 } return; }
/** Add a sample to a tile using the AO algorithm * @param state global renderer state * @param pixels pixel buffer to add sample to * @param isect_buffer intersection buffer from samples generated by kernel_ao_gen_samples * @param mask_buffer the mask bitmap * @param n_pixels number of pixels in buffer * @param n_samples number of samples already in the buffer */ void kernel_ao_add_sample(state_t state, vec3* pixels, hit_t* isect_buffer, int* mask_buffer, sample_t* sample_buffer, int n_samples, int i) { //compute the sample float l; if(mask_buffer[i] == 1) { l = 0.f; } else if(isect_buffer[i].t == -1) { l = 1.f; } else { l = minf(1.f,isect_buffer[i].t/state.ao_params.length); } vec3 p = make_vec3(l,l,l); if(isnan(p.x) || isnan(p.y) || isnan(p.z)) { p = make_vec3(0.f,1.f,0.f); } pixels[i] = div_vec3_scalar(add_vec3(mul_vec3_scalar(pixels[i], n_samples+(1-sample_buffer[i].weight)), mul_vec3_scalar(p, sample_buffer[i].weight)),(n_samples+1)); }
template<typename Scalar> void special_numbers() { typedef Matrix<Scalar, Dynamic,Dynamic> MatType; int rows = internal::random<int>(1,300); int cols = internal::random<int>(1,300); Scalar nan = std::numeric_limits<Scalar>::quiet_NaN(); Scalar inf = std::numeric_limits<Scalar>::infinity(); Scalar s1 = internal::random<Scalar>(); MatType m1 = MatType::Random(rows,cols), mnan = MatType::Random(rows,cols), minf = MatType::Random(rows,cols), mboth = MatType::Random(rows,cols); int n = internal::random<int>(1,10); for(int k=0; k<n; ++k) { mnan(internal::random<int>(0,rows-1), internal::random<int>(0,cols-1)) = nan; minf(internal::random<int>(0,rows-1), internal::random<int>(0,cols-1)) = inf; } mboth = mnan + minf; VERIFY(!m1.hasNaN()); VERIFY(m1.allFinite()); VERIFY(mnan.hasNaN()); VERIFY((s1*mnan).hasNaN()); VERIFY(!minf.hasNaN()); VERIFY(!(2*minf).hasNaN()); VERIFY(mboth.hasNaN()); VERIFY(mboth.array().hasNaN()); VERIFY(!mnan.allFinite()); VERIFY(!minf.allFinite()); VERIFY(!(minf-mboth).allFinite()); VERIFY(!mboth.allFinite()); VERIFY(!mboth.array().allFinite()); }
static double transform_distance_garmin(struct coord *c1, struct coord *c2) { #ifdef USE_HALVESINE static const int earth_radius = 6371*1000; //m change accordingly // static const int earth_radius = 3960; //miles //Point 1 cords navit_float lat1 = GC2RAD(c1->y); navit_float long1 = GC2RAD(c1->x); //Point 2 cords navit_float lat2 = GC2RAD(c2->y); navit_float long2 = GC2RAD(c2->x); //Haversine Formula navit_float dlong = long2-long1; navit_float dlat = lat2-lat1; navit_float sinlat = navit_sin(dlat/2); navit_float sinlong = navit_sin(dlong/2); navit_float a=(sinlat*sinlat)+navit_cos(lat1)*navit_cos(lat2)*(sinlong*sinlong); navit_float c=2*navit_asin(minf(1,navit_sqrt(a))); #ifdef AVOID_FLOAT return round(earth_radius*c); #else return earth_radius*c; #endif #else #define GMETER 2.3887499999999999 navit_float dx,dy; dx=c1->x-c2->x; dy=c1->y-c2->y; return navit_sqrt(dx*dx+dy*dy)*GMETER; #undef GMETER #endif }
// Calculate the coefficient for a HF (and eventually LF) decay damping // filter. static __inline ALfloat CalcDampingCoeff(ALfloat hfRatio, ALfloat length, ALfloat decayTime, ALfloat decayCoeff, ALfloat cw) { ALfloat coeff, g; // Eventually this should boost the high frequencies when the ratio // exceeds 1. coeff = 0.0f; if (hfRatio < 1.0f) { // Calculate the low-pass coefficient by dividing the HF decay // coefficient by the full decay coefficient. g = CalcDecayCoeff(length, decayTime * hfRatio) / decayCoeff; // Damping is done with a 1-pole filter, so g needs to be squared. g *= g; coeff = lpCoeffCalc(g, cw); // Very low decay times will produce minimal output, so apply an // upper bound to the coefficient. coeff = minf(coeff, 0.98f); } return coeff; }
void BatchRenderer::DrawDashedLine( const Vec3D& start, const Vec3D& end, const FLOAT dashSize, const FColor& startColor, const FColor& endColor ) { mxSWIPED("Unreal Engine 3"); Vec3D lineDir = end - start; FLOAT lineLeft = (end - start).LengthFast(); lineDir /= lineLeft; while(lineLeft > 0.f) { Vec3D DrawStart = end - ( lineLeft * lineDir ); Vec3D DrawEnd = DrawStart + ( minf(dashSize, lineLeft) * lineDir ); this->DrawLine3D( DrawStart, DrawEnd, startColor, endColor ); lineLeft -= 2*dashSize; } }
void Cterrain::showAndMark(int jmin,int jmax,int imin,int imax,int curDepth) { //检查当前节点是否与视截体相交 //求节点p所表示区域的保守包围盒 // 上面 // p[0]--p[3] // | | // p[1]--p[2] // 下面 // p[4]--p[7] // | | // p[5]--p[6] float xmin=m_range.getMinX()+gridSize*jmin; float xmax=m_range.getMinX()+gridSize*jmax; float zmin=m_range.getMinZ()+gridSize*imin; float zmax=m_range.getMinZ()+gridSize*imax; float ymin=m_range.getMinY(); float ymax=m_range.getMaxY(); float c[3]={(xmax+xmin)/2,(ymin+ymax)/2,(zmin+zmax)/2}; float r=max(xmax-xmin,ymax-ymin)*0.86602540378443864676372317075294;//由于zmax-zmin与xmax-xmin相等,所以不用考虑 //看球体(c,r)是否都在planeList中某个面的反面,如果是则可剔除 bool visible=true; for(int i=0;i<5;i++){//不考虑远平面 const Cplane&plane=this->getModel()->getMeshByIndex(0)->getCamera()->getFrustum().getPlaneByIndex(i); //看球体(c,r)是否在plane的背面 float PND=PND_point_plane(plane, c); if(PND<-r){//如果在背面 //断定为不可见,不用再继续检测 visible=false; break; } }//得到visible if(visible){//如果可见 bool needDiv=false;//是否需要再分 //求needDiv if(imin+1==imax){//无须再分,因为已经无法再分 needDiv=false; }else{//进一步判断 //求c到视点的距离 //指数值越大,LOD效应越明显 float d=square(this->getModel()->getMeshByIndex(0)->getCamera()->getEyePos().x()-c[0]) +square(minf(0.6*(this->getModel()->getMeshByIndex(0)->getCamera()->getEyePos().y()-c[1]),700))//Y乘以一个比1小的系数是为了让LOD对高度变化不敏感 +square(this->getModel()->getMeshByIndex(0)->getCamera()->getEyePos().z()-c[2]); float e=xmax-xmin;//边长 if(d<e*reso)needDiv=true; }//得到needDiv if(needDiv){//继续分 int imid=(imin+imax)>>1;//除2 int jmid=(jmin+jmax)>>1; markmat[imid][jmid]=true; markedElementIndexList.push_back(Cij(imid,jmid)); //对四个孩子继续递归 showAndMark(jmin,jmid,imin,imid,curDepth+1); showAndMark(jmin,jmid,imid,imax,curDepth+1); showAndMark(jmid,jmax,imid,imax,curDepth+1); showAndMark(jmid,jmax,imin,imid,curDepth+1); }else{//不分 const int vIDMat_imin=(int)markmat[0].size()*imin;//vIDMat[imin]; const int vIDMat_imax=(int)markmat[0].size()*imax;//vIDMat[imax]; const int ID0=vIDMat_imin+jmin; const int ID1=vIDMat_imax+jmin; const int ID2=vIDMat_imax+jmax; const int ID3=vIDMat_imin+jmax; this->getModel()->getMeshByIndex(0)->addIDtri(ID0, ID1, ID2); this->getModel()->getMeshByIndex(0)->addIDtri(ID0, ID2, ID3); } }
void handle_mousedown(SDL_MouseButtonEvent button) { //printf("SDL Mousebutton down event: mouse %d, button %d, state %d, %dx%d\n", Event.button.which, Event.button.button, Event.button.state, Event.button.x, Event.button.y); switch (button.button) { case 1: // left mouse { float mousex = button.x; float mousey = Surf_Display->h - button.y; float w = Surf_Display->w; float h = Surf_Display->h; float dim = minf(w, h); gXmouseDown = transX + (mousex / w) * 200.0 * w / dim / zoomFactor; gYmouseDown = transY + (mousey / h) * 200.0 * h / dim / zoomFactor; if (timerDragRender) SDL_RemoveTimer(timerDragRender); timerDragRender = SDL_AddTimer(50, &timerCallback, (void *) TIMER_DRAGRENDER); } break; case 2: // middle mouse break; case 3: // right mouse break; case 4: // wheel up if ((keymodifiermask & (KMM_LSHIFT | KMM_RSHIFT)) == 0) { #ifdef OPENGL float mousex = button.x; float mousey = Surf_Display->h - button.y; float w = Surf_Display->w; float h = Surf_Display->h; float dim = minf(w, h); float gX = transX + (mousex / w) * 200.0 * w / dim / zoomFactor; float gY = transY + (mousey / h) * 200.0 * h / dim / zoomFactor; //printf("%d,%d->%d,%d\n", (int) transX, (int) transY, (int) gX, (int) gY); zoomFactor *= 1.1; transX = gX - (mousex / w) * 200.0 * w / dim / zoomFactor; transY = gY - (mousey / h) * 200.0 * h / dim/ zoomFactor; #else //float viewX = (gX - viewPortL) * zoomFactor, float gX = ((float) button.x) / zoomFactor + viewPortL; // float viewY = (viewPortB - gY) * zoomFactor, float gY = viewPortB - ((float) button.y) / zoomFactor; zoomFactor *= 1.1; //printf("Zoom %g\n", zoomFactor); viewPortL = gX - ((float) button.x) / zoomFactor; viewPortB = ((float) button.y) / zoomFactor + gY; #endif render(); } else if (currentLayer > 0) drawLayer(--currentLayer); break; case 5: // wheel down if ((keymodifiermask & (KMM_LSHIFT | KMM_RSHIFT)) == 0) { #ifdef OPENGL float mousex = button.x; float mousey = Surf_Display->h - button.y; float w = Surf_Display->w; float h = Surf_Display->h; float dim = minf(w, h); float gX = transX + (mousex / w) * 200.0 * w / dim / zoomFactor; float gY = transY + (mousey / h) * 200.0 * h / dim / zoomFactor; //printf("%d,%d->%d,%d\n", (int) transX, (int) transY, (int) gX, (int) gY); zoomFactor /= 1.1; transX = gX - (mousex / w) * 200.0 * w / dim / zoomFactor; transY = gY - (mousey / h) * 200.0 * h / dim / zoomFactor; #else //float viewX = (gX - viewPortL) * zoomFactor, float gX = ((float) button.x) / zoomFactor + viewPortL; // float viewY = (viewPortB - gY) * zoomFactor, float gY = viewPortB - ((float) button.y) / zoomFactor; zoomFactor /= 1.1; //printf("Zoom %g\n", zoomFactor); viewPortL = gX - ((float) button.x) / zoomFactor; viewPortB = ((float) button.y) / zoomFactor + gY; #endif render(); } else if (currentLayer < layerCount - 1) drawLayer(++currentLayer); break; } }