| public static Lerp ( double a, double b, double f ) : double | ||
| a | double | |
| b | double | |
| f | double | |
| return | double | |
/// <summary>
/// 高度计算
/// </summary>
/// <param name="x"></param>
/// <param name="z"></param>
/// <returns></returns>
public float CalculateHeight(float x, float z)
{
float num = this.TGOceanSlope + this.TGOceanSlopeVariation * MathUtils.PowSign(2f * SimplexNoise.OctavedNoise(x + this.mountainsOffset.X, z + this.mountainsOffset.Y, 0.01f, 1, 2f, 0.5f) - 1f, 0.5f);
float num2 = this.CalculateOceanShoreDistance(x, z);
float num3 = MathUtils.Saturate(1f - 0.05f * MathUtils.Abs(num2));
float num4 = MathUtils.Saturate(MathUtils.Sin(this.TGIslandsFrequency * num2));
float num5 = MathUtils.Saturate(MathUtils.Saturate(-num * num2) - 0.85f * num4);
float num6 = MathUtils.Saturate(MathUtils.Saturate(0.05f * (-num2 - 10f)) - num4);
float num7 = this.CalculateMountainRangeFactor(x, z);
float f = (1f - num3) * SimplexNoise.OctavedNoise(x, z, 0.001f / this.TGBiomeScaling, 2, 1.97f, 0.8f);
float f2 = (1f - num3) * SimplexNoise.OctavedNoise(x, z, 0.0017f / this.TGBiomeScaling, 2, 1.93f, 0.7f);
float num8 = (1f - num6) * (1f - num3) * MathUtils.Saturate((num7 - 0.6f) / 0.4f);
float num9 = (1f - num6) * MathUtils.Saturate((num7 - (1f - this.TGMountainsPercentage)) / this.TGMountainsPercentage);
float num10 = 2f * SimplexNoise.OctavedNoise(x, z, 0.02f, 3, 1.93f, 0.8f) - 1f;
float num11 = 1.5f * SimplexNoise.OctavedNoise(x, z, 0.004f, 4, 1.98f, 0.9f) - 0.5f;
float num12 = MathUtils.Lerp(60f, 30f, MathUtils.Saturate(1f * num9 + 0.5f * num8 + MathUtils.Saturate(1f - num2 / 30f)));
float x2 = MathUtils.Lerp(-2f, -4f, MathUtils.Saturate(num9 + 0.5f * num8));
float num13 = MathUtils.Saturate(2.0f - num12 * MathUtils.Abs(2f * SimplexNoise.OctavedNoise(x + this.riversOffset.X, z + this.riversOffset.Y, 0.001f, 4, 2f, 0.5f) - 1f));
float num14 = -50f * num5 + this.TGHeightBias;
float num15 = MathUtils.Lerp(0f, 8f, f);
float num16 = MathUtils.Lerp(0f, -6f, f2);
float num17 = this.TGHillsStrength * num8 * num10;
float num18 = this.TGMountainsStrength * num9 * num11;
float f3 = this.TGRiversStrength * num13;
float num19 = num14 + num15 + num16 + num18 + num17;
float num20 = MathUtils.Min(MathUtils.Lerp(num19, x2, f3), num19);
return(MathUtils.Clamp(64f + num20, 10f, 123f));
}
private void Update(EvaluationContext context)
{
var countX = Count.GetValue(context).Clamp(1, 10000);
var count = countX;
if (_points.Length != count)
{
_points = new T3.Core.DataTypes.Point[count];
_pointList.SetLength(count);
}
var startP = Start.GetValue(context);
var endP = Offset.GetValue(context);
var startW = StartW.GetValue(context);
var scaleW = OffsetW.GetValue(context);
var startPoint = new Vector3(startP.X, startP.Y, startP.Z);
var offset = new Vector3(endP.X, endP.Y, endP.Z);
var index = 0;
for (var x = 0; x < countX; x++)
{
var fX = x / (float)countX;
_points[index].Position = Vector3.Lerp(startPoint, startPoint + offset, fX);
_points[index].Orientation = Quaternion.Identity;
_points[index].W = MathUtils.Lerp(startW, startW + scaleW, fX);
_pointList[index] = _points[index];
index++;
}
Result.Value = _points;
PointList.Value = _pointList;
}
protected override void UpdateInternal(UpdateContext context)
{
float value = this._moveSpeedFactor * MathUtils.Lerp(this.values[0], 1f, this._elapsed / this.duration);
this.owner.property.Equal(Attr.MoveSpeedFactor, value);
this._deltaf[Attr.MoveSpeedFactor] = value - this._moveSpeedFactor;
}
private void setPosition()
{
var viewport = _game.State.Viewport;
float x = MathUtils.Lerp(0f, 0f, _windowInfo.AppWindowWidth, _resolution.Width, viewport.ScreenArea.X);
float width = MathUtils.Lerp(0f, 0f, _windowInfo.AppWindowWidth, _resolution.Width, viewport.ScreenArea.Width);
_toolbar.X = x + width / 2f;
}
private float EvalForTwoKeys(FRichCurveKey key1, FRichCurveKey key2, float inTime)
{
var diff = key2.Time - key1.Time;
if (diff > 0f && key1.InterpMode != RCIM_Constant)
{
var alpha = (inTime - key1.Time) / diff;
var p0 = key1.Value;
var p3 = key2.Value;
if (key1.InterpMode == RCIM_Linear)
{
return(MathUtils.Lerp(p0, p3, alpha));
}
if (IsItNotWeighted(key1, key2))
{
const float oneThird = 1f / 3f;
var p1 = p0 + key1.LeaveTangent * diff * oneThird;
var p2 = p3 - key2.ArriveTangent * diff * oneThird;
return(BezierInterp(p0, p1, p2, p3, alpha));
}
// it's weighted
return(WeightedEvalForTwoKeys(key1, key2, inTime));
}
return(key1.Value);
}
private float convertX(float x)
{
var viewport = getViewport();
var virtualWidth = _virtualWidth / viewport.ScaleX;
x = MathUtils.Lerp(0f, 0f, _windowSize.GetWidth(_game), virtualWidth, x);
return(x + viewport.X);
}
private float convertY(float y)
{
var viewport = getViewport();
var virtualHeight = _virtualHeight / viewport.ScaleY;
y = MathUtils.Lerp(0f, virtualHeight, _windowSize.GetHeight(_game), 0f, y);
return(y + viewport.Y);
}
private async Task <float[]> GenerateHeightMap(BiomeBase[] biomes, int chunkX, int chunkZ)
{
return(await Task.Run(() =>
{
int minX = ((chunkX) * 16);
int minZ = ((chunkZ) * 16);
var maxX = ((chunkX + 1) << 4);
var maxZ = ((chunkZ + 1) << 4);
int cx = (chunkX * 16);
int cz = (chunkZ * 16);
/*float q11 = MathUtils.Lerp(biomes[0].MinHeight, biomes[0].MaxHeight,
* MathUtils.ConvertRange(-1f, 1f, 0f, 1f, NoiseProvider.TerrainNoise.GetValue(minX, minZ)));
* float q12 = MathUtils.Lerp(biomes[15].MinHeight, biomes[15].MaxHeight,
* MathUtils.ConvertRange(-1f, 1f, 0f, 1f, NoiseProvider.TerrainNoise.GetValue(minX, maxZ)));
*
* float q21 = MathUtils.Lerp(biomes[240].MinHeight, biomes[240].MaxHeight,
* MathUtils.ConvertRange(-1f, 1f, 0f, 1f,NoiseProvider.TerrainNoise.GetValue(maxX, minZ)));
* float q22 = MathUtils.Lerp(biomes[255].MinHeight, biomes[255].MaxHeight,
* MathUtils.ConvertRange(-1f, 1f, 0f, 1f, NoiseProvider.TerrainNoise.GetValue(maxX, maxZ)));*/
float q11 = MathUtils.Lerp(biomes[0].MinHeight, biomes[0].MaxHeight,
NoiseProvider.TerrainNoise.GetValue(minX, minZ));
float q12 = MathUtils.Lerp(biomes[15].MinHeight, biomes[15].MaxHeight,
NoiseProvider.TerrainNoise.GetValue(minX, maxZ));
float q21 = MathUtils.Lerp(biomes[240].MinHeight, biomes[240].MaxHeight,
NoiseProvider.TerrainNoise.GetValue(maxX, minZ));
float q22 = MathUtils.Lerp(biomes[255].MinHeight, biomes[255].MaxHeight,
NoiseProvider.TerrainNoise.GetValue(maxX, maxZ));
float[] heightMap = new float[16 * 16];
for (int x = 0; x < 16; x++)
{
float rx = cx + x;
for (int z = 0; z < 16; z++)
{
float rz = cz + z;
var baseNoise = MathUtils.BilinearCmr(
rx, rz,
q11,
q12,
q21,
q22,
minX, maxX, minZ, maxZ);
heightMap[(x << 4) + z] = baseNoise; //WaterLevel + ((128f * baseNoise));
}
}
return heightMap;
}));
}
public Pair <Genome> Crossover(Genome other, RandomNumberGenerator random)
{
var o = (SimpleGenome)other;
var child1 = new SimpleGenome(MathUtils.Lerp(value, o.value, random.NextDouble()));
var child2 = new SimpleGenome(MathUtils.Lerp(value, o.value, random.NextDouble()));
return(new Pair <Genome>(child1, child2));
}
protected void UpdateValues()
{
foreach (var axis in DeviceAxis.All)
{
var value = CoerceProviderValue(axis, _valueProvider?.GetValue(axis) ?? float.NaN);
var settings = AxisSettings[axis];
Values[axis] = MathUtils.Lerp(settings.Minimum / 100f, settings.Maximum / 100f, value);
}
}
public static Vector4 Mix(Vector4 c1, Vector4 c2, float t)
{
var c1Linear = Degamma(c1);
var c2Linear = Degamma(c2);
var labMix = MathUtils.Lerp(RgbAToOkLab(c1Linear), RgbAToOkLab(c2Linear), t);
return(ToGamma(OkLab.OkLabToRgba(labMix)));
}
public Color4 ColorHSV(float hueMin, float hueMax, float saturationMin, float saturationMax, float valueMin, float valueMax, float alphaMin, float alphaMax)
{
float h = MathUtils.Lerp(hueMin, hueMax, this.NextFloat());
float s = MathUtils.Lerp(saturationMin, saturationMax, this.NextFloat());
float v = MathUtils.Lerp(valueMin, valueMax, this.NextFloat());
Color4 result = Color4.HsvtoRgb(h, s, v, true);
result.a = MathUtils.Lerp(alphaMin, alphaMax, this.NextFloat());
return(result);
}
private void Update(EvaluationContext context)
{
var v = Value.GetValue(context);
var damping = Damping.GetValue(context);
var f = (float)(damping * EvaluationContext.LastFrameDuration).Clamp(0f, 1f);
_dampedValue = MathUtils.Lerp(v, _dampedValue, f);
Result.Value = _dampedValue;
}
/// <summary>
/// Interpolates between two bookmarks. The t argument must be between 0 and 1 (inclusive), and
/// the two endpoints must have the same mode (ORBIT or MAP).
/// </summary>
public static Bookmark Interpolate(Bookmark a, Bookmark b, float time)
{
Bookmark result = new Bookmark();
if (a.Mode == Mode.Map)
{
Debug.Assert(b.Mode == Mode.Map);
float rho = MathF.Sqrt(2.0f);
float rho2 = 2, rho4 = 4;
float ux0 = a.Map.Center.X, uy0 = a.Map.Center.Y, w0 = a.Map.Extent;
float ux1 = b.Map.Center.X, uy1 = b.Map.Center.Y, w1 = b.Map.Extent;
float dx = ux1 - ux0;
float dy = uy1 - uy0;
float d2 = dx * dx + dy * dy;
float d1 = MathF.Sqrt(d2);
float b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2.0f * w0 * rho2 * d1);
float b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2.0f * w1 * rho2 * d1);
float r0 = MathF.Log(MathF.Sqrt(b0 * b0 + 1.0f) - b0);
float r1 = MathF.Log(MathF.Sqrt(b1 * b1 + 1f) - b1);
float dr = r1 - r0;
bool valid = dr != 0;
float s = ((valid ? dr : MathF.Log(w1 / w0)) / rho);
s = time * s;
// this performs Van Wijk interpolation to animate between two waypoints on a map.
if (valid)
{
var coshr0 = MathF.Cosh(r0);
var u = w0 / (rho2 * d1) * (coshr0 * MathF.Tanh(rho * s + r0) - MathF.Sinh(r0));
result.Map.Center.X = (ux0 + u * dx);
result.Map.Center.Y = (uy0 + u * dy);
result.Map.Extent = (w0 * coshr0 / MathF.Cosh(rho * s + r0));
return(result);
}
// for degenerate cases, fall back to a simplified interpolation method.
result.Map.Center.X = ux0 + time * dx;
result.Map.Center.Y = uy0 + time * dy;
result.Map.Extent = (w0 * MathF.Exp(rho * s));
return(result);
}
Debug.Assert(b.Mode == Mode.Orbit);
result.Orbit.Phi = MathUtils.Lerp(a.Orbit.Phi, b.Orbit.Phi, time);
result.Orbit.Theta = MathUtils.Lerp(a.Orbit.Theta, b.Orbit.Theta, time);
result.Orbit.Distance = MathUtils.Lerp(a.Orbit.Distance, b.Orbit.Distance, time);
result.Orbit.Pivot = Vector3.Lerp(a.Orbit.Pivot, b.Orbit.Pivot, time);
return(result);
}
public override void _Process(float delta)
{
_timer += delta;
if (_timer > _visible_duration)
{
Hide();
SetProcess(false);
}
Reposition();
SetValue(MathUtils.Lerp(GetValue(), _target_value, delta * 5));
}
private float BezierInterp(float p0, float p1, float p2, float p3, float alpha)
{
var p01 = MathUtils.Lerp(p0, p1, alpha);
var p12 = MathUtils.Lerp(p1, p2, alpha);
var p23 = MathUtils.Lerp(p2, p3, alpha);
var p012 = MathUtils.Lerp(p01, p12, alpha);
var p123 = MathUtils.Lerp(p12, p23, alpha);
var p0123 = MathUtils.Lerp(p012, p123, alpha);
return(p0123);
}
private void DoFirstPerson(Vector2 mousePos)
{
Vector3 vel = Vector3.Zero;
if (Globals.Engine.Keyboard[Key.W])
{
vel += new Vector3(0, 0, -1); // camera looks backwards
}
if (Globals.Engine.Keyboard[Key.S])
{
vel += new Vector3(0, 0, 1);
}
if (Globals.Engine.Keyboard[Key.A])
{
vel += new Vector3(-1, 0, 0);
}
if (Globals.Engine.Keyboard[Key.D])
{
vel += new Vector3(1, 0, 0);
}
vel.NormalizeFast();
if (Globals.Engine.Keyboard[Key.ShiftLeft])
{
vel *= 4;
}
var mouseDelta = mousePos - oldMousePos;
// unity screen coordinate system
mouseDelta = new Vector2(-mouseDelta.Y, -mouseDelta.X) * sensitivity * smoothing;
_smoothMouse.X = MathUtils.Lerp(_smoothMouse.X, mouseDelta.X, 1f / smoothing);
_smoothMouse.Y = MathUtils.Lerp(_smoothMouse.Y, mouseDelta.Y, 1f / smoothing);
// find the absolute mouse movement value from point zero
_mouseAbsolute += _smoothMouse;
if (clampX < 360)
{
_mouseAbsolute.X = MathUtils.Clamp(_mouseAbsolute.X, -clampX * 0.5f, clampX * 0.5f);
}
if (clampY < 360)
{
_mouseAbsolute.Y = MathUtils.Clamp(_mouseAbsolute.Y, -clampY * 0.5f, clampY * 0.5f);
}
var xRotation = Quaternion.FromAxisAngle(Vector3.UnitX, _mouseAbsolute.X);
var yRotation = Quaternion.FromAxisAngle(Vector3.UnitY, _mouseAbsolute.Y);
GameObject.LocalRotation = yRotation * xRotation;
GameObject.Translate(vel * speed, false);
}
public static void SmoothlyUpdateBar(TextureProgress bar, float target, float delta)
{
if (delta <= 0)
{
GD.PrintErr("Tried to run SmoothlyUpdateBar with non-positive delta!");
return;
}
var weight = Math.Min(3.0f * delta + 0.2f, 1.0f);
bar.Value = MathUtils.Lerp((float)bar.Value, target, weight, 1.0f / (float)bar.MaxValue);
}
private float convertY(float y)
{
var viewport = getViewport();
var virtualHeight = _virtualHeight / viewport.ScaleY;
float density = Resources.System.DisplayMetrics.Density;
y = (y - GLUtils.ScreenViewport.Y) / density;
float height = _windowSize.GetHeight(null) - ((GLUtils.ScreenViewport.Y * 2) / density);
y = MathUtils.Lerp(0f, virtualHeight, height, 0f, y);
return(y + viewport.Y);
}
private float convertX(float x)
{
var viewport = getViewport();
var virtualWidth = _virtualWidth / viewport.ScaleX;
float density = Resources.System.DisplayMetrics.Density;
x = (x - GLUtils.ScreenViewport.X) / density;
float width = _windowSize.GetWidth(null) - ((GLUtils.ScreenViewport.X * 2) / density);
x = MathUtils.Lerp(0f, 0f, width, virtualWidth, x);
return(x + viewport.X);
}
private float convertY(float y)
{
var viewport = getViewport();
var virtualHeight = _virtualHeight / viewport.ScaleY;
float density = (float)UIScreen.MainScreen.Scale;
y = y - (GLUtils.ScreenViewport.Y / density);
float height = (_gameWindow.Height - (GLUtils.ScreenViewport.Y * 2)) / density;
y = MathUtils.Lerp(0f, virtualHeight, height, 0f, y);
return(y + viewport.Y);
}
private float convertX(float x)
{
var viewport = getViewport();
var virtualWidth = _virtualWidth / viewport.ScaleX;
float density = (float)UIScreen.MainScreen.Scale;
x = x - (GLUtils.ScreenViewport.X / density);
float width = (_gameWindow.Width - (GLUtils.ScreenViewport.X * 2)) / density;
x = MathUtils.Lerp(0f, 0f, width, virtualWidth, x);
return(x + viewport.X);
}
private void Update(EvaluationContext context)
{
var closeCircle = CloseCircle.GetValue(context);
var circleOffset = closeCircle ? 1 : 0;
var corners = Count.GetValue(context).Clamp(1, 10000);
var pointCount = corners + circleOffset;
var listCount = corners + 2 * circleOffset; // Separator
if (_pointList.NumElements != listCount)
{
//_points = new T3.Core.DataTypes.Point[count];
_pointList.SetLength(listCount);
}
var axis = Axis.GetValue(context);
var center = Center.GetValue(context);
var offset = Offset.GetValue(context);
var radius = Radius.GetValue(context);
var radiusOffset = RadiusOffset.GetValue(context);
var thickness = W.GetValue(context);
var thicknessOffset = WOffset.GetValue(context);
var angelInRads = StartAngel.GetValue(context) * MathUtils.ToRad + (float)Math.PI / 2;
var deltaAngle = -Cycles.GetValue(context) * MathUtils.Pi2 / (pointCount - circleOffset);
for (var index = 0; index < pointCount; index++)
{
var f = corners == 1
? 1
: (float)index / pointCount;
var length = MathUtils.Lerp(radius, radius + radiusOffset, f);
var v = Vector3.UnitX * length;
var rot = Quaternion.CreateFromAxisAngle(axis, angelInRads);
var vInAxis = Vector3.Transform(v, rot) + Vector3.Lerp(center, center + offset, f);
var p = new Point
{
Position = vInAxis,
W = MathUtils.Lerp(thickness, thickness + thicknessOffset, f),
Orientation = rot
};
_pointList[index] = p;
angelInRads += deltaAngle;
}
if (closeCircle)
{
_pointList[listCount - 1] = Point.Separator();
}
ResultList.Value = _pointList;
}
private void ProcessFadeIn()
{
Last.Volume =
MathUtils.Lerp(Last.Volume, _originalVolume, Game.LastFrameTime * FadeInMultiplier);
if (!(Last.Volume >= _originalVolume - 0.05f))
{
return;
}
Last.Volume = _originalVolume;
IsDoingFadeIn = false;
}
public static double Perlin(double x, double y, double z)
{
var xi = (int)x & 255; // Calculate the "unit cube" that the point asked will be located in
var yi = (int)y & 255; // The left bound is ( |_x_|,|_y_|,|_z_| ) and the right bound is that
var zi = (int)z & 255; // plus 1. Next we calculate the location (from 0.0 to 1.0) in that cube.
var xf = x - (int)x; // We also Fade the location to smooth the result.
var yf = y - (int)y;
var zf = z - (int)z;
var u = Fade(xf);
var v = Fade(yf);
var w = Fade(zf);
var a = p[xi] + yi; // This here is Perlin's hash function. We take our x value (remember,
var aa = p[a] + zi; // between 0 and 255) and get a random value (from our p[] array above) between
var ab = p[a + 1] + zi; // 0 and 255. We then add y to it and plug that into p[], and add z to that.
var b = p[xi + 1] + yi; // Then, we get another random value by adding 1 to that and putting it into p[]
var ba = p[b] + zi; // and add z to it. We do the whole thing over again starting with x+1. Later
var
bb = p[b + 1] +
zi; // we plug aa, ab, ba, and bb back into p[] along with their +1's to get another set.
// in the end we have 8 values between 0 and 255 - one for each vertex on the unit cube.
// These are all interpolated together using u, v, and w below.
double x1, x2, y1, y2;
x1 = MathUtils.Lerp(
Grad(p[aa], xf, yf,
zf), // This is where the "magic" happens. We calculate a new set of p[] values and use that to get
Grad(p[ba], xf - 1, yf,
zf), // our final gradient values. Then, we interpolate between those gradients with the u value to get
u); // 4 x-values. Next, we interpolate between the 4 x-values with v to get 2 y-values. Finally,
x2 = MathUtils.Lerp(Grad(p[ab], xf, yf - 1, zf), // we interpolate between the y-values to get a z-value.
Grad(p[bb], xf - 1, yf - 1, zf),
u); // When calculating the p[] values, remember that above, p[a+1] expands to p[xi]+yi+1 -- so you are
y1 = MathUtils.Lerp(x1, x2,
v); // essentially adding 1 to yi. Likewise, p[ab+1] expands to p[p[xi]+yi+1]+zi+1] -- so you are adding
// to zi. The other 3 parameters are your possible return values (see Grad()), which are actually
x1 = MathUtils.Lerp(
Grad(p[aa + 1], xf, yf,
zf - 1), // the vectors from the edges of the unit cube to the point in the unit cube itself.
Grad(p[ba + 1], xf - 1, yf, zf - 1),
u);
x2 = MathUtils.Lerp(Grad(p[ab + 1], xf, yf - 1, zf - 1),
Grad(p[bb + 1], xf - 1, yf - 1, zf - 1),
u);
y2 = MathUtils.Lerp(x1, x2, v);
return
((MathUtils.Lerp(y1, y2, w) + 1) /
2); // For convenience we bound it to 0 - 1 (theoretical min/max before is -1 - 1)
}
private void ProcessFadeOut()
{
Last.Volume =
MathUtils.Lerp(Last.Volume, 0f, Game.LastFrameTime * FadeOutMultiplier);
if (!(Last.Volume <= 0.05f))
{
return;
}
IsDoingFadeOut = false;
Last.Stop();
}
private void resizeGameWindow()
{
int height = _editor.Editor.Settings.WindowSize.Height - 100;
if (_panel.Visible)
{
float panelWidth = MathUtils.Lerp(0f, 0f, _layer.IndependentResolution.Value.Width, _editor.Editor.Settings.WindowSize.Width, _panel.Width);
AGSEditor.Platform.SetHostedGameWindow(new Rectangle((int)Math.Round(panelWidth), 0, (int)Math.Round(_editor.Editor.Settings.WindowSize.Width - panelWidth), height));
}
else
{
AGSEditor.Platform.SetHostedGameWindow(new Rectangle(0, 0, _editor.Editor.Settings.WindowSize.Width, height));
}
}
private float EvalForTwoKeys(FSimpleCurveKey key1, FSimpleCurveKey key2, float inTime)
{
var diff = key2.Time - key1.Time;
if (diff > 0f && InterpMode != RCIM_Constant)
{
var alpha = (inTime - key1.Time) / diff;
var p0 = key1.Value;
var p3 = key2.Value;
return(MathUtils.Lerp(p0, p3, alpha));
}
return(key1.Value);
}
public void QueueDisc(Vector2 center, Vector2 radius, float depth, Color color, int sides = 32, float startAngle = 0f, float endAngle = (float)Math.PI * 2f)
{
Vector2 p = Vector2.Zero;
for (int i = 0; i <= sides; i++)
{
float x = MathUtils.Lerp(startAngle, endAngle, (float)i / (float)sides);
Vector2 vector = center + radius * new Vector2(MathUtils.Sin(x), 0f - MathUtils.Cos(x));
if (i > 0)
{
QueueTriangle(p, vector, center, depth, color);
}
p = vector;
}
}
private void Update(EvaluationContext context)
{
var deviceContext = _d3dDevice.ImmediateContext;
bool enabled = Enabled.GetValue(context);
bool logToConsole = LogToConsole.GetValue(context);
if (enabled && _readyToMeasure)
{
_queryTimeStampDisjoint.Begin(deviceContext);
_queryTimeStampFrameBegin.End(deviceContext);
}
Command.GetValue(context);
if (!enabled)
{
return;
}
if (_readyToMeasure)
{
_queryTimeStampFrameEnd.End(deviceContext);
_queryTimeStampDisjoint.End(deviceContext);
_readyToMeasure = false;
}
else
{
// check if last measurement is ready
bool dataFetched = true;
dataFetched &= _queryTimeStampDisjoint.GetData(deviceContext, AsynchronousFlags.None, out QueryDataTimestampDisjoint disjointData);
dataFetched &= _queryTimeStampFrameBegin.GetData(deviceContext, AsynchronousFlags.None, out long timeStampframeBegin);
dataFetched &= _queryTimeStampFrameEnd.GetData(deviceContext, AsynchronousFlags.None, out long timeStampframeEnd);
if (dataFetched && !disjointData.Disjoint)
{
float durationInS = (float)(timeStampframeEnd - timeStampframeBegin) / disjointData.Frequency;
int usDuration = (int)(durationInS * 1000f * 1000f);
if (logToConsole)
{
Log.Debug($"Subtree took: {usDuration}us on GPU.");
}
LastMeasureInMicroSeconds = usDuration;
_readyToMeasure = true;
}
LastMeasureInMs = MathUtils.Lerp(LastMeasureInMs, (float)(LastMeasureInMicroSeconds / 1000.0), 0.03f);
}
}
