float Vec2i::distancef(const Vec2i &rhs) const { return sqrtf(powf(((float)x_-(float)rhs.x()), 2.0f) + pow(((float)y_-(float)rhs.y()), 2.0f)); }
/* offsetIndex: [0] skeleton [1] spline [2] offset spline */ ofVec2f BGGraphics::calculateInternalTexOffset(float t, bool isSourceSpline, bool isSourceSegment, int offsetIndex) { const float triangleHeight = .5 * tanf(M_PI / 3.0); const float baseSize = sqrtf(3.0); const float halfBaseSize = .5 * baseSize; const ofVec2f source(0, 1); const ofVec2f sink1(-halfBaseSize, -.5); const ofVec2f sink2(halfBaseSize, -.5); const ofVec2f center = (source + sink1 + sink2) / 3.0; const float bezierOffset = 0.5 * baseSize; const float maxInternalOffset = (.25 * source - .5 * center + .25 * sink1).length(); const float centerStretchFactor = (maxInternalOffset + bezierOffset) / bezierOffset; ofVec2f focusPt = isSourceSpline ? ofVec2f(baseSize, 1) : ofVec2f(0, -2); float fromFocusAngle = M_PI * (isSourceSpline ? (1.0 + t / 3.0) : ((1.0 + t) / 3.0)); ofVec2f toPtVector(cosf(fromFocusAngle), sinf(fromFocusAngle)); float offset = (offsetIndex == 2) ? (.5 * baseSize) : baseSize; ofVec2f xy = focusPt + offset * toPtVector; if(offsetIndex == 0) { //project point on base spline ofVec2f projBase = isSourceSegment ? ofVec2f(0,1) : ofVec2f(halfBaseSize, -.5); xy = dot(xy, projBase) * projBase; } //in case we are dealing with the center point: if(offsetIndex == -1) xy = ofVec2f(0,0); const ofVec2f cornerTL = source + (sink1 - sink2); const ofVec2f cornerTR = source + (sink2 - sink1); const ofVec2f cornerB = sink1 + (sink2 - source); ofVec2f vecSource = (center - source).normalize(); ofVec2f vecSink1 = (sink1 - center).normalize(); ofVec2f vecSink2 = (sink2 - center).normalize(); float traversalDistance = 2. * (center - source).length(); float projSource = dot(xy - source, vecSource); float projSink1 = dot(xy - sink1, vecSink1); float projSink2 = dot(xy - sink2, vecSink2); float orSource = cross(xy - source, vecSource); float orSink1 = cross(xy - sink1, vecSink1); float orSink2 = cross(xy - sink2, vecSink2); float val1 = projSource / traversalDistance; float val2 = 1.0 + projSink1 / traversalDistance; float val3 = 1.0 + projSink2 / traversalDistance; float offsetX = 0; if(ABS(projSource) < .0001) offsetX = val1; else if(ABS(projSink1) < .0001) offsetX = val2; else if(ABS(projSink2) < .0001) offsetX = val3; else { float power = 2.0; float weight1 = powf(1.0 / ABS(projSource), power); float weight2 = powf(1.0 / ABS(projSink1), power); float weight3 = powf(1.0 / ABS(projSink2), power); float sumWeight = weight1 + weight2 + weight3; offsetX = (weight1 / sumWeight) * val1 + (weight2 / sumWeight) * val2 + (weight3 / sumWeight) * val3; } ofVec2f to = xy - focusPt; float toDist = to.length(); to /= toDist; float dist = MAX(0.0, toDist - bezierOffset); float maxAng = M_PI / 6.; float angle = acos(dot(to, (center - focusPt).normalize())); float maxOffset = baseSize / cos(M_PI / 6.0 - angle) - bezierOffset; float circDistFrac = dist / (baseSize - bezierOffset); float projDistFrac = dist / maxOffset; float angleFrac = 1. - angle / maxAng; float offFactor = pow(projDistFrac, 2.0 + abs(angleFrac) * projDistFrac); float offsetY = (1. - offFactor) * circDistFrac + offFactor * projDistFrac; offsetY = 1. - offsetY; if(isnan(offsetX) || isnan(offsetY)) cout << "OFFSET VALUE is NaN" << endl; return ofVec2f(offsetX - .5, offsetY); }
// autotest helper function // _n : sequence length // _dt : fractional sample offset // _dphi : carrier frequency offset void detector_cccf_runtest(unsigned int _n, float _dt, float _dphi) { // TODO: validate input unsigned int i; // fixed values float noise_floor = -80.0f; // noise floor [dB] float SNRdB = 30.0f; // signal-to-noise ratio [dB] unsigned int m = 11; // resampling filter semi-length float threshold = 0.3f; // detection threshold // derived values unsigned int num_samples = _n + 2*m + 1; float nstd = powf(10.0f, noise_floor/20.0f); float gamma = powf(10.0f, (SNRdB + noise_floor)/20.0f); float delay = (float)(_n + m) + _dt; // expected delay // arrays float complex s[_n]; // synchronization pattern (samples) float complex x[num_samples]; // resampled signal with noise and offsets // generate synchronization pattern (two samples per symbol) unsigned int n2 = (_n - (_n%2)) / 2; // n2 = floor(n/2) unsigned int mm = liquid_nextpow2(n2); // mm = ceil( log2(n2) ) msequence ms = msequence_create_default(mm); float complex v = 0.0f; for (i=0; i<_n; i++) { if ( (i%2)==0 ) v = msequence_advance(ms) ? 1.0f : -1.0f; s[i] = v; } msequence_destroy(ms); // create fractional sample interpolator firfilt_crcf finterp = firfilt_crcf_create_kaiser(2*m+1, 0.45f, 40.0f, _dt); // generate sequence for (i=0; i<num_samples; i++) { // add fractional sample timing offset if (i < _n) firfilt_crcf_push(finterp, s[i]); else firfilt_crcf_push(finterp, 0.0f); // compute output firfilt_crcf_execute(finterp, &x[i]); // add channel gain x[i] *= gamma; // add carrier offset x[i] *= cexpf(_Complex_I*_dphi*i); // add noise x[i] += nstd * ( randnf() + _Complex_I*randnf() ) * M_SQRT1_2; } // destroy fractional sample interpolator firfilt_crcf_destroy(finterp); // create detector detector_cccf sync = detector_cccf_create(s, _n, threshold, 2*_dphi); // push signal through detector float tau_hat = 0.0f; // fractional sample offset estimate float dphi_hat = 0.0f; // carrier offset estimate float gamma_hat = 1.0f; // signal level estimate (linear) float delay_hat = 0.0f; // total delay offset estimate int signal_detected = 0; // signal detected flag for (i=0; i<num_samples; i++) { // correlate int detected = detector_cccf_correlate(sync, x[i], &tau_hat, &dphi_hat, &gamma_hat); if (detected) { signal_detected = 1; delay_hat = (float)i + (float)tau_hat; if (liquid_autotest_verbose) { printf("****** preamble found, tau_hat=%8.6f, dphi_hat=%8.6f, gamma_hat=%8.6f\n", tau_hat, dphi_hat, gamma_hat); } } } // destroy objects detector_cccf_destroy(sync); // // run tests // // convert to dB gamma = 20*log10f(gamma); gamma_hat = 20*log10f(gamma_hat); if (liquid_autotest_verbose) { printf("detector autotest [%3u]: signal detected? %s\n", _n, signal_detected ? "yes" : "no"); printf(" dphi : estimate = %12.6f (expected %12.6f)\n", dphi_hat, _dphi); printf(" delay : estimate = %12.6f (expected %12.6f)\n", delay_hat, delay); printf(" gamma : estimate = %12.6f (expected %12.6f)\n", gamma_hat, gamma); } // ensure signal was detected CONTEND_EXPRESSION( signal_detected ); // check carrier offset estimate CONTEND_DELTA( dphi_hat, _dphi, 0.01f ); // check delay estimate CONTEND_DELTA( delay_hat, delay, 0.2f ); // check signal level estimate CONTEND_DELTA( gamma_hat, gamma, 2.0f ); }
void CCEaseIn::update(float time) { m_pOther->update(powf(time, m_fRate)); }
void CCEaseExponentialIn::update(float time) { m_pOther->update(time == 0 ? 0 : powf(2, 10 * (time/1 - 1)) - 1 * 0.001f); }
void Corpse::Update(float dt) { SPADES_MARK_FUNCTION(); float damp = 1.f; float damp2 = 1.f; if(dt > 0.f){ damp = powf(.9f, dt); damp2 = powf(.371f, dt); } //dt *= 0.1f; for(int i = 0; i <NodeCount; i++){ Node& node = nodes[i]; Vector3 oldPos = node.lastPos; node.pos += node.vel * dt; SPAssert(!isnan(node.pos.x)); SPAssert(!isnan(node.pos.y)); SPAssert(!isnan(node.pos.z)); if(node.pos.z > 63.f){ node.vel.z -= dt * 6.f; // buoyancy node.vel *= damp; }else{ node.vel.z += dt * 32.f; // gravity node.vel.z *= damp2; } //node.vel *= damp; if(!map->ClipBox(oldPos.x, oldPos.y, oldPos.z)){ if(map->ClipBox(node.pos.x, oldPos.y, oldPos.z)){ node.vel.x = -node.vel.x * .2f; if(fabsf(node.vel.x) < .3f) node.vel.x = 0.f; node.pos.x = oldPos.x; node.vel.y *= .5f; node.vel.z *= .5f; } if(map->ClipBox(node.pos.x, node.pos.y, oldPos.z)){ node.vel.y = -node.vel.y * .2f; if(fabsf(node.vel.y) < .3f) node.vel.y = 0.f; node.pos.y = oldPos.y; node.vel.x *= .5f; node.vel.z *= .5f; } if(map->ClipBox(node.pos.x, node.pos.y, node.pos.z)){ node.vel.z = -node.vel.z * .2f; if(fabsf(node.vel.z) < .3f) node.vel.z = 0.f; node.pos.z = oldPos.z; node.vel.x *= .5f; node.vel.y *= .5f; } if(map->ClipBox(node.pos.x, node.pos.y, node.pos.z)){ // TODO: getting out block //node.pos = oldPos; //node.vel *= .5f; } } /* if(map->ClipBox(node.pos.x, node.pos.y, node.pos.z)){ if(!map->ClipBox(node.pos.x, node.pos.y, oldPos.z)){ node.vel.z = -node.vel.z * .2f; if(fabsf(node.vel.z) < .3f) node.vel.z = 0.f; node.pos.z = oldPos.z; } if(!map->ClipBox(node.pos.x, oldPos.y, node.pos.z)){ node.vel.y = -node.vel.y * .2f; if(fabsf(node.vel.y) < .3f) node.vel.y = 0.f; node.pos.y = oldPos.y; } if(!map->ClipBox(oldPos.x, node.pos.y, node.pos.z)){ node.vel.x = -node.vel.x * .2f; if(fabsf(node.vel.x) < .3f) node.vel.x = 0.f; node.pos.x = oldPos.x; } node.vel *= .8f; //node.pos = oldPos; if(node.vel.GetLength() < .02f){ node.vel *= 0.f; } }*/ node.lastPos = node.pos; node.lastForce = node.vel; } ApplyConstraint(dt); for(int i = 0; i <NodeCount; i++){ nodes[i].lastForce = nodes[i].vel - nodes[i].lastForce; } }
/* * Effect output */ void Valve::out (float * smpsl, float * smpsr) { int i; float l, r, lout, rout, fx; if (Pstereo != 0) { //Stereo for (i = 0; i < param->PERIOD; i++) { efxoutl[i] = smpsl[i] * inputvol; efxoutr[i] = smpsr[i] * inputvol; }; } else { for (i = 0; i < param->PERIOD; i++) { efxoutl[i] = (smpsl[i] + smpsr[i] ) * inputvol; }; }; harm->harm_out(efxoutl,efxoutr); if (Pprefiltering != 0) applyfilters (efxoutl, efxoutr); if(Ped) { for (i =0; i<param->PERIOD; i++) { efxoutl[i]=Wshape(efxoutl[i]); if (Pstereo != 0) efxoutr[i]=Wshape(efxoutr[i]); } } for (i =0; i<param->PERIOD; i++) { //soft limiting to 3.0 (max) fx = efxoutl[i]; if (fx>1.0f) fx = 3.0f - 2.0f/sqrtf(fx); efxoutl[i] = fx; fx = efxoutr[i]; if (fx>1.0f) fx = 3.0f - 2.0f/sqrtf(fx); efxoutr[i] = fx; } if (q == 0.0f) { for (i =0; i<param->PERIOD; i++) { if (efxoutl[i] == q) fx = fdist; else fx =efxoutl[i] / (1.0f - powf(2.0f,-dist * efxoutl[i] )); otml = atk * otml + fx - itml; itml = fx; efxoutl[i]= otml; } } else { for (i = 0; i < param->PERIOD; i++) { if (efxoutl[i] == q) fx = fdist + qcoef; else fx =(efxoutl[i] - q) / (1.0f - powf(2.0f,-dist * (efxoutl[i] - q))) + qcoef; otml = atk * otml + fx - itml; itml = fx; efxoutl[i]= otml; } } if (Pstereo != 0) { if (q == 0.0f) { for (i =0; i<param->PERIOD; i++) { if (efxoutr[i] == q) fx = fdist; else fx = efxoutr[i] / (1.0f - powf(2.0f,-dist * efxoutr[i] )); otmr = atk * otmr + fx - itmr; itmr = fx; efxoutr[i]= otmr; } } else { for (i = 0; i < param->PERIOD; i++) { if (efxoutr[i] == q) fx = fdist + qcoef; else fx = (efxoutr[i] - q) / (1.0f - powf(2.0f,-dist * (efxoutr[i] - q))) + qcoef; otmr = atk * otmr + fx - itmr; itmr = fx; efxoutr[i]= otmr; } } } if (Pprefiltering == 0) applyfilters (efxoutl, efxoutr); if (Pstereo == 0) memcpy (efxoutr , efxoutl, param->PERIOD * sizeof(float)); float level = dB2rap (60.0f * (float)Plevel / 127.0f - 40.0f); for (i = 0; i < param->PERIOD; i++) { lout = efxoutl[i]; rout = efxoutr[i]; l = lout * (1.0f - lrcross) + rout * lrcross; r = rout * (1.0f - lrcross) + lout * lrcross; lout = l; rout = r; efxoutl[i] = lout * 2.0f * level * panning; efxoutr[i] = rout * 2.0f * level * (1.0f -panning); }; };
void CRMLandScape::Sprinkle(CCMPatch *patch, CCGHeightDetails *hd, int level) { int i, count, px, py; float density; vec3_t origin, scale, angles, bounds[2]; refEntity_t refEnt; CRandomModel *rm; CArea area; // int areaTypes[] = { AT_BSP, AT_OBJECTIVE }; TCGMiscEnt *data = (TCGMiscEnt *)cl.mSharedMemory; TCGTrace *td = (TCGTrace *)cl.mSharedMemory; // memset(&refEnt, 0, sizeof(refEntity_t)); px = patch->GetHeightMapX() / common->GetTerxels(); py = patch->GetHeightMapY() / common->GetTerxels(); // Get a number -5.3f to 5.3f density = (mDensityMap[px + (common->GetBlockWidth() * py)] - 128) / 24.0f; // ..and multiply that into the count count = Round(common->GetPatchScalarSize() * hd->GetAverageFrequency() * powf(2.0f, density) * 0.001); for(i = 0; i < count; i++) { if(!common->irand(0, 10)) { vec3_t temp; float average; rm = hd->GetRandomModel(common); refEnt.hModel = re.RegisterModel(rm->GetModelName()); refEnt.frame = 0; re.ModelBoundsRef(&refEnt, bounds[0], bounds[1]); // Calculate the scale using some magic to help ensure that the // scales are never too different from eachother. Otherwise you // could get an entity that is really small on one axis but huge // on another. temp[0] = common->flrand(rm->GetMinScale(), rm->GetMaxScale()); temp[1] = common->flrand(rm->GetMinScale(), rm->GetMaxScale()); temp[2] = common->flrand(rm->GetMinScale(), rm->GetMaxScale()); // Average of the three random numbers and divide that by two average = ( ( temp[0] + temp[1] + temp[2] ) / 3) / 2; // Add in half of the other two numbers and then subtract half the average to prevent. // any number from going beyond the range. If all three numbers were the same then // they would remain unchanged after this calculation. scale[0] = temp[0] + (temp[1]+temp[2]) / 2 - average; scale[1] = temp[1] + (temp[0]+temp[2]) / 2 - average; scale[2] = temp[2] + (temp[0]+temp[1]) / 2 - average; angles[0] = 0.0f; angles[1] = common->flrand(-M_PI, M_PI); angles[2] = 0.0f; VectorCopy(patch->GetMins(), origin); origin[0] += common->flrand(0.0f, common->GetPatchWidth()); origin[1] += common->flrand(0.0f, common->GetPatchHeight()); // Get above world height float slope = common->GetWorldHeight(origin, bounds, true); if (slope > 1.33) { // spot has too steep of a slope continue; } if(origin[2] < common->GetWaterHeight()) { continue; } // very that we aren't dropped too low if (origin[2] < common->CalcWorldHeight(level)) { continue; } // Hack-ariffic, don't allow them to drop below the big player clip brush. if (origin[2] < 1280 ) { continue; } // FIXME: shouldn't be using a hard-coded 1280 number, only allow to spawn if inside player clip brush? // if( !(CONTENTS_PLAYERCLIP & VM_Call( cgvm, CG_POINT_CONTENTS )) ) // { // continue; // } // Simple radius check for buildings /* area.Init(origin, VectorLength(bounds[0])); if(common->AreaCollision(&area, areaTypes, sizeof(areaTypes) / sizeof(int))) { continue; }*/ // Make sure there is no architecture around - doesn't work for ents though =( memset(td, sizeof(*td), 0); VectorCopy(origin, td->mStart); VectorCopy(bounds[0], td->mMins); VectorCopy(bounds[1], td->mMaxs); VectorCopy(origin, td->mEnd); td->mSkipNumber = -1; td->mMask = MASK_PLAYERSOLID; VM_Call( cgvm, CG_TRACE ); if(td->mResult.surfaceFlags & SURF_NOMISCENTS) { continue; } if(td->mResult.startsolid) { // continue; } // Get minimum height of area common->GetWorldHeight(origin, bounds, false); // Account for relative origin origin[2] -= bounds[0][2] * scale[2]; origin[2] -= common->flrand(2.0, (bounds[1][2] - bounds[0][2]) / 4); // Spawn the client model strcpy(data->mModel, rm->GetModelName()); VectorCopy(origin, data->mOrigin); VectorCopy(angles, data->mAngles); VectorCopy(scale, data->mScale); VM_Call( cgvm, CG_MISC_ENT); mModelCount++; } } }
float decibelsToLinear(float decibels) { return powf(10, 0.05f * decibels); }
void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int width, int height) { /* these two passes could be combined into one, but it's more readable and * easy to tweak like this, speed isn't really that much of an issue in this situation... */ int checkerwidth= 32, dark= 1; int x, y; unsigned char *rect_orig= rect; float *rect_float_orig= rect_float; float h=0.0, hoffs=0.0, hue=0.0, s=0.9, v=0.9, r, g, b; /* checkers */ for(y= 0; y<height; y++) { dark= powf(-1.0f, floorf(y / checkerwidth)); for(x= 0; x<width; x++) { if (x % checkerwidth == 0) dark= -dark; if (rect_float) { if (dark > 0) { rect_float[0]= rect_float[1]= rect_float[2]= 0.25f; rect_float[3]= 1.0f; } else { rect_float[0]= rect_float[1]= rect_float[2]= 0.58f; rect_float[3]= 1.0f; } rect_float+= 4; } else { if (dark > 0) { rect[0]= rect[1]= rect[2]= 64; rect[3]= 255; } else { rect[0]= rect[1]= rect[2]= 150; rect[3]= 255; } rect+= 4; } } } rect= rect_orig; rect_float= rect_float_orig; /* 2nd pass, colored + */ for(y= 0; y<height; y++) { hoffs= 0.125f * floorf(y / checkerwidth); for(x= 0; x<width; x++) { h= 0.125f * floorf(x / checkerwidth); if ((fabs((x % checkerwidth) - (checkerwidth / 2)) < 4) && (fabs((y % checkerwidth) - (checkerwidth / 2)) < 4)) { if ((fabs((x % checkerwidth) - (checkerwidth / 2)) < 1) || (fabs((y % checkerwidth) - (checkerwidth / 2)) < 1)) { hue= fmodf(fabs(h-hoffs), 1.0f); hsv_to_rgb(hue, s, v, &r, &g, &b); if (rect) { rect[0]= (char)(r * 255.0f); rect[1]= (char)(g * 255.0f); rect[2]= (char)(b * 255.0f); rect[3]= 255; } if (rect_float) { rect_float[0]= r; rect_float[1]= g; rect_float[2]= b; rect_float[3]= 1.0f; } } } if (rect_float) rect_float+= 4; if (rect) rect+= 4; } } }
struct circle computeArea(struct circle instance){ instance.area = powf ( (pi * (instance.diameter * .5)), 2 ); return instance; }
inline void Audio::performIO(int16_t* inputLeft, int16_t* outputLeft, int16_t* outputRight) { NodeList* nodeList = NodeList::getInstance(); Application* interface = Application::getInstance(); Avatar* interfaceAvatar = interface->getAvatar(); // Add Procedural effects to input samples addProceduralSounds(inputLeft, BUFFER_LENGTH_SAMPLES_PER_CHANNEL); if (nodeList && inputLeft) { // Measure the loudness of the signal from the microphone and store in audio object float loudness = 0; for (int i = 0; i < BUFFER_LENGTH_SAMPLES_PER_CHANNEL; i++) { loudness += abs(inputLeft[i]); } loudness /= BUFFER_LENGTH_SAMPLES_PER_CHANNEL; _lastInputLoudness = loudness; // add input (@microphone) data to the scope _scope->addSamples(0, inputLeft, BUFFER_LENGTH_SAMPLES_PER_CHANNEL); Node* audioMixer = nodeList->soloNodeOfType(NODE_TYPE_AUDIO_MIXER); if (audioMixer) { glm::vec3 headPosition = interfaceAvatar->getHeadJointPosition(); glm::quat headOrientation = interfaceAvatar->getHead().getOrientation(); int numBytesPacketHeader = numBytesForPacketHeader((unsigned char*) &PACKET_TYPE_MICROPHONE_AUDIO_NO_ECHO); int leadingBytes = numBytesPacketHeader + sizeof(headPosition) + sizeof(headOrientation); // we need the amount of bytes in the buffer + 1 for type // + 12 for 3 floats for position + float for bearing + 1 attenuation byte unsigned char dataPacket[BUFFER_LENGTH_BYTES_PER_CHANNEL + leadingBytes]; PACKET_TYPE packetType = (Application::getInstance()->shouldEchoAudio()) ? PACKET_TYPE_MICROPHONE_AUDIO_WITH_ECHO : PACKET_TYPE_MICROPHONE_AUDIO_NO_ECHO; unsigned char* currentPacketPtr = dataPacket + populateTypeAndVersion(dataPacket, packetType); // memcpy the three float positions memcpy(currentPacketPtr, &headPosition, sizeof(headPosition)); currentPacketPtr += (sizeof(headPosition)); // memcpy our orientation memcpy(currentPacketPtr, &headOrientation, sizeof(headOrientation)); currentPacketPtr += sizeof(headOrientation); // copy the audio data to the last BUFFER_LENGTH_BYTES bytes of the data packet memcpy(currentPacketPtr, inputLeft, BUFFER_LENGTH_BYTES_PER_CHANNEL); nodeList->getNodeSocket()->send(audioMixer->getActiveSocket(), dataPacket, BUFFER_LENGTH_BYTES_PER_CHANNEL + leadingBytes); interface->getBandwidthMeter()->outputStream(BandwidthMeter::AUDIO) .updateValue(BUFFER_LENGTH_BYTES_PER_CHANNEL + leadingBytes); } } memset(outputLeft, 0, PACKET_LENGTH_BYTES_PER_CHANNEL); memset(outputRight, 0, PACKET_LENGTH_BYTES_PER_CHANNEL); AudioRingBuffer* ringBuffer = &_ringBuffer; // if there is anything in the ring buffer, decide what to do: if (ringBuffer->getEndOfLastWrite()) { if (!ringBuffer->isStarted() && ringBuffer->diffLastWriteNextOutput() < (PACKET_LENGTH_SAMPLES + _jitterBufferSamples * (ringBuffer->isStereo() ? 2 : 1))) { // // If not enough audio has arrived to start playback, keep waiting // #ifdef SHOW_AUDIO_DEBUG printLog("%i,%i,%i,%i\n", _packetsReceivedThisPlayback, ringBuffer->diffLastWriteNextOutput(), PACKET_LENGTH_SAMPLES, _jitterBufferSamples); #endif } else if (ringBuffer->isStarted() && ringBuffer->diffLastWriteNextOutput() == 0) { // // If we have started and now have run out of audio to send to the audio device, // this means we've starved and should restart. // ringBuffer->setStarted(false); _numStarves++; _packetsReceivedThisPlayback = 0; _wasStarved = 10; // Frames for which to render the indication that the system was starved. #ifdef SHOW_AUDIO_DEBUG printLog("Starved, remaining samples = %d\n", ringBuffer->diffLastWriteNextOutput()); #endif } else { // // We are either already playing back, or we have enough audio to start playing back. // if (!ringBuffer->isStarted()) { ringBuffer->setStarted(true); #ifdef SHOW_AUDIO_DEBUG printLog("starting playback %0.1f msecs delayed, jitter = %d, pkts recvd: %d \n", (usecTimestampNow() - usecTimestamp(&_firstPacketReceivedTime))/1000.0, _jitterBufferSamples, _packetsReceivedThisPlayback); #endif } // // play whatever we have in the audio buffer // // if we haven't fired off the flange effect, check if we should // TODO: lastMeasuredHeadYaw is now relative to body - check if this still works. int lastYawMeasured = fabsf(interfaceAvatar->getHeadYawRate()); if (!_samplesLeftForFlange && lastYawMeasured > MIN_FLANGE_EFFECT_THRESHOLD) { // we should flange for one second if ((_lastYawMeasuredMaximum = std::max(_lastYawMeasuredMaximum, lastYawMeasured)) != lastYawMeasured) { _lastYawMeasuredMaximum = std::min(_lastYawMeasuredMaximum, MIN_FLANGE_EFFECT_THRESHOLD); _samplesLeftForFlange = SAMPLE_RATE; _flangeIntensity = MIN_FLANGE_INTENSITY + ((_lastYawMeasuredMaximum - MIN_FLANGE_EFFECT_THRESHOLD) / (float)(MAX_FLANGE_EFFECT_THRESHOLD - MIN_FLANGE_EFFECT_THRESHOLD)) * (1 - MIN_FLANGE_INTENSITY); _flangeRate = FLANGE_BASE_RATE * _flangeIntensity; _flangeWeight = MAX_FLANGE_SAMPLE_WEIGHT * _flangeIntensity; } } for (int s = 0; s < PACKET_LENGTH_SAMPLES_PER_CHANNEL; s++) { int leftSample = ringBuffer->getNextOutput()[s]; int rightSample = ringBuffer->getNextOutput()[s + PACKET_LENGTH_SAMPLES_PER_CHANNEL]; if (_samplesLeftForFlange > 0) { float exponent = (SAMPLE_RATE - _samplesLeftForFlange - (SAMPLE_RATE / _flangeRate)) / (SAMPLE_RATE / _flangeRate); int sampleFlangeDelay = (SAMPLE_RATE / (1000 * _flangeIntensity)) * powf(2, exponent); if (_samplesLeftForFlange != SAMPLE_RATE || s >= (SAMPLE_RATE / 2000)) { // we have a delayed sample to add to this sample int16_t *flangeFrame = ringBuffer->getNextOutput(); int flangeIndex = s - sampleFlangeDelay; if (flangeIndex < 0) { // we need to grab the flange sample from earlier in the buffer flangeFrame = ringBuffer->getNextOutput() != ringBuffer->getBuffer() ? ringBuffer->getNextOutput() - PACKET_LENGTH_SAMPLES : ringBuffer->getNextOutput() + RING_BUFFER_LENGTH_SAMPLES - PACKET_LENGTH_SAMPLES; flangeIndex = PACKET_LENGTH_SAMPLES_PER_CHANNEL + (s - sampleFlangeDelay); } int16_t leftFlangeSample = flangeFrame[flangeIndex]; int16_t rightFlangeSample = flangeFrame[flangeIndex + PACKET_LENGTH_SAMPLES_PER_CHANNEL]; leftSample = (1 - _flangeWeight) * leftSample + (_flangeWeight * leftFlangeSample); rightSample = (1 - _flangeWeight) * rightSample + (_flangeWeight * rightFlangeSample); _samplesLeftForFlange--; if (_samplesLeftForFlange == 0) { _lastYawMeasuredMaximum = 0; } } } #ifndef TEST_AUDIO_LOOPBACK outputLeft[s] = leftSample; outputRight[s] = rightSample; #else outputLeft[s] = inputLeft[s]; outputRight[s] = inputLeft[s]; #endif } ringBuffer->setNextOutput(ringBuffer->getNextOutput() + PACKET_LENGTH_SAMPLES); if (ringBuffer->getNextOutput() == ringBuffer->getBuffer() + RING_BUFFER_LENGTH_SAMPLES) { ringBuffer->setNextOutput(ringBuffer->getBuffer()); } } } eventuallySendRecvPing(inputLeft, outputLeft, outputRight); // add output (@speakers) data just written to the scope _scope->addSamples(1, outputLeft, BUFFER_LENGTH_SAMPLES_PER_CHANNEL); _scope->addSamples(2, outputRight, BUFFER_LENGTH_SAMPLES_PER_CHANNEL); gettimeofday(&_lastCallbackTime, NULL); }
float Vec2i::length() const { return sqrtf(powf((float)x_, 2.0f) + powf((float)y_, 2.0f)); }
float Vec2i::distancef(int x, int y) const { return sqrtf(powf(((float)x_-(float)x), 2.0f) + pow(((float)y_-(float)y), 2.0f)); }
void commit_params (dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece) { dt_iop_profilegamma_params_t *p = (dt_iop_profilegamma_params_t *)p1; dt_iop_profilegamma_data_t *d = (dt_iop_profilegamma_data_t *)piece->data; const float linear = p->linear; const float gamma = p->gamma; d->linear = p->linear; d->gamma = p->gamma; float a, b, c, g; if(gamma == 1.0) { #ifdef _OPENMP #pragma omp parallel for default(none) shared(d) schedule(static) #endif for(int k=0; k<0x10000; k++) d->table[k] = 1.0*k/0x10000; } else { if(linear == 0.0) { #ifdef _OPENMP #pragma omp parallel for default(none) shared(d) schedule(static) #endif for(int k=0; k<0x10000; k++) d->table[k] = powf(1.00*k/0x10000, gamma); } else { if(linear<1.0) { g = gamma*(1.0-linear)/(1.0-gamma*linear); a = 1.0/(1.0+linear*(g-1)); b = linear*(g-1)*a; c = powf(a*linear+b, g)/linear; } else { a = b = g = 0.0; c = 1.0; } #ifdef _OPENMP #pragma omp parallel for default(none) shared(d,a,b,c,g) schedule(static) #endif for(int k=0; k<0x10000; k++) { float tmp; if (k<0x10000*linear) tmp = c*k/0x10000; else tmp = powf(a*k/0x10000+b, g); d->table[k] = tmp; } } } // now the extrapolation stuff: const float x[4] = {0.7f, 0.8f, 0.9f, 1.0f}; const float y[4] = {d->table[CLAMP((int)(x[0]*0x10000ul), 0, 0xffff)], d->table[CLAMP((int)(x[1]*0x10000ul), 0, 0xffff)], d->table[CLAMP((int)(x[2]*0x10000ul), 0, 0xffff)], d->table[CLAMP((int)(x[3]*0x10000ul), 0, 0xffff)] }; dt_iop_estimate_exp(x, y, 4, d->unbounded_coeffs); }
float discreteTimeConstantForSampleRate(float timeConstant, float sampleRate) { // hardcoded value is temporary build fix for Windows. // FIXME: replace hardcode 2.718282 with M_E until the correct MathExtras.h solution is determined. return 1 - powf(1 / 2.718282f, 1 / (sampleRate * timeConstant)); }
float bsd_pow10f(float x) { return powf(10.f, x); }
static int rule_goal_avoid(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa) { BoidRuleGoalAvoid *gabr = (BoidRuleGoalAvoid*) rule; BoidSettings *boids = bbd->part->boids; BoidParticle *bpa = pa->boid; EffectedPoint epoint; ListBase *effectors = bbd->sim->psys->effectors; EffectorCache *cur, *eff = NULL; EffectorCache temp_eff; EffectorData efd, cur_efd; float mul = (rule->type == eBoidRuleType_Avoid ? 1.0 : -1.0); float priority = 0.0f, len = 0.0f; int ret = 0; pd_point_from_particle(bbd->sim, pa, &pa->state, &epoint); /* first find out goal/predator with highest priority */ if(effectors) for(cur = effectors->first; cur; cur=cur->next) { Object *eob = cur->ob; PartDeflect *pd = cur->pd; if(gabr->ob && (rule->type != eBoidRuleType_Goal || gabr->ob != bpa->ground)) { if(gabr->ob == eob) { /* TODO: effectors with multiple points */ if(get_effector_data(cur, &efd, &epoint, 0)) { if(cur->pd && cur->pd->forcefield == PFIELD_BOID) priority = mul * pd->f_strength * effector_falloff(cur, &efd, &epoint, bbd->part->effector_weights); else priority = 1.0; eff = cur; } break; } } else if(rule->type == eBoidRuleType_Goal && eob == bpa->ground) ; /* skip current object */ else if(pd->forcefield == PFIELD_BOID && mul * pd->f_strength > 0.0f && get_effector_data(cur, &cur_efd, &epoint, 0)) { float temp = mul * pd->f_strength * effector_falloff(cur, &cur_efd, &epoint, bbd->part->effector_weights); if(temp == 0.0f) ; /* do nothing */ else if(temp > priority) { priority = temp; eff = cur; efd = cur_efd; len = efd.distance; } /* choose closest object with same priority */ else if(temp == priority && efd.distance < len) { eff = cur; efd = cur_efd; len = efd.distance; } } } /* if the object doesn't have effector data we have to fake it */ if(eff == NULL && gabr->ob) { memset(&temp_eff, 0, sizeof(EffectorCache)); temp_eff.ob = gabr->ob; temp_eff.scene = bbd->sim->scene; eff = &temp_eff; get_effector_data(eff, &efd, &epoint, 0); priority = 1.0f; } /* then use that effector */ if(priority > (rule->type==eBoidRuleType_Avoid ? gabr->fear_factor : 0.0f)) { /* with avoid, factor is "fear factor" */ Object *eob = eff->ob; PartDeflect *pd = eff->pd; float surface = (pd && pd->shape == PFIELD_SHAPE_SURFACE) ? 1.0f : 0.0f; if(gabr->options & BRULE_GOAL_AVOID_PREDICT) { /* estimate future location of target */ get_effector_data(eff, &efd, &epoint, 1); mul_v3_fl(efd.vel, efd.distance / (val->max_speed * bbd->timestep)); add_v3_v3(efd.loc, efd.vel); sub_v3_v3v3(efd.vec_to_point, pa->prev_state.co, efd.loc); efd.distance = len_v3(efd.vec_to_point); } if(rule->type == eBoidRuleType_Goal && boids->options & BOID_ALLOW_CLIMB && surface!=0.0f) { if(!bbd->goal_ob || bbd->goal_priority < priority) { bbd->goal_ob = eob; copy_v3_v3(bbd->goal_co, efd.loc); copy_v3_v3(bbd->goal_nor, efd.nor); } } else if(rule->type == eBoidRuleType_Avoid && bpa->data.mode == eBoidMode_Climbing && priority > 2.0f * gabr->fear_factor) { /* detach from surface and try to fly away from danger */ negate_v3_v3(efd.vec_to_point, bpa->gravity); } copy_v3_v3(bbd->wanted_co, efd.vec_to_point); mul_v3_fl(bbd->wanted_co, mul); bbd->wanted_speed = val->max_speed * priority; /* with goals factor is approach velocity factor */ if(rule->type == eBoidRuleType_Goal && boids->landing_smoothness > 0.0f) { float len2 = 2.0f*len_v3(pa->prev_state.vel); surface *= pa->size * boids->height; if(len2 > 0.0f && efd.distance - surface < len2) { len2 = (efd.distance - surface)/len2; bbd->wanted_speed *= powf(len2, boids->landing_smoothness); } } ret = 1; } return ret; }
void Functions::pow(Aurora::NWScript::FunctionContext &ctx) { ctx.getReturn() = powf(ctx.getParams()[0].getFloat(), ctx.getParams()[1].getFloat()); }
/* Evaluate spline IK for a given bone */ static void splineik_evaluate_bone(tSplineIK_Tree *tree, Scene *scene, Object *ob, bPoseChannel *pchan, int index, float ctime) { bSplineIKConstraint *ikData = tree->ikData; float poseHead[3], poseTail[3], poseMat[4][4]; float splineVec[3], scaleFac, radius = 1.0f; /* firstly, calculate the bone matrix the standard way, since this is needed for roll control */ BKE_pose_where_is_bone(scene, ob, pchan, ctime, 1); copy_v3_v3(poseHead, pchan->pose_head); copy_v3_v3(poseTail, pchan->pose_tail); /* step 1: determine the positions for the endpoints of the bone */ { float vec[4], dir[3], rad; float tailBlendFac = 1.0f; /* determine if the bone should still be affected by SplineIK */ if (tree->points[index + 1] >= 1.0f) { /* spline doesn't affect the bone anymore, so done... */ pchan->flag |= POSE_DONE; return; } else if ((tree->points[index] >= 1.0f) && (tree->points[index + 1] < 1.0f)) { /* blending factor depends on the amount of the bone still left on the chain */ tailBlendFac = (1.0f - tree->points[index + 1]) / (tree->points[index] - tree->points[index + 1]); } /* tail endpoint */ if (where_on_path(ikData->tar, tree->points[index], vec, dir, NULL, &rad, NULL)) { /* apply curve's object-mode transforms to the position * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root) */ if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0) mul_m4_v3(ikData->tar->obmat, vec); /* convert the position to pose-space, then store it */ mul_m4_v3(ob->imat, vec); interp_v3_v3v3(poseTail, pchan->pose_tail, vec, tailBlendFac); /* set the new radius */ radius = rad; } /* head endpoint */ if (where_on_path(ikData->tar, tree->points[index + 1], vec, dir, NULL, &rad, NULL)) { /* apply curve's object-mode transforms to the position * unless the option to allow curve to be positioned elsewhere is activated (i.e. no root) */ if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) == 0) mul_m4_v3(ikData->tar->obmat, vec); /* store the position, and convert it to pose space */ mul_m4_v3(ob->imat, vec); copy_v3_v3(poseHead, vec); /* set the new radius (it should be the average value) */ radius = (radius + rad) / 2; } } /* step 2: determine the implied transform from these endpoints * - splineVec: the vector direction that the spline applies on the bone * - scaleFac: the factor that the bone length is scaled by to get the desired amount */ sub_v3_v3v3(splineVec, poseTail, poseHead); scaleFac = len_v3(splineVec) / pchan->bone->length; /* step 3: compute the shortest rotation needed to map from the bone rotation to the current axis * - this uses the same method as is used for the Damped Track Constraint (see the code there for details) */ { float dmat[3][3], rmat[3][3], tmat[3][3]; float raxis[3], rangle; /* compute the raw rotation matrix from the bone's current matrix by extracting only the * orientation-relevant axes, and normalizing them */ copy_v3_v3(rmat[0], pchan->pose_mat[0]); copy_v3_v3(rmat[1], pchan->pose_mat[1]); copy_v3_v3(rmat[2], pchan->pose_mat[2]); normalize_m3(rmat); /* also, normalize the orientation imposed by the bone, now that we've extracted the scale factor */ normalize_v3(splineVec); /* calculate smallest axis-angle rotation necessary for getting from the * current orientation of the bone, to the spline-imposed direction */ cross_v3_v3v3(raxis, rmat[1], splineVec); rangle = dot_v3v3(rmat[1], splineVec); CLAMP(rangle, -1.0f, 1.0f); rangle = acosf(rangle); /* multiply the magnitude of the angle by the influence of the constraint to * control the influence of the SplineIK effect */ rangle *= tree->con->enforce; /* construct rotation matrix from the axis-angle rotation found above * - this call takes care to make sure that the axis provided is a unit vector first */ axis_angle_to_mat3(dmat, raxis, rangle); /* combine these rotations so that the y-axis of the bone is now aligned as the spline dictates, * while still maintaining roll control from the existing bone animation */ mul_m3_m3m3(tmat, dmat, rmat); /* m1, m3, m2 */ normalize_m3(tmat); /* attempt to reduce shearing, though I doubt this'll really help too much now... */ copy_m4_m3(poseMat, tmat); } /* step 4: set the scaling factors for the axes */ { /* only multiply the y-axis by the scaling factor to get nice volume-preservation */ mul_v3_fl(poseMat[1], scaleFac); /* set the scaling factors of the x and z axes from... */ switch (ikData->xzScaleMode) { case CONSTRAINT_SPLINEIK_XZS_ORIGINAL: { /* original scales get used */ float scale; /* x-axis scale */ scale = len_v3(pchan->pose_mat[0]); mul_v3_fl(poseMat[0], scale); /* z-axis scale */ scale = len_v3(pchan->pose_mat[2]); mul_v3_fl(poseMat[2], scale); break; } case CONSTRAINT_SPLINEIK_XZS_INVERSE: { /* old 'volume preservation' method using the inverse scale */ float scale; /* calculate volume preservation factor which is * basically the inverse of the y-scaling factor */ if (fabsf(scaleFac) != 0.0f) { scale = 1.0f / fabsf(scaleFac); /* we need to clamp this within sensible values */ /* NOTE: these should be fine for now, but should get sanitised in future */ CLAMP(scale, 0.0001f, 100000.0f); } else scale = 1.0f; /* apply the scaling */ mul_v3_fl(poseMat[0], scale); mul_v3_fl(poseMat[2], scale); break; } case CONSTRAINT_SPLINEIK_XZS_VOLUMETRIC: { /* improved volume preservation based on the Stretch To constraint */ float final_scale; /* as the basis for volume preservation, we use the inverse scale factor... */ if (fabsf(scaleFac) != 0.0f) { /* NOTE: The method here is taken wholesale from the Stretch To constraint */ float bulge = powf(1.0f / fabsf(scaleFac), ikData->bulge); if (bulge > 1.0f) { if (ikData->flag & CONSTRAINT_SPLINEIK_USE_BULGE_MAX) { float bulge_max = max_ff(ikData->bulge_max, 1.0f); float hard = min_ff(bulge, bulge_max); float range = bulge_max - 1.0f; float scale = (range > 0.0f) ? 1.0f / range : 0.0f; float soft = 1.0f + range * atanf((bulge - 1.0f) * scale) / (float)M_PI_2; bulge = interpf(soft, hard, ikData->bulge_smooth); } } if (bulge < 1.0f) { if (ikData->flag & CONSTRAINT_SPLINEIK_USE_BULGE_MIN) { float bulge_min = CLAMPIS(ikData->bulge_min, 0.0f, 1.0f); float hard = max_ff(bulge, bulge_min); float range = 1.0f - bulge_min; float scale = (range > 0.0f) ? 1.0f / range : 0.0f; float soft = 1.0f - range * atanf((1.0f - bulge) * scale) / (float)M_PI_2; bulge = interpf(soft, hard, ikData->bulge_smooth); } } /* compute scale factor for xz axes from this value */ final_scale = sqrtf(bulge); } else { /* no scaling, so scale factor is simple */ final_scale = 1.0f; } /* apply the scaling (assuming normalised scale) */ mul_v3_fl(poseMat[0], final_scale); mul_v3_fl(poseMat[2], final_scale); break; } } /* finally, multiply the x and z scaling by the radius of the curve too, * to allow automatic scales to get tweaked still */ if ((ikData->flag & CONSTRAINT_SPLINEIK_NO_CURVERAD) == 0) { mul_v3_fl(poseMat[0], radius); mul_v3_fl(poseMat[2], radius); } } /* step 5: set the location of the bone in the matrix */ if (ikData->flag & CONSTRAINT_SPLINEIK_NO_ROOT) { /* when the 'no-root' option is affected, the chain can retain * the shape but be moved elsewhere */ copy_v3_v3(poseHead, pchan->pose_head); } else if (tree->con->enforce < 1.0f) { /* when the influence is too low * - blend the positions for the 'root' bone * - stick to the parent for any other */ if (pchan->parent) { copy_v3_v3(poseHead, pchan->pose_head); } else { /* FIXME: this introduces popping artifacts when we reach 0.0 */ interp_v3_v3v3(poseHead, pchan->pose_head, poseHead, tree->con->enforce); } } copy_v3_v3(poseMat[3], poseHead); /* finally, store the new transform */ copy_m4_m4(pchan->pose_mat, poseMat); copy_v3_v3(pchan->pose_head, poseHead); /* recalculate tail, as it's now outdated after the head gets adjusted above! */ BKE_pose_where_is_bone_tail(pchan); /* done! */ pchan->flag |= POSE_DONE; }
void Valve::processReplacing (float **inputs, float **outputs, int sampleFrames) { int i; float l, r, lout, rout, fx; param->PERIOD = sampleFrames; param->fPERIOD = param->PERIOD; if (Pstereo != 0) { //Stereo for (i = 0; i < param->PERIOD; i++) { outputs[0][i] = inputs[0][i] * inputvol; outputs[1][i] = inputs[1][i] * inputvol; }; } else { for (i = 0; i < param->PERIOD; i++) { outputs[0][i] = (inputs[0][i] + inputs[1][i] ) * inputvol; }; }; harm->harm_out(outputs[0],outputs[1]); if (Pprefiltering != 0) applyfilters (outputs[0], outputs[1]); if(Ped) { for (i =0; i<param->PERIOD; i++) { outputs[0][i]=Wshape(outputs[0][i]); if (Pstereo != 0) outputs[1][i]=Wshape(outputs[1][i]); } } for (i =0; i<param->PERIOD; i++) { //soft limiting to 3.0 (max) fx = outputs[0][i]; if (fx>1.0f) fx = 3.0f - 2.0f/sqrtf(fx); outputs[0][i] = fx; fx = outputs[1][i]; if (fx>1.0f) fx = 3.0f - 2.0f/sqrtf(fx); outputs[1][i] = fx; } if (q == 0.0f) { for (i =0; i<param->PERIOD; i++) { if (outputs[0][i] == q) fx = fdist; else fx =outputs[0][i] / (1.0f - powf(2.0f,-dist * outputs[0][i] )); otml = atk * otml + fx - itml; itml = fx; outputs[0][i]= otml; } } else { for (i = 0; i < param->PERIOD; i++) { if (outputs[0][i] == q) fx = fdist + qcoef; else fx =(outputs[0][i] - q) / (1.0f - powf(2.0f,-dist * (outputs[0][i] - q))) + qcoef; otml = atk * otml + fx - itml; itml = fx; outputs[0][i]= otml; } } if (Pstereo != 0) { if (q == 0.0f) { for (i =0; i<param->PERIOD; i++) { if (outputs[1][i] == q) fx = fdist; else fx = outputs[1][i] / (1.0f - powf(2.0f,-dist * outputs[1][i] )); otmr = atk * otmr + fx - itmr; itmr = fx; outputs[1][i]= otmr; } } else { for (i = 0; i < param->PERIOD; i++) { if (outputs[1][i] == q) fx = fdist + qcoef; else fx = (outputs[1][i] - q) / (1.0f - powf(2.0f,-dist * (outputs[1][i] - q))) + qcoef; otmr = atk * otmr + fx - itmr; itmr = fx; outputs[1][i]= otmr; } } } if (Pprefiltering == 0) applyfilters (outputs[0], outputs[1]); if (Pstereo == 0) memcpy (outputs[1] , outputs[0], param->PERIOD * sizeof(float)); float level = dB2rap (60.0f * (float)Plevel / 127.0f - 40.0f); for (i = 0; i < param->PERIOD; i++) { lout = outputs[0][i]; rout = outputs[1][i]; l = lout * (1.0f - lrcross) + rout * lrcross; r = rout * (1.0f - lrcross) + lout * lrcross; lout = l; rout = r; outputs[0][i] = lout * 2.0f * level * panning; outputs[1][i] = rout * 2.0f * level * (1.0f -panning); }; };
static inline float floatToFrequency(float value) { if (value > 0.97f) return MAXFREQ; if (value < 0.03f) return MINFREQ; value = powf(10.0f, (value + ((0.4f - fabsf(value - 0.4f)) * 0.3f)) * log10f(MAXFREQ - MINFREQ)) + MINFREQ; return value < MAXFREQ ? value : MAXFREQ; }
void CCEaseOut::update(float time) { m_pOther->update(powf(time, 1 / m_fRate)); }
//this gets called when the object is created; everytime the user types in new args, this will get called void *curvesmooth_new(t_symbol *s, long argc, t_atom *argv) { int i, j; long upsmooth; // in ms long downsmooth; // in ms double upcoeff; double downcoeff; // deal with incoming values if (argc > 0) { upsmooth = atom_getlong(argv); } else { upsmooth = 0; } if (argc > 1) { downsmooth = atom_getlong(argv+1); } else { downsmooth = 0; } if (argc > 2) { upcoeff = atom_getfloat(argv+2); } else { upcoeff = 0; } if (argc > 3) { downcoeff = atom_getfloat(argv+3); } else { downcoeff = 0; } // post("us: %ld, ds: %ld, uc: %f, dc: %f", upsmooth, downsmooth, upcoeff, downcoeff); //leave this; creates our object t_curvesmooth *x = (t_curvesmooth *)object_alloc(curvesmooth_class); //zero out the struct, to be careful (takk to jkclayton) if (x) { for(i=sizeof(t_pxobject);i<sizeof(t_curvesmooth);i++) { ((char *)x)[i]=0; } x->num_inputs = 5; x->num_outputs = 1; //setup up inputs and outputs, for audio //inputs dsp_setup((t_pxobject *)x, x->num_inputs); //if you just need one input for message (not using audio), you can just set num_inputs = 1 //i don't think this causes a performance hit. //outputs for (i=0;i<x->num_outputs;i++) { outlet_new((t_object *)x, "signal"); } //can use intin, floatout, listout, etc... for setting up non-audio ins and outs. //but, the order in which you call these funcs is important. //for instance, from gQ~ /* x->outfloat = floatout((t_object *)x); x->outlist = listout((t_object *)x); outlet_new((t_object *)x, "signal"); outlet_new((t_object *)x, "signal"); */ //this will create four outputs, *rightmost* created first, so the outlets, from left to right, will look like //(signal) (signal) (list) (float) //when you instantiate gQ~ in Max/MSP. //initialize some variables; important to do this! for (i=0;i<x->num_inputs;i++){ x->in[i] = 0.; x->in_connected[i] = 0; } x->power = 1; x->in[1] = (double)upsmooth; x->in[2] = (double)downsmooth; x->in[3] = (double)upcoeff; x->in[4] = (double)downcoeff; x->c = 0.; x->update_D = 1; x->current_direction = 1; x->D = 0.; //lookup table alloc and init for(i=0;i<TABLE_SIZE;i++) { //x->s_table_k_exp[i]= t_getbytes(TABLE_SIZE*sizeof(double)); x->s_table_k_exp[i]= (double *)sysmem_newptr(TABLE_SIZE*sizeof(double)); if (!x->s_table_k_exp[i]) { error("curvesmooth~: out of memory"); return NULL; } //x->s_table_k_log[i] = t_getbytes(TABLE_SIZE*sizeof(double)); x->s_table_k_log[i] = (double *)sysmem_newptr(TABLE_SIZE*sizeof(double)); if (!x->s_table_k_log[i]) { error("curvesmooth~: out of memory"); return NULL; } } for(i=2;i<TABLE_SIZE;i++) { //k, indices 2 to 1000 (exp) and 1 to 1000 (log, so .001 to 1, though we should never use 1) for(j=1;j<TABLE_SIZE;j++) { //d or d/D, 0 to 1 x->s_table_k_exp[i][j] = (i-1.) / ((powf(i, j*.001) - 1.)); x->s_table_k_log[i-1][j] = ((i-1.)*.001 - 1.) / ((powf((i-1.)*.001, j*.001) - 1.)); } x->s_table_k_exp[i][0] = 0.; x->s_table_k_log[i][0] = 0.; } //occasionally this line is necessary if you are doing weird asynchronous things with the in/out vectors //x->x_obj.z_misc = Z_NO_INPLACE; } return (x); }
void CCEaseExponentialOut::update(float time) { m_pOther->update(time == 1 ? 1 : (-powf(2, -10 * time / 1) + 1)); }
/***************************************************************************** * VideoGetBuffer: Build an alternate video buffer *****************************************************************************/ static block_t *VideoGetBuffer( sout_stream_t *p_stream, sout_stream_id_t *id, block_t *p_buffer ) { sout_stream_sys_t *p_sys = p_stream->p_sys; int i_out; block_t *p_out; id->p_frame->quality = p_sys->i_qscale * powf(2.0, FF_LAMBDA_SHIFT + 7.0) / 139.0; id->p_frame->interlaced_frame = 0; id->p_frame->top_field_first = 1; id->p_frame->pts = p_buffer->i_dts; if ( id->i_nb_pred >= p_sys->i_gop ) { id->p_frame->pict_type = AV_PICTURE_TYPE_I; #if 0 id->p_frame->me_threshold = 0; id->p_frame->mb_threshold = 0; #endif id->i_nb_pred = 0; } else { id->p_frame->pict_type = AV_PICTURE_TYPE_P; #if 0 if ( id->p_frame->mb_type != NULL ) { id->p_frame->me_threshold = MAX_THRESHOLD; id->p_frame->mb_threshold = MAX_THRESHOLD; } #endif id->i_nb_pred++; } i_out = avcodec_encode_video( id->ff_enc_c, id->p_buffer_out, id->ff_enc_c->width * id->ff_enc_c->height * 3, id->p_frame ); if ( i_out <= 0 ) return NULL; #if 0 if ( id->p_frame->mb_type == NULL && id->ff_enc_c->coded_frame->pict_type != AV_PICTURE_TYPE_I ) { int mb_width = (id->ff_enc_c->width + 15) / 16; int mb_height = (id->ff_enc_c->height + 15) / 16; int h_chroma_shift, v_chroma_shift; int i; avcodec_get_chroma_sub_sample( id->ff_enc_c->pix_fmt, &h_chroma_shift, &v_chroma_shift ); id->p_frame->motion_subsample_log2 = id->ff_enc_c->coded_frame->motion_subsample_log2; id->p_frame->mb_type = malloc( ((mb_width + 1) * (mb_height + 1) + 1) * sizeof(uint32_t) ); memcpy( id->p_frame->mb_type, id->ff_enc_c->coded_frame->mb_type, (mb_width + 1) * mb_height * sizeof(id->p_frame->mb_type[0])); for ( i = 0; i < 2; i++ ) { int stride = ((16 * mb_width ) >> id->ff_enc_c->coded_frame->motion_subsample_log2) + 1; int height = ((16 * mb_height) >> id->ff_enc_c->coded_frame->motion_subsample_log2); int b8_stride = mb_width * 2 + 1; if ( id->ff_enc_c->coded_frame->motion_val[i] ) { id->p_frame->motion_val[i] = malloc( 2 * stride * height * sizeof(int16_t) ); memcpy( id->p_frame->motion_val[i], id->ff_enc_c->coded_frame->motion_val[i], 2 * stride * height * sizeof(int16_t) ); } if ( id->ff_enc_c->coded_frame->ref_index[i] ) { id->p_frame->ref_index[i] = malloc( b8_stride * 2 * mb_height * sizeof(int8_t) ); memcpy( id->p_frame->ref_index[i], id->ff_enc_c->coded_frame->ref_index[i], b8_stride * 2 * mb_height * sizeof(int8_t)); } } }
/* ================= CL_MouseMove ================= */ void CL_MouseMove(usercmd_t *cmd) { float mx, my; if (m_filter->integer) { mx = (cl.mouseDx[0] + cl.mouseDx[1]) * 0.5f; my = (cl.mouseDy[0] + cl.mouseDy[1]) * 0.5f; } else { mx = cl.mouseDx[cl.mouseIndex]; my = cl.mouseDy[cl.mouseIndex]; } cl.mouseIndex ^= 1; cl.mouseDx[cl.mouseIndex] = 0; cl.mouseDy[cl.mouseIndex] = 0; if (mx == 0.0f && my == 0.0f) return; if (cl_mouseAccel->value != 0.0f) { if(cl_mouseAccelStyle->integer == 0) { float accelSensitivity; float rate; rate = sqrt(mx * mx + my * my) / (float) frame_msec; accelSensitivity = cl_sensitivity->value + rate * cl_mouseAccel->value; mx *= accelSensitivity; my *= accelSensitivity; if(cl_showMouseRate->integer) Com_Printf("rate: %f, accelSensitivity: %f\n", rate, accelSensitivity); } else { float rate[2]; float power[2]; // sensitivity remains pretty much unchanged at low speeds // cl_mouseAccel is a power value to how the acceleration is shaped // cl_mouseAccelOffset is the rate for which the acceleration will have doubled the non accelerated amplification // NOTE: decouple the config cvars for independent acceleration setup along X and Y? rate[0] = fabs(mx) / (float) frame_msec; rate[1] = fabs(my) / (float) frame_msec; power[0] = powf(rate[0] / cl_mouseAccelOffset->value, cl_mouseAccel->value); power[1] = powf(rate[1] / cl_mouseAccelOffset->value, cl_mouseAccel->value); mx = cl_sensitivity->value * (mx + ((mx < 0) ? -power[0] : power[0]) * cl_mouseAccelOffset->value); my = cl_sensitivity->value * (my + ((my < 0) ? -power[1] : power[1]) * cl_mouseAccelOffset->value); if(cl_showMouseRate->integer) Com_Printf("ratex: %f, ratey: %f, powx: %f, powy: %f\n", rate[0], rate[1], power[0], power[1]); } } else { mx *= cl_sensitivity->value; my *= cl_sensitivity->value; } // ingame FOV mx *= cl.cgameSensitivity; my *= cl.cgameSensitivity; // add mouse X/Y movement to cmd if(in_strafe.active) cmd->rightmove = ClampChar(cmd->rightmove + m_side->value * mx); else cl.viewangles[YAW] -= m_yaw->value * mx; if ((in_mlooking || cl_freelook->integer) && !in_strafe.active) cl.viewangles[PITCH] += m_pitch->value * my; else cmd->forwardmove = ClampChar(cmd->forwardmove - m_forward->value * my); }
void drawTriangleToRaster(OWRaster *raster, OWTriangle& triangle, OWMaterial material, OWScene scene, bool phong, OWVector4* camPosition) { OWColorFloat* fillcolorF = material.color; unsigned rasterHeight = raster->getHeight(); unsigned rasterWidth = raster->getWidth(); float lambda1; float lambda2; float lambda3; float zDepth; lambda1=lambda3=lambda2=0.0f; float zb1=triangle.zBuffer[0]; float zb2=triangle.zBuffer[1]; float zb3=triangle.zBuffer[2]; float xLength = scene.maxX - scene.minX; float yLength = scene.maxY - scene.minY; float x1,x2,x3,y1,y2,y3,z1,z2,z3; x1 = triangle.getVec1().getX(); x2 = triangle.getVec2().getX(); x3 = triangle.getVec3().getX(); y1 = triangle.getVec1().getY(); y2 = triangle.getVec2().getY(); y3 = triangle.getVec3().getY(); z1 = triangle.getVec1().getZ(); z2 = triangle.getVec2().getZ(); z3 = triangle.getVec3().getZ(); float maxTX=fminf(scene.maxX,fmaxf(x1, fmaxf(x2, x3))); float maxTY=fminf(scene.maxY,fmaxf(y1, fmaxf(y2, y3))); float minTX=fmaxf(scene.minX,fminf(x1, fminf(x2, x3))); float minTY=fmaxf(scene.minY,fminf(y1, fminf(y2, y3))); unsigned maxRX = ceilf(fminf(rasterWidth, (maxTX - scene.minX)/xLength*(float)rasterWidth)); unsigned minRX = floorf(fmaxf(0.0f, (minTX - scene.minX)/xLength*(float)rasterWidth)); unsigned maxRY = ceilf(fminf(rasterWidth, (maxTY - scene.minY)/yLength*(float)rasterHeight)); unsigned minRY = floorf(fmaxf(0.0f, (minTY - scene.minY)/yLength*(float)rasterHeight)); if (maxRX > rasterWidth) { printf("raster x max bound error.\n"); //system("pause"); maxRX = rasterWidth; } if (maxRY > rasterHeight) { printf("raster y max bound error.\n"); //system("pause"); maxRY = rasterHeight; } for (unsigned y=minRY; y<maxRY; y++) { for (unsigned x=minRX; x<maxRX; x++) { float fx=((float)x/(float)rasterWidth) * xLength+scene.minX; float fy=((float)y/(float)rasterHeight)* yLength+scene.minY; calculateTriBarycentricCoordinates(triangle, fx, fy, &lambda1, &lambda2, &lambda3); zDepth = zb1*lambda1 + zb2*lambda2 + zb3*lambda3; if( lambda1 >= 0.0f && lambda2 >= 0.0f && lambda3 >= 0.0f //&& (lambda1 <= 0.02f || lambda2 <= 0.02f || lambda3 <= 0.02f) && raster->z_buffer[x + y * rasterWidth] > zDepth //lambda1 <= 1.0f && lambda2 <= 1.0f && lambda3 <= 1.0f ) { raster->z_buffer[x + y * rasterWidth] = zDepth; OWColorChannelFloat red,green,blue; red = fillcolorF[0].r * lambda1 + fillcolorF[1].r * lambda2 + fillcolorF[2].r * lambda3; green = fillcolorF[0].g * lambda1 + fillcolorF[1].g * lambda2 + fillcolorF[2].g * lambda3; blue = fillcolorF[0].b * lambda1 + fillcolorF[1].b * lambda2 + fillcolorF[2].b * lambda3; if (phong == true) { /***Phong Mode*************************************************************************************/ for (list<OWLight>::iterator iterLight = scene.lightList.begin(); iterLight != scene.lightList.end(); iterLight++) { OWVector4* currVector = new OWVector4; OWVector4* n = new OWVector4; currVector->setX(triangle.worldCoorVec[0].getX() * lambda1 + triangle.worldCoorVec[1].getX() * lambda2 + triangle.worldCoorVec[2].getX() * lambda3); currVector->setY(triangle.worldCoorVec[0].getY() * lambda1 + triangle.worldCoorVec[1].getY() * lambda2 + triangle.worldCoorVec[2].getY() * lambda3); currVector->setZ(triangle.worldCoorVec[0].getZ() * lambda1 + triangle.worldCoorVec[1].getZ() * lambda2 + triangle.worldCoorVec[2].getZ() * lambda3); for (int i=0; i<3; i++) { triangle.norVec[i].normalise(); } n->setX(triangle.norVec[0].getX() * lambda1 + triangle.norVec[1].getX() * lambda2 + triangle.norVec[2].getX() * lambda3); n->setY(triangle.norVec[0].getY() * lambda1 + triangle.norVec[1].getY() * lambda2 + triangle.norVec[2].getY() * lambda3); n->setZ(triangle.norVec[0].getZ() * lambda1 + triangle.norVec[1].getZ() * lambda2 + triangle.norVec[2].getZ() * lambda3); OWVector4* l = vectorSubtract((*iterLight).myPosition, currVector); l->normalise(); n->normalise(); float l_dot_n = l->dotProduct(*n); float diffContr = fmaxf(0.0f, l_dot_n); n->scale(2*l_dot_n); OWVector4* r = vectorSubtract(n,l); OWVector4* v = vectorSubtract(camPosition, currVector); r->normalise(); v->normalise(); OWColorFloat Idif; if (diffContr < 0.0f) { diffContr = 0.0f; } Idif.a=1.0f; Idif.r=(*iterLight).myColor.r * red * diffContr; Idif.g=(*iterLight).myColor.g * green * diffContr; Idif.b=(*iterLight).myColor.b * blue * diffContr; OWColorFloat shininessColor = material.shininessColor; OWColorFloat Ispec; float specContri = powf(v->dotProduct(*r), shininessColor.a); //float specContri = v->dotProduct(*r); if ( l_dot_n >= 0.0f && specContri >= 0.0f ) { Ispec.a = 1.0f; Ispec.r = (*iterLight).myColor.r * shininessColor.r * specContri; Ispec.g = (*iterLight).myColor.g * shininessColor.g * specContri; Ispec.b = (*iterLight).myColor.b * shininessColor.b * specContri; }else{ Ispec.a = 0.0f; Ispec.r = 0.0f; Ispec.g = 0.0f; Ispec.b = 0.0f; } scene.ambient.a = 0.0f; //OWColorFloat tempColor = Idif; //OWColorFloat tempColor = Ispec; //OWColorFloat tempColor = scene.ambient; //OWColorFloat tempColor = colorAdd(Idif, scene.ambient); //OWColorFloat tempColor = colorAdd(Idif, Ispec); OWColorFloat tempColor = colorAdd(Idif, colorAdd(Ispec, scene.ambient)); colorNormalise(tempColor); red = tempColor.r; green = tempColor.g; blue = tempColor.b; } } raster->pixels[x + y * rasterWidth] = drawARGBColorFromFloatColor(red, green, blue); } } } //triangle.printMyself(); }
//----------------------------------------------- // Response curve function for the move axes //----------------------------------------------- static float ResponseCurve( int curve, float x, int axis, float sensitivity ) { switch ( curve ) { case 1: // quadratic if ( x < 0 ) return -(x*x) * sensitivity; return x*x * sensitivity; case 2: // cubic return x*x*x*sensitivity; case 3: { // quadratic extreme float extreme = 1.0f; if ( fabs( x ) >= 0.95f ) { extreme = 1.5f; } if ( x < 0 ) return -extreme * x*x*sensitivity; return extreme * x*x*sensitivity; } case 4: { float flScale = sensitivity < 0.0f ? -1.0f : 1.0f; sensitivity = clamp( fabs( sensitivity ), 1.0e-8f, 1000.0f ); float oneOverSens = 1.0f / sensitivity; if ( x < 0.0f ) { flScale = -flScale; } float retval = clamp( powf( fabs( x ), oneOverSens ), 0.0f, 1.0f ); return retval * flScale; } break; case 5: { float out = x; if( fabs(out) <= 0.6f ) { out *= 0.5f; } out = out * sensitivity; return out; } break; case 6: // Custom for driving a vehicle! { if( axis == YAW ) { // This code only wants to affect YAW axis (the left and right axis), which // is used for turning in the car. We fall-through and use a linear curve on // the PITCH axis, which is the vehicle's throttle. REALLY, these are the 'forward' // and 'side' axes, but we don't have constants for those, so we re-use the same // axis convention as the look stick. (sjb) float sign = 1; if( x < 0.0 ) sign = -1; x = fabs(x); if( x <= joy_vehicle_turn_lowend.GetFloat() ) x = RemapVal( x, 0.0f, joy_vehicle_turn_lowend.GetFloat(), 0.0f, joy_vehicle_turn_lowmap.GetFloat() ); else x = RemapVal( x, joy_vehicle_turn_lowend.GetFloat(), 1.0f, joy_vehicle_turn_lowmap.GetFloat(), 1.0f ); return x * sensitivity * sign; } //else // fall through and just return x*sensitivity below (as if using default curve) } } // linear return x*sensitivity; }
void score_setup() { int i,u; //weight_time_setup(); if(load_model) { fpV=fopen(fnameV,"rb"); fpU=fopen(fnameU,"rb"); if(fpV || fpU) { lg("Loading %s and %s\n",fnameV,fnameU); if(!fpV || !fpU) error("Cant open both files"); } } int day0[NMOVIES]; ZERO(day0); // It is OK to look on all data for day0 because it is always known for(i=0;i<NENTRIES;i++) { int m=userent[i]&USER_MOVIEMASK; int day=userent[i]>>(USER_LMOVIEMASK+3); if(!day0[m] || day0[m]>day) day0[m]=day; } DEVuHat = (float *) malloc(NENTRIES*sizeof(float)); sdbU = (float *) malloc(NENTRIES*sizeof(float)); sdsU = (float *) malloc(((unsigned int)NENTRIES)*((unsigned int)NFEATURES)*sizeof(float)); memset(DEVuHat,0,NENTRIES*sizeof(float)); memset(sdbU,0,NENTRIES*sizeof(float)); memset(sdsU,0,((unsigned int)NENTRIES)*((unsigned int)NFEATURES)*sizeof(float)); ZERO(sdbin); int tcount[100000]; ZERO(tcount); ZERO(avgdate); ZERO(avgdevu); ZERO(ucnt); int j; for(u=0;u<NUSERS;u++) { int base=useridx[u][0]; int d012=UNALL(u); int d0=UNTRAIN(u); // compute explanatory variable for(j=0;j<d012;j++) { int m=userent[base+j]&USER_MOVIEMASK; int day=userent[base+j]>>(USER_LMOVIEMASK+3); if ( day < minday ) minday = day; if ( day > maxday ) maxday = day; //usertime[j]=DTIME(day-day0[m]); if ( day < 0 ) ;//toosmall++; else if ( day < 100000-1 ) tcount[day]++; else ;//toobig++; ucnt[u]++; avgdate[u] += day; } } printf("minday: %d, maxday: %d\n", minday, maxday); fflush(stdout); for(u=0;u<NUSERS;u++) { // 1) Find the average date of rating for every customer. In this step I include the probe dates also in the calculation of the average. avgdate[u] /= ucnt[u]; //printf("U: %d, avgdate: %f, ucnt: %d\n", u, avgdate[u], ucnt[u]); //fflush(stdout); } for(u=0;u<NUSERS;u++) { int base=useridx[u][0]; int d012=UNALL(u); int d0=UNTRAIN(u); int j; for(j=0;j<d012;j++) { int m=userent[base+j]&USER_MOVIEMASK; int day=userent[base+j]>>(USER_LMOVIEMASK+3); //2) For every rating [i] in the data set (including probe) I calculate DEVu[i]: // DEVu[i] = sign(t[i] - t_mean_for_customer) * powf(abs(t[i] - t_mean_for_customer), 0.4); double DEVu = sign(day - avgdate[u]) * powf(abs(day - avgdate[u]), 0.4); avgdevu[u] += DEVu; //printf("U: %d, M: %d, day: %d, uavg: %f, DEVu: %f\n", u, m, day, avgdate[u], DEVu); //fflush(stdout); } } for(u=0;u<NUSERS;u++) { //3) Find the average DEVu[i] for every customer. His/hers probe DEVu[i] values are also included. avgdevu[u] /= ucnt[u]; //printf("U: %d, avgdevu: %f, avgdate: %f, ucnt: %d\n", u, avgdevu[u], avgdate[u], ucnt[u]); //fflush(stdout); } ZERO(maxDEVuHat); for(u=0;u<NUSERS;u++) { int base=useridx[u][0]; int d012=UNALL(u); int d0=UNTRAIN(u); int j; for(j=0;j<d012;j++) { int m=userent[base+j]&USER_MOVIEMASK; int day=userent[base+j]>>(USER_LMOVIEMASK+3); // 2) For every rating [i] in the data set (including probe) I calculate DEVu[i]: // DEVu[i] = sign(t[i] - t_mean_for_customer) * powf(abs(t[i] - t_mean_for_customer), 0.4); double DEVu = sign(day - avgdate[u]) * powf(abs(day - avgdate[u]), 0.4); // 4) Subtract every customer's average DEVu_avg value from every time deviation: // DEVu_hat[i] = DEVu[i] - DEVu_avg_for_customer; double DEVuHat = DEVu - avgdevu[u]; //printf("U: %d, M: %d, ndevu: %f, day: %d, uavg: %f, DEVu: %f\n", u, m, DEVuHat, day, avgdate[u], DEVu); //fflush(stdout); // Get the max absolute value of a user's devu_hat values...maxDevu_hat... double tDEVu = fabs(DEVuHat); if ( tDEVu > maxDEVuHat[u] ) maxDEVuHat[u] = tDEVu; } } // Compute and store DEVuHats and create single day bin numbering per user int daysBinValue[maxday+1]; for(u=0;u<NUSERS;u++) { int base=useridx[u][0]; int d012=UNALL(u); int d0=UNTRAIN(u); int j; ZERO(daysBinValue); int dcount=0; for(j=0;j<d012;j++) { int m=userent[base+j]&USER_MOVIEMASK; int day=userent[base+j]>>(USER_LMOVIEMASK+3); DEVuHat[base+j] = devuHat(day,u); if ( daysBinValue[day] == 0 ) { sdbin[base+j] = base+j; daysBinValue[day] = base+j; if ( daysBinValue[day] > NENTRIES ) { printf("Days bin v: %d\n", daysBinValue[day]); fflush(stdout); } dcount++; } else { if ( daysBinValue[day] > NENTRIES ) { printf("Days bin v: %d\n", daysBinValue[day]); fflush(stdout); } sdbin[base+j] = daysBinValue[day]; } } } //for (i=minday; i < maxday; i++ ) { //printf("day: %d, count: %d\n", i, tcount[i]); //fflush(stdout); //} }