static void PI4D_SetFraction(GF_Node *node, GF_Route *route) { u32 i; Fixed frac; M_PositionInterpolator4D *_this = (M_PositionInterpolator4D *)node; if (! _this->key.count) return; if (_this->keyValue.count != _this->key.count) return; // The given fraction is less than the specified range if (_this->set_fraction < _this->key.vals[0]) { _this->value_changed = _this->keyValue.vals[0]; } else if (_this->set_fraction >= _this->key.vals[_this->key.count-1]) { _this->value_changed = _this->keyValue.vals[_this->keyValue.count-1]; } else { for (i=1; i<_this->key.count; i++) { // Find the key values the fraction lies between if (_this->set_fraction < _this->key.vals[i-1]) continue; if (_this->set_fraction >= _this->key.vals[i]) continue; frac = GetInterpolateFraction(_this->key.vals[i-1], _this->key.vals[i], _this->set_fraction); _this->value_changed.x = Interpolate(_this->keyValue.vals[i-1].x, _this->keyValue.vals[i].x, frac); _this->value_changed.y = Interpolate(_this->keyValue.vals[i-1].y, _this->keyValue.vals[i].y, frac); _this->value_changed.z = Interpolate(_this->keyValue.vals[i-1].z, _this->keyValue.vals[i].z, frac); _this->value_changed.q = Interpolate(_this->keyValue.vals[i-1].q, _this->keyValue.vals[i].q, frac); break; } } gf_node_event_out(node, 3);//"value_changed" }
///========================================================================================================================================== /// Friend Functions ///========================================================================================================================================== inline const AABB3D Interpolate(const AABB3D& start, const AABB3D& end, float fractionFromStartToEnd){ const Vec3 interpolatedMins = Interpolate(start.mins, end.mins, fractionFromStartToEnd); const Vec3 interpolatedMaxs = Interpolate(start.maxs, end.maxs, fractionFromStartToEnd); AABB3D interpolation(interpolatedMins, interpolatedMaxs); return interpolation; }
void CBulletTime::Update() { if (!(g_pGameCVars->bt_speed || g_pGameCVars->bt_ironsight) || gEnv->bMultiplayer) return; // normalized frametime float frameTime = gEnv->pTimer->GetFrameTime(); float normFrameTime = frameTime; float timeScale = gEnv->pTimer->GetTimeScale(); if (timeScale < 1.0f) { timeScale = max(0.0001f, timeScale); normFrameTime = frameTime/timeScale; } if (m_active) { Interpolate(m_energy, 0.0f, g_pGameCVars->bt_energy_decay, normFrameTime); // deactivate when we run out of energy if (m_energy < 0.001f) { Activate(false); } } else { Interpolate(m_energy, g_pGameCVars->bt_energy_max, g_pGameCVars->bt_energy_regen, normFrameTime); } Interpolate(m_timeScaleCurrent, m_timeScaleTarget, 2.0f, normFrameTime); gEnv->pTimer->SetTimeScale(m_timeScaleCurrent); }
void PosInt_SetFraction(SFNode *node) { u32 i; Float frac; M_PositionInterpolator *_this = (M_PositionInterpolator *)node; if (! _this->key.count) return; if (_this->keyValue.count != _this->key.count) return; // The given fraction is less than the specified range if (_this->set_fraction < _this->key.vals[0]) { _this->value_changed = _this->keyValue.vals[0]; } else if (_this->set_fraction >= _this->key.vals[_this->key.count-1]) { _this->value_changed = _this->keyValue.vals[_this->keyValue.count-1]; } else { for (i=1; i<_this->key.count; i++) { // Find the key values the fraction lies between if (_this->set_fraction < _this->key.vals[i-1]) continue; if (_this->set_fraction >= _this->key.vals[i]) continue; frac = GetInterpolateFraction(_this->key.vals[i-1], _this->key.vals[i], _this->set_fraction); _this->value_changed.x = Interpolate(_this->keyValue.vals[i-1].x, _this->keyValue.vals[i].x, frac); _this->value_changed.y = Interpolate(_this->keyValue.vals[i-1].y, _this->keyValue.vals[i].y, frac); _this->value_changed.z = Interpolate(_this->keyValue.vals[i-1].z, _this->keyValue.vals[i].z, frac); break; } } Node_OnEventOutSTR(node, "value_changed"); }
/** This function allows to get the prediction of an non IDR picture. //8.4.2.2 @param DpbLuma Table of the reference decoded picture buffer. @param DpbCb Table of the reference decoded picture buffer. @param DpbCr Table of the reference decoded picture buffer. @param Luma_l0 Table of current frame. @param Luma_l1 Table of current frame. @param Chroma_Cb_l0 Table of current frame. @param Chroma_Cb_l1 Table of current frame. @param Chroma_Cr_l0 Table of current frame. @param Chroma_Cr_l1 Table of current frame. @param mvL0 The motion vector are stocked for each 4x4 block of each macroblock. @param mvL1 The motion vector are stocked for each 4x4 block of each macroblock. @param ref_cache_l0 A cache table where the reference is stocked for each 4x4 block of each macroblock. @param ref_cache_l1 A cache table where the reference is stocked for each 4x4 block of each macroblock. @param x X-coordinate. @param y Y-coordinate. @param PicWidthInPix Width in pixel of the current frame. @param PicHeightInPix Height in pixel of the current frame. @prama RefPicListL0 List l0 of reference image. @prama RefPicListL1 List l1 of reference image. @param interpol Function pointer of 4x4 interpoaltion. */ void sample_interpolation_main(unsigned char *DpbLuma, unsigned char *DpbCb,unsigned char *DpbCr, unsigned char *Luma_l0, unsigned char *Luma_l1 , unsigned char *Chroma_Cb_l0, unsigned char *Chroma_Cb_l1, unsigned char *Chroma_Cr_l0 , unsigned char *Chroma_Cr_l1, short mvL0[][2], short mvL1[][2], short *ref_cache_l0, short *ref_cache_l1, short x, short y, const short PicWidthInPix, const short PicHeightInPix , const LIST_MMO *RefPicListL0, const LIST_MMO * RefPicListL1, const interpol_4x4 *interpol) { int i; for( i = 0; i < 16; i++){ short index8 = SCAN8(i); const short Currentx = x + LOCX(i); const short Currenty = y + LOCY(i); if ( ref_cache_l0[index8] >= 0){ Interpolate(ref_cache_l0[index8], Currentx, Currenty, &mvL0[index8][0], 4, PicWidthInPix, PicHeightInPix, RefPicListL0, &Luma_l0[i << 4], &Chroma_Cb_l0[i << 2], &Chroma_Cr_l0[i << 2], DpbLuma, DpbCb, DpbCr, interpol); } if ( ref_cache_l1[index8] >= 0){ Interpolate(ref_cache_l1[index8], Currentx, Currenty, &mvL1[index8][0], 4, PicWidthInPix, PicHeightInPix, RefPicListL1, &Luma_l1[i << 4], &Chroma_Cb_l1[i << 2], &Chroma_Cr_l1[i << 2], DpbLuma, DpbCb, DpbCr, interpol); } } }
inline const Vector4< primitiveType > Interpolate( const Vector4< primitiveType >& start, const Vector4< primitiveType >& end, primitiveType fractionFromStartToEnd ) { primitiveType xInterpolated = Interpolate( start.x, end.x, fractionFromStartToEnd ); primitiveType yInterpolated = Interpolate( start.y, end.y, fractionFromStartToEnd ); primitiveType zInterpolated = Interpolate( start.z, end.z, fractionFromStartToEnd ); primitiveType wInterpolated = Interpolate( start.w, end.w, fractionFromStartToEnd ); return Vector4< primitiveType >( xInterpolated, yInterpolated, zInterpolated, wInterpolated ); }
inline Color Interpolate(Color val1, Color val2, double dDelta) { return Color( Interpolate(val1.m_color[Color::red], val2.m_color[Color::red], dDelta), Interpolate(val1.m_color[Color::green], val2.m_color[Color::green], dDelta), Interpolate(val1.m_color[Color::blue], val2.m_color[Color::blue], dDelta), Interpolate(val1.m_color[Color::alpha], val2.m_color[Color::alpha], dDelta)); }
inline RGBA Interpolate(const RGBA& start, const RGBA& end, float fractionComplete) { RGBA interpRGBA; interpRGBA.r() = Interpolate(start.r(), end.r(), fractionComplete); interpRGBA.g() = Interpolate(start.g(), end.g(), fractionComplete); interpRGBA.b() = Interpolate(start.b(), end.b(), fractionComplete); interpRGBA.a() = Interpolate(start.a(), end.a(), fractionComplete); return interpRGBA; }
Vector3 Interpolate(const Vector3 &v1, const Vector3 &v2, float f) { Vector3 _v = v1 ; _v.x = Interpolate(_v.x, v2.x, f) ; _v.y = Interpolate(_v.y, v2.y, f) ; _v.z = Interpolate(_v.z, v2.z, f) ; return _v ; }
void FFMODListener::UpdateCurrentInteriorSettings() { // Store the interpolation value, not the actual value InteriorVolumeInterp = Interpolate( InteriorEndTime ); ExteriorVolumeInterp = Interpolate( ExteriorEndTime ); InteriorLPFInterp = Interpolate( InteriorLPFEndTime ); ExteriorLPFInterp = Interpolate( ExteriorLPFEndTime ); }
global func InterpolateRGBa(RGBa_1,RGBa_2,x1,x2,x3) { var r = Interpolate(GetRGBaValue(RGBa_1,1),GetRGBaValue (RGBa_2,1),x1,x2,x3); var g = Interpolate(GetRGBaValue(RGBa_1,2),GetRGBaValue (RGBa_2,2),x1,x2,x3); var b = Interpolate(GetRGBaValue(RGBa_1,3),GetRGBaValue (RGBa_2,3),x1,x2,x3); var a = Interpolate(GetRGBaValue(RGBa_1,0),GetRGBaValue (RGBa_2,0),x1,x2,x3); return(RGBa(r,g,b,a)); }
int main(void) { int i = 24332; float x = 432.321; std::string str1("foo"); //Works std::cout << Interpolate(R"(goo % goo % goo)", i, x) << std::endl; // Does not work, even though I'm not actually doing anything with the string argument std::cout << Interpolate(R"(goo %)", str1) << std::endl; }
//----------------------------------------------------------------// float USInterpolate::Interpolate ( u32 mode, float x0, float x1, float t, float w ) { float v0 = Interpolate ( mode, x0, x1, t ); if ( w == 1.0f ) { return v0; } float v1 = Interpolate ( kLinear, x0, x1, t ); return Interpolate ( kLinear, v1, v0, w ); }
void PressureTable::LookupSelectedCoeff(double &RoM, double &T0, double &E0, double &Gam0, double &a_Gam, double P, double Zm, double Zvar, double C) { InterpolatePoint(P, Zm, Zvar, C); RoM = Interpolate(0); T0 = Interpolate(1); E0 = Interpolate(2); Gam0 = Interpolate(3); a_Gam = Interpolate(4); }
double Noise::Generate(double x, double y) { double s, t, u, v; s = FindNoise(floor(x), floor(y)); t = FindNoise(ceil(x), floor(y)); u = FindNoise(floor(x), ceil(y));//Get the surrounding pixels to calculate the transition. v = FindNoise(ceil(x), ceil(y)); double y1 = Interpolate(s, t, x - floorf(x));//Interpolate between the values. double y2 = Interpolate(u, v, x - floorf(x));//Here we use x-floorx, to get 1st dimension. Don't mind the x-floorx thingie, it's part of the cosine formula. return Interpolate(y1, y2, y - floorf(y));//Here we use y-floory, to get the 2nd dimension. }
virtual void GetInterpolatedPosition2D(float frameOffset, float& x, float& z, float& rotY) { if (!m_InWorld) { LOGERROR(L"CCmpPosition::GetInterpolatedPosition2D called on entity when IsInWorld is false"); return; } x = Interpolate(m_LastX.ToFloat(), m_X.ToFloat(), frameOffset); z = Interpolate(m_LastZ.ToFloat(), m_Z.ToFloat(), frameOffset); rotY = m_InterpolatedRotY; }
void Voice::RenderAudio() { switch (this->PlaybackState) { case playback_state_ram: { Interpolate((sample_t*) pSample->GetCache().pStart); if (DiskVoice) { // check if we reached the allowed limit of the sample RAM cache if (Pos > MaxRAMPos) { dmsg(("Voice: switching to disk playback (Pos=%f)\n", Pos)); this->PlaybackState = playback_state_disk; } } else if (Pos >= pSample->GetCache().Size / pSample->FrameSize) { this->PlaybackState = playback_state_end; } } break; case playback_state_disk: { if (!DiskStreamRef.pStream) { // check if the disk thread created our ordered disk stream in the meantime DiskStreamRef.pStream = pDiskThread->AskForCreatedStream(DiskStreamRef.OrderID); if (!DiskStreamRef.pStream) { std::cout << stderr << "Disk stream not available in time!" << std::endl << std::flush; pDiskThread->OrderDeletionOfStream(&DiskStreamRef); this->Active = false; return; } DiskStreamRef.pStream->IncrementReadPos(pSample->Channels * (double_to_int(Pos) - MaxRAMPos)); Pos -= double_to_int(Pos); } // add silence sample at the end if we reached the end of the stream (for the interpolator) if (DiskStreamRef.State == Stream::state_end && DiskStreamRef.pStream->GetReadSpace() < (OutputBufferSize << MAX_PITCH) / pSample->Channels) { DiskStreamRef.pStream->WriteSilence((OutputBufferSize << MAX_PITCH) / pSample->Channels); this->PlaybackState = playback_state_end; } sample_t* ptr = DiskStreamRef.pStream->GetReadPtr(); // get the current read_ptr within the ringbuffer where we read the samples from Interpolate(ptr); DiskStreamRef.pStream->IncrementReadPos(double_to_int(Pos) * pSample->Channels); Pos -= double_to_int(Pos); } break; case playback_state_end: this->Active = false; // free voice break; } }
GeoVector GetVector(fixed time) const { assert(Ready()); if (!positive(p[2].t-p[1].t)) { return GeoVector(fixed_zero, Angle::zero()); } const Record r0 = Interpolate(time - fixed(0.05)); const Record r1 = Interpolate(time + fixed(0.05)); return GeoVector(p[1].loc.distance(p[2].loc)/ (p[2].t-p[1].t), r0.loc.bearing(r1.loc)); }
void Bone::ScaleForFrame(int32 f, double* x, double* y) const { const Frame* frame = NULL, * prevFrame = NULL, * nextFrame = NULL; GetFrame(f, &frame, &prevFrame, &nextFrame); if ( frame != NULL ) { *x = frame->GetScaleX(); *y = frame->GetScaleY(); } else if ( prevFrame != NULL && nextFrame != NULL ) { *x = Interpolate(f, prevFrame->GetId(), nextFrame->GetId(), prevFrame->GetScaleX(), nextFrame->GetScaleX()); *y = Interpolate(f, prevFrame->GetId(), nextFrame->GetId(), prevFrame->GetScaleY(), nextFrame->GetScaleY()); } else { *x = *y = 0; } }
const Rgba Interpolate(const Rgba& start, const Rgba& end, float fractionFromStartToEnd) { float lerpedR = Interpolate(start.fR(), end.fR(), fractionFromStartToEnd); float lerpedG = Interpolate(start.fG(), end.fG(), fractionFromStartToEnd); float lerpedB = Interpolate(start.fB(), end.fB(), fractionFromStartToEnd); float lerpedA = Interpolate(start.fA(), end.fA(), fractionFromStartToEnd); unsigned char lerpedCR = Rgba::cR(lerpedR); unsigned char lerpedCG = Rgba::cG(lerpedG); unsigned char lerpedCB = Rgba::cB(lerpedB); unsigned char lerpedCA = Rgba::cA(lerpedA); return Rgba(lerpedCR, lerpedCG, lerpedCB, lerpedCA); }
CFrameAnimation::CFrameAnimation(CWnd* pWnd, int iStartX1,int iStartY1,int iStartX2,int iStartY2, int iEndX1,int iEndY1,int iEndX2,int iEndY2) { CClientDC dc(pWnd); for(int i=0;i<=NUMFRAMES+1;i++) { // Remove last frame if(i!=0) InvertHollowRect(dc, Interpolate(iStartX1,iEndX1,i-1), Interpolate(iStartY1,iEndY1,i-1), Interpolate(iStartX2,iEndX2,i-1), Interpolate(iStartY2,iEndY2,i-1)); // If we've just undrawn final frame, break out if(i==NUMFRAMES+1) break; // Draw this frame InvertHollowRect(dc, Interpolate(iStartX1,iEndX1,i), Interpolate(iStartY1,iEndY1,i), Interpolate(iStartX2,iEndX2,i), Interpolate(iStartY2,iEndY2,i)); // Pause some so that user gets to see it Sleep(150/NUMFRAMES); } }
double InterpolatedNoise(double x, double y){ int int_X, int_Y; double fractional_X, fractional_Y, v1, v2, v3, v4, i1, i2; int_X = (int)floor(x); //不要问我为毛用floor,c++默认居然TM的是向零取整的 fractional_X = x - int_X; int_Y = (int)floor(y); fractional_Y = y - int_Y; v1 = SmoothedNoise(int_X, int_Y); v2 = SmoothedNoise(int_X + 1, int_Y); v3 = SmoothedNoise(int_X, int_Y + 1); v4 = SmoothedNoise(int_X + 1, int_Y + 1); i1 = Interpolate(v1, v2, fractional_X); i2 = Interpolate(v3, v4, fractional_X); return Interpolate(i1, i2, fractional_Y); }
static void CI4D_SetFraction(GF_Node *n, GF_Route *route) { Fixed frac; u32 numElemPerKey, i, j; M_CoordinateInterpolator4D *_this = (M_CoordinateInterpolator4D *) n; if (! _this->key.count) return; if (_this->keyValue.count % _this->key.count) return; numElemPerKey = _this->keyValue.count / _this->key.count; //set size if (_this->value_changed.count != numElemPerKey) gf_sg_vrml_mf_alloc(&_this->value_changed, GF_SG_VRML_MFVEC4F, numElemPerKey); if (_this->set_fraction < _this->key.vals[0]) { for (i=0; i<numElemPerKey; i++) _this->value_changed.vals[i] = _this->keyValue.vals[i]; } else if (_this->set_fraction > _this->key.vals[_this->key.count - 1]) { for (i=0; i<numElemPerKey; i++) _this->value_changed.vals[i] = _this->keyValue.vals[(_this->keyValue.count) - numElemPerKey + i]; } else { for (j = 1; j < _this->key.count; j++) { // Find the key values the fraction lies between if ( _this->set_fraction < _this->key.vals[j-1]) continue; if (_this->set_fraction >= _this->key.vals[j]) continue; frac = GetInterpolateFraction(_this->key.vals[j-1], _this->key.vals[j], _this->set_fraction); for (i=0; i<numElemPerKey; i++) { _this->value_changed.vals[i].x = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].x, _this->keyValue.vals[(j)*numElemPerKey + i].x, frac); _this->value_changed.vals[i].y = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].y, _this->keyValue.vals[(j)*numElemPerKey + i].y, frac); _this->value_changed.vals[i].z = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].z, _this->keyValue.vals[(j)*numElemPerKey + i].z, frac); _this->value_changed.vals[i].q = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].q, _this->keyValue.vals[(j)*numElemPerKey + i].q, frac); } break; } } //invalidate gf_node_event_out(n, 3);//"value_changed" }
void CI4D_SetFraction(SFNode *n) { Float frac; u32 numElemPerKey, i, j; M_CoordinateInterpolator4D *_this = (M_CoordinateInterpolator4D *) n; if (! _this->key.count) return; if (_this->keyValue.count % _this->key.count) return; numElemPerKey = _this->keyValue.count / _this->key.count; //set size if (_this->value_changed.count != numElemPerKey) VRML_MF_Alloc(&_this->value_changed, FT_MFVec4f, numElemPerKey); if (_this->set_fraction < _this->key.vals[0]) { for (i=0; i<numElemPerKey; i++) _this->value_changed.vals[i] = _this->keyValue.vals[i]; } else if (_this->set_fraction > _this->key.vals[_this->key.count - 1]) { for (i=0; i<numElemPerKey; i++) _this->value_changed.vals[i] = _this->keyValue.vals[(_this->keyValue.count) - numElemPerKey + i]; } else { for (j = 1; j < _this->key.count; j++) { // Find the key values the fraction lies between if ( _this->set_fraction < _this->key.vals[j-1]) continue; if (_this->set_fraction >= _this->key.vals[j]) continue; frac = GetInterpolateFraction(_this->key.vals[j-1], _this->key.vals[j], _this->set_fraction); for (i=0; i<numElemPerKey; i++) { _this->value_changed.vals[i].x = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].x, _this->keyValue.vals[(j)*numElemPerKey + i].x, frac); _this->value_changed.vals[i].y = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].y, _this->keyValue.vals[(j)*numElemPerKey + i].y, frac); _this->value_changed.vals[i].z = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].z, _this->keyValue.vals[(j)*numElemPerKey + i].z, frac); _this->value_changed.vals[i].q = Interpolate(_this->keyValue.vals[(j-1)*numElemPerKey + i].q, _this->keyValue.vals[(j)*numElemPerKey + i].q, frac); } break; } } //invalidate Node_OnEventOutSTR(n, "value_changed"); }
GeoVector GetVector(fixed time) const { if (!Ready()) return fixed_zero; if (!positive(p[2].t-p[1].t)) { return GeoVector(fixed_zero, Angle::native(fixed_zero)); } fixed alt, palt; GeoPoint p0, p1; Interpolate(time-fixed(0.05), p0, alt, palt); Interpolate(time+fixed(0.05), p1, alt, palt); return GeoVector(p[1].loc.distance(p[2].loc)/ (p[2].t-p[1].t), p0.bearing(p1)); }
Ang3 CCinematicInput::UpdateAdditiveCameraInputWithController( const SUpdateContext& updateCtx, const Ang3& rawControllerInput ) { if (updateCtx.m_recenter) { Ang3 finalControllerAnglesLimited = rawControllerInput; //Yaw angle (Z axis) finalControllerAnglesLimited.z = -clamp_tpl((float)fsel(finalControllerAnglesLimited.z, finalControllerAnglesLimited.z * updateCtx.m_lookRightLimit, finalControllerAnglesLimited.z * updateCtx.m_lookLeftLimit), -updateCtx.m_lookLeftLimit, updateCtx.m_lookRightLimit); //Pitch angle (X axis) finalControllerAnglesLimited.x *= (g_pGameCVars->cl_invertController == 0) ? 1.0f : -1.0f; finalControllerAnglesLimited.x = clamp_tpl((float)fsel(finalControllerAnglesLimited.x, finalControllerAnglesLimited.x * updateCtx.m_lookUpLimit, finalControllerAnglesLimited.x * updateCtx.m_lookDownLimit), -updateCtx.m_lookDownLimit, updateCtx.m_lookUpLimit); //No roll allowed finalControllerAnglesLimited.y = 0.0f; Interpolate(m_controllerAccumulatedAngles, finalControllerAnglesLimited, 2.5f, updateCtx.m_frameTime); } else { Ang3 finalControllerAnglesLimited = m_controllerAccumulatedAngles; finalControllerAnglesLimited.x += ( (rawControllerInput.x * updateCtx.m_frameTime * 1.5f) * ((g_pGameCVars->cl_invertController == 0) ? 1.0f : -1.0f) ); finalControllerAnglesLimited.z -= (rawControllerInput.z * updateCtx.m_frameTime * 1.5f); finalControllerAnglesLimited.x = clamp_tpl(finalControllerAnglesLimited.x, -updateCtx.m_lookDownLimit, updateCtx.m_lookUpLimit); finalControllerAnglesLimited.z = clamp_tpl(finalControllerAnglesLimited.z, -updateCtx.m_lookLeftLimit, updateCtx.m_lookRightLimit); finalControllerAnglesLimited.y = 0.0f; m_controllerAccumulatedAngles = finalControllerAnglesLimited; } return m_controllerAccumulatedAngles; }
void CGradientEditor::OnMouseMove(int x, int y) { COLORREF colorHere = gradient->ColorAtPoint(Interpolate(x, clientRect->left, clientRect->right, 0.0, 1.0)); tstring colorStr; ColorToHTML(colorHere, colorStr); display->SetHelpText(TEXT("Click (and optionally drag) to add a new step to the gradient. [color here: ") + colorStr + TEXT("]")); CCompoundDispItem::OnMouseMove(x, y); }
CGradientEditor::CStepHandle *CGradientEditor::AddGradientStep(int x) { double pos = Interpolate(x, clientRect->left, clientRect->right, 0.0, 1.0); unsigned int index = gradient->AddStep(pos, gradient->ColorAtPoint(pos)); SetGradient(gradient); return stepHandles[index]; }
void CGradientEditor::OnDraw(HDC hDC, const LPRECT clientRect) { this->clientRect = clientRect; for (int x = clientRect->left; x < clientRect->right; x++) { double point = Interpolate(x, clientRect->left, clientRect->right, 0.0, 1.0); COLORREF color = MultiplyColors(tint, gradient->ColorAtPoint(point)); SelectObject(hDC, GetStockObject(DC_PEN)); SetDCPenColor(hDC, color); MoveToEx(hDC, x, clientRect->bottom - 23, NULL); LineTo(hDC, x, clientRect->bottom); SetPixel(hDC, x, clientRect->bottom - 24, InterpolateColor(color, 0xFFFFFF, 0.125)); } SetTextColor(hDC, 0xFFFFFF); int count = bitmap.GetCellCount(); for (int i = 1; i < count; i++) { int x = i * (clientRect->right - clientRect->left) / count; BitBlt(hDC, x - 3, clientRect->bottom - 4, 7, 4, cellMarkerBmpDC, 0, 0, SRCINVERT); } for (std::vector<CStepHandle*>::iterator i = stepHandles.begin(); i != stepHandles.end(); i++) { (*i)->SetPositioningInfo(clientRect->left, clientRect->right, clientRect->bottom - 24); } CCompoundDispItem::OnDraw(hDC, clientRect); }
double CAAInterpolate::Extremum(double Y1, double Y2, double Y3, double Y4, double Y5, double& nm) { double A = Y2 - Y1; double B = Y3 - Y2; double C = Y4 - Y3; double D = Y5 - Y4; double E = B - A; double F = C - B; double G = D - C; double H = F - E; double J = G - F; double K = J - H; bool bRecalc = true; double nmprev = 0; nm = nmprev; while (bRecalc) { double NMprev2 = nmprev*nmprev; double NMprev3 = NMprev2*nmprev; nm = (6*B + 6*C - H - J +3*NMprev2*(H+J) + 2*NMprev3*K) / (K - 12*F); bRecalc = (fabs(nm - nmprev) > 1E-12); if (bRecalc) nmprev = nm; } return Interpolate(nm, Y1, Y2, Y3, Y4, Y5); }