private unsafe void CalculateRectangleVertices(UIImageDrawInfo *drawInfo, VertexPositionColorTextureSwizzle *vertex)
{
var currentPosition = drawInfo->LeftTopCornerWorld;
// snap first pixel to prevent possible problems when left/top is in the middle of a pixel
if (drawInfo->SnapImage)
{
var invW = 1.0f / currentPosition.W;
var backBufferHalfWidth = GraphicsContext.CommandList.RenderTarget.ViewWidth / 2;
var backBufferHalfHeight = GraphicsContext.CommandList.RenderTarget.ViewHeight / 2;
currentPosition.X *= invW;
currentPosition.Y *= invW;
currentPosition.X = (float)(Math.Round(currentPosition.X * backBufferHalfWidth) / backBufferHalfWidth);
currentPosition.Y = (float)(Math.Round(currentPosition.Y * backBufferHalfHeight) / backBufferHalfHeight);
currentPosition.X *= currentPosition.W;
currentPosition.Y *= currentPosition.W;
}
var textureCoordX = new Vector2(drawInfo->Source.Left, drawInfo->Source.Right);
var textureCoordY = new Vector2(drawInfo->Source.Top, drawInfo->Source.Bottom);
// set the two first line of vertices
for (var r = 0; r < 2; r++)
{
for (var c = 0; c < 2; c++)
{
vertex->ColorScale = drawInfo->ColorScale;
vertex->ColorAdd = drawInfo->ColorAdd;
vertex->Swizzle = (int)drawInfo->Swizzle;
vertex->TextureCoordinate.X = textureCoordX[c];
vertex->TextureCoordinate.Y = textureCoordY[r];
vertex->Position.X = currentPosition.X;
vertex->Position.Y = currentPosition.Y;
vertex->Position.Z = currentPosition.Z - currentPosition.W * drawInfo->DepthBias * DepthBiasShiftOneUnit;
vertex->Position.W = currentPosition.W;
if (drawInfo->SnapImage)
{
var backBufferHalfWidth = GraphicsContext.CommandList.RenderTarget.ViewWidth / 2;
var backBufferHalfHeight = GraphicsContext.CommandList.RenderTarget.ViewHeight / 2;
vertex->Position.X = (float)(Math.Round(vertex->Position.X * backBufferHalfWidth) / backBufferHalfWidth);
vertex->Position.Y = (float)(Math.Round(vertex->Position.Y * backBufferHalfHeight) / backBufferHalfHeight);
}
vertex++;
if (c == 0)
{
Vector4.Add(ref currentPosition, ref drawInfo->UnitXWorld, out currentPosition);
}
else
{
Vector4.Subtract(ref currentPosition, ref drawInfo->UnitXWorld, out currentPosition);
}
}
Vector4.Add(ref currentPosition, ref drawInfo->UnitYWorld, out currentPosition);
}
}
Position4 VS(Position4 input)
{
Vector2 v2 = new Vector2(1, 2);
Vector2 r2 = Vector2.Abs(v2);
r2 = Vector2.Add(v2, v2);
r2 = Vector2.Clamp(v2, v2, v2);
float r = Vector2.Distance(v2, v2);
r = Vector2.DistanceSquared(v2, v2);
r2 = Vector2.Divide(v2, v2);
r2 = Vector2.Divide(v2, r);
r = Vector2.Dot(v2, v2);
r2 = Vector2.Lerp(v2, v2, 0.75f);
r2 = Vector2.Max(v2, v2);
r2 = Vector2.Min(v2, v2);
r2 = Vector2.Multiply(v2, v2);
r2 = Vector2.Multiply(v2, r);
r2 = Vector2.Multiply(r, v2);
r2 = Vector2.Negate(v2);
r2 = Vector2.Normalize(v2);
r2 = Vector2.Reflect(v2, v2);
r2 = Vector2.SquareRoot(v2);
r2 = Vector2.Subtract(v2, v2);
r = v2.Length();
r = v2.LengthSquared();
Vector3 v3 = new Vector3(1, 2, 3);
Vector3 r3 = Vector3.Abs(v3);
r3 = Vector3.Add(v3, v3);
r3 = Vector3.Clamp(v3, v3, v3);
r3 = Vector3.Cross(v3, v3);
r = Vector3.Distance(v3, v3);
r = Vector3.DistanceSquared(v3, v3);
r3 = Vector3.Divide(v3, v3);
r3 = Vector3.Divide(v3, r);
r = Vector3.Dot(v3, v3);
r3 = Vector3.Lerp(v3, v3, 0.75f);
r3 = Vector3.Max(v3, v3);
r3 = Vector3.Min(v3, v3);
r3 = Vector3.Multiply(v3, v3);
r3 = Vector3.Multiply(v3, r);
r3 = Vector3.Multiply(r, v3);
r3 = Vector3.Negate(v3);
r3 = Vector3.Normalize(v3);
r3 = Vector3.Reflect(v3, v3);
r3 = Vector3.SquareRoot(v3);
r3 = Vector3.Subtract(v3, v3);
r = v3.Length();
r = v3.LengthSquared();
Vector4 v4 = new Vector4(1, 2, 3, 4);
Vector4 r4 = Vector4.Abs(v4);
r4 = Vector4.Add(v4, v4);
r4 = Vector4.Clamp(v4, v4, v4);
r = Vector4.Distance(v4, v4);
r = Vector4.DistanceSquared(v4, v4);
r4 = Vector4.Divide(v4, v4);
r4 = Vector4.Divide(v4, r);
r = Vector4.Dot(v4, v4);
r4 = Vector4.Lerp(v4, v4, 0.75f);
r4 = Vector4.Max(v4, v4);
r4 = Vector4.Min(v4, v4);
r4 = Vector4.Multiply(v4, v4);
r4 = Vector4.Multiply(v4, r);
r4 = Vector4.Multiply(r, v4);
r4 = Vector4.Negate(v4);
r4 = Vector4.Normalize(v4);
r4 = Vector4.SquareRoot(v4);
r4 = Vector4.Subtract(v4, v4);
r = v4.Length();
r = v4.LengthSquared();
return(input);
}
public override void Update(GameTime gameTime)
{
if (!isStarted)
{
return;
}
// UtilityHelper.ApplyVelocity(ref currentColor, Vector4.Multiply(velocity, Sign), gameTime);
Vector4 deltaDistance = graphFunction.ApplyVelocity(CurrentTime, CurrentTime.Add(gameTime.ElapsedGameTime), Duration, totalDistance);
CurrentTime = CurrentTime.Add(gameTime.ElapsedGameTime);
// if (CurrentTime > Duration) CurrentTime = TimeSpan.Zero;
deltaDistance = Vector4.Multiply(deltaDistance, Sign);
currentColor = Vector4.Add(currentColor, deltaDistance);
currentColor.X = MathHelper.Clamp(currentColor.X, Math.Min(fromColor.X, toColor.X), Math.Max(fromColor.X, toColor.X));
currentColor.Y = MathHelper.Clamp(currentColor.Y, Math.Min(fromColor.Y, toColor.Y), Math.Max(fromColor.Y, toColor.Y));
currentColor.Z = MathHelper.Clamp(currentColor.Z, Math.Min(fromColor.Z, toColor.Z), Math.Max(fromColor.Z, toColor.Z));
currentColor.W = MathHelper.Clamp(currentColor.W, Math.Min(fromColor.W, toColor.W), Math.Max(fromColor.W, toColor.W));
sprite.SetOverlay(currentColor);
if (isLoop)
{
int completed = 0;
if (currentColor.X == fromColor.X || currentColor.X == toColor.X)
{
Sign.X *= -1;
completed++;
}
if (currentColor.Y == fromColor.Y || currentColor.Y == toColor.Y)
{
Sign.Y *= -1;
completed++;
}
if (currentColor.Z == fromColor.Z || currentColor.Z == toColor.Z)
{
Sign.Z *= -1;
completed++;
}
if (currentColor.W == fromColor.W || currentColor.W == toColor.W)
{
Sign.W *= -1;
completed++;
}
if (completed == 4)
{
CurrentTime = TimeSpan.Zero;
}
}
else
{
if (currentColor.X == toColor.X && currentColor.Y == toColor.Y && currentColor.Z == toColor.Z && currentColor.W == toColor.W)
{
if (!isInfinite)
{
this.Stop();
}
return;
}
}
}
private unsafe void CalculateRectangleVertices(UIImageDrawInfo *drawInfo, VertexPositionColorTextureSwizzle *vertex)
{
var currentPosition = drawInfo->LeftTopCornerWorld;
// snap first pixel to prevent possible problems when left/top is in the middle of a pixel
if (drawInfo->SnapImage)
{
var invW = 1.0f / currentPosition.W;
var backBufferHalfWidth = GraphicsContext.CommandList.RenderTarget.ViewWidth / 2;
var backBufferHalfHeight = GraphicsContext.CommandList.RenderTarget.ViewHeight / 2;
currentPosition.X *= invW;
currentPosition.Y *= invW;
currentPosition.X = (float)(Math.Round(currentPosition.X * backBufferHalfWidth) / backBufferHalfWidth);
currentPosition.Y = (float)(Math.Round(currentPosition.Y * backBufferHalfHeight) / backBufferHalfHeight);
currentPosition.X *= currentPosition.W;
currentPosition.Y *= currentPosition.W;
}
float tcx0 = drawInfo->Source.Left;
float tcx1 = drawInfo->Source.Right;
float tcy0 = drawInfo->Source.Top;
float tcy1 = drawInfo->Source.Bottom;
// convert colors here instead of in the loop
Color4 colorScale = drawInfo->ColorScale;
float depthShift = drawInfo->DepthBias * DepthBiasShiftOneUnit;
// set the two first line of vertices
for (var r = 0; r < 2; r++)
{
// unroll this loop
// c = 0
vertex->ColorScale = colorScale;
vertex->Swizzle = (int)drawInfo->Swizzle;
vertex->TextureCoordinate.X = tcx0;
vertex->TextureCoordinate.Y = r == 0 ? tcy0 : tcy1;
vertex->Position.X = currentPosition.X;
vertex->Position.Y = currentPosition.Y;
vertex->Position.Z = currentPosition.Z - currentPosition.W * depthShift;
vertex->Position.W = currentPosition.W;
if (drawInfo->SnapImage)
{
var backBufferHalfWidth = GraphicsContext.CommandList.RenderTarget.ViewWidth / 2;
var backBufferHalfHeight = GraphicsContext.CommandList.RenderTarget.ViewHeight / 2;
vertex->Position.X = (float)(Math.Round(vertex->Position.X * backBufferHalfWidth) / backBufferHalfWidth);
vertex->Position.Y = (float)(Math.Round(vertex->Position.Y * backBufferHalfHeight) / backBufferHalfHeight);
}
vertex++;
Vector4.Add(ref currentPosition, ref drawInfo->UnitXWorld, out currentPosition);
// c = 1
vertex->ColorScale = colorScale;
vertex->Swizzle = (int)drawInfo->Swizzle;
vertex->TextureCoordinate.X = tcx1;
vertex->TextureCoordinate.Y = r == 0 ? tcy0 : tcy1;
vertex->Position.X = currentPosition.X;
vertex->Position.Y = currentPosition.Y;
vertex->Position.Z = currentPosition.Z - currentPosition.W * depthShift;
vertex->Position.W = currentPosition.W;
if (drawInfo->SnapImage)
{
var backBufferHalfWidth = GraphicsContext.CommandList.RenderTarget.ViewWidth / 2;
var backBufferHalfHeight = GraphicsContext.CommandList.RenderTarget.ViewHeight / 2;
vertex->Position.X = (float)(Math.Round(vertex->Position.X * backBufferHalfWidth) / backBufferHalfWidth);
vertex->Position.Y = (float)(Math.Round(vertex->Position.Y * backBufferHalfHeight) / backBufferHalfHeight);
}
vertex++;
Vector4.Subtract(ref currentPosition, ref drawInfo->UnitXWorld, out currentPosition);
Vector4.Add(ref currentPosition, ref drawInfo->UnitYWorld, out currentPosition);
}
}
public Vector4 AddFunctionBenchmark() => Vector4.Add(VectorTests.Vector4Value, VectorTests.Vector4Delta);
SystemPosition4 VS(Position4 input)
{
Matrix4x4 testMatrix = new Matrix4x4(
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
Vector2 v2 = new Vector2(1, 2);
Vector2 r2 = Vector2.Abs(v2);
r2 = Vector2.Add(v2, v2);
r2 = Vector2.Clamp(v2, v2, v2);
float r = Vector2.Distance(v2, v2);
r = Vector2.DistanceSquared(v2, v2);
r2 = Vector2.Divide(v2, v2);
r2 = Vector2.Divide(v2, r);
r = Vector2.Dot(v2, v2);
r2 = Vector2.Lerp(v2, v2, 0.75f);
r2 = Vector2.Max(v2, v2);
r2 = Vector2.Min(v2, v2);
r2 = Vector2.Multiply(v2, v2);
r2 = Vector2.Multiply(v2, r);
r2 = Vector2.Multiply(r, v2);
r2 = Vector2.Negate(v2);
r2 = Vector2.Normalize(v2);
r2 = Vector2.Reflect(v2, v2);
r2 = Vector2.SquareRoot(v2);
r2 = Vector2.Subtract(v2, v2);
r = v2.Length();
r = v2.LengthSquared();
r2 = Vector2.Transform(v2, testMatrix);
Vector3 v3 = new Vector3(1, 2, 3);
Vector3 r3 = Vector3.Abs(v3);
r3 = Vector3.Add(v3, v3);
r3 = Vector3.Clamp(v3, v3, v3);
r3 = Vector3.Cross(v3, v3);
r = Vector3.Distance(v3, v3);
r = Vector3.DistanceSquared(v3, v3);
r3 = Vector3.Divide(v3, v3);
r3 = Vector3.Divide(v3, r);
r = Vector3.Dot(v3, v3);
r3 = Vector3.Lerp(v3, v3, 0.75f);
r3 = Vector3.Max(v3, v3);
r3 = Vector3.Min(v3, v3);
r3 = Vector3.Multiply(v3, v3);
r3 = Vector3.Multiply(v3, r);
r3 = Vector3.Multiply(r, v3);
r3 = Vector3.Negate(v3);
r3 = Vector3.Normalize(v3);
r3 = Vector3.Reflect(v3, v3);
r3 = Vector3.SquareRoot(v3);
r3 = Vector3.Subtract(v3, v3);
r = v3.Length();
r = v3.LengthSquared();
r3 = Vector3.Transform(v3, testMatrix);
Vector4 v4 = new Vector4(1, 2, 3, 4);
Vector4 r4 = Vector4.Abs(v4);
r4 = Vector4.Add(v4, v4);
r4 = Vector4.Clamp(v4, v4, v4);
r = Vector4.Distance(v4, v4);
r = Vector4.DistanceSquared(v4, v4);
r4 = Vector4.Divide(v4, v4);
r4 = Vector4.Divide(v4, r);
r = Vector4.Dot(v4, v4);
r4 = Vector4.Lerp(v4, v4, 0.75f);
r4 = Vector4.Max(v4, v4);
r4 = Vector4.Min(v4, v4);
r4 = Vector4.Multiply(v4, v4);
r4 = Vector4.Multiply(v4, r);
r4 = Vector4.Multiply(r, v4);
r4 = Vector4.Negate(v4);
r4 = Vector4.Normalize(v4);
r4 = Vector4.SquareRoot(v4);
r4 = Vector4.Subtract(v4, v4);
r = v4.Length();
r = v4.LengthSquared();
r4 = Vector4.Transform(v2, testMatrix);
r4 = Vector4.Transform(v3, testMatrix);
r4 = Vector4.Transform(v4, testMatrix);
SystemPosition4 output;
output.Position = input.Position;
return(output);
}
public override Vector4 Add(Vector4 from, Vector4 to)
{
return(Vector4.Add(from, to));
}
public override void Transform(ref Vector4 v, out Vector4 res)
{
var _o = new Vector4(_offset, 0);
Vector4.Add(ref v, ref _o, out res);
}
static async Task Main(string[] args)
{
var surfaceSize = new Size(640, 400);
var pixelScaling = 3;
var window = new SdlWindow(surfaceSize * pixelScaling);
var controls = new Controls(window);
var cameraPos = Vector4.Zero;
var cameraRot = Matrix4.Identity;
var focalLength = window.Height / 2.0f / pixelScaling;
var circles = new Hypersphere[8];
var rnd = new Random(1);
for (int i = 0; i < circles.Length; i++)
{
var w = rnd.Next(-5.0f, 5.0f);
var x = rnd.Next(-12.0f, 12.0f);
var y = rnd.Next(-12.0f, 12.0f);
var z = rnd.Next(-12.0f, 12.0f);
var position = Vector4.Forward * 16 + new Vector4(w, x, y, z);
var radius = rnd.Next(4.0f, 6.0f);
circles[i] = new Hypersphere(position, radius);
}
window.Update += (delta) => {
var mouseSensitivity = 0.2f;
var moveSpeed = 5.0f * (float)delta.TotalSeconds;
if (controls.FourDimensionalMove)
{
var roll = Deg2Rad(controls.MouseMotion.X) * mouseSensitivity;
var w = Deg2Rad(controls.MouseMotion.Y) * mouseSensitivity;
var rollRot = new Matrix4(
1, 0, 0, 0,
0, Cos(roll), 0, -Sin(roll),
0, 0, 1, 0,
0, Sin(roll), 0, Cos(roll));
var wRot = new Matrix4(
Cos(w), 0, -Sin(w), 0,
0, 1, 0, 0,
Sin(w), 0, Cos(w), 0,
0, 0, 0, 1);
cameraRot = cameraRot * rollRot * wRot;
if (controls.Up)
{
cameraPos += cameraRot * Vector4.UnitW * moveSpeed;
}
if (controls.Down)
{
cameraPos += cameraRot * -Vector4.UnitW * moveSpeed;
}
}
if (controls.TraditionalMove)
{
var yaw = Deg2Rad(controls.MouseMotion.X) * mouseSensitivity;
var pitch = -Deg2Rad(controls.MouseMotion.Y) * mouseSensitivity;
var yawRot = new Matrix4(
1, 0, 0, 0,
0, Cos(yaw), -Sin(yaw), 0,
0, Sin(yaw), Cos(yaw), 0,
0, 0, 0, 1);
var pitchRot = new Matrix4(
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, Cos(pitch), -Sin(pitch),
0, 0, Sin(pitch), Cos(pitch));
cameraRot = cameraRot * pitchRot * yawRot;
if (controls.Forward)
{
cameraPos += cameraRot * Vector4.Forward * moveSpeed;
}
if (controls.Back)
{
cameraPos += cameraRot * Vector4.Back * moveSpeed;
}
if (controls.Right)
{
cameraPos += cameraRot * Vector4.Right * moveSpeed;
}
if (controls.Left)
{
cameraPos += cameraRot * Vector4.Left * moveSpeed;
}
if (controls.Up)
{
cameraPos += cameraRot * Vector4.Up * moveSpeed;
}
if (controls.Down)
{
cameraPos += cameraRot * Vector4.Down * moveSpeed;
}
}
controls.ResetMouseMotion();
return(Task.CompletedTask);
};
window.Render += async(delta) => {
var forward = cameraRot * Vector4.Forward;
var stepRight = cameraRot * Vector4.Right;
var stepDown = cameraRot * Vector4.Down;
var width = window.Width / pixelScaling;
var height = window.Height / pixelScaling;
IEnumerable <Rectangle> SplitScreen(int size)
{
for (var x = 0; x < width; x += size)
{
for (var y = 0; y < height; y += size)
{
yield return(new Rectangle(x, y, Math.Min(width, x + size), Math.Min(height, y + size)));
}
}
}
await Task.WhenAll(SplitScreen(32).Select(rect => Task.Run(() => {
var rayTmp = default(Ray);
var ray = new Ray(cameraPos,
forward *focalLength
- stepRight * (width / 2 - rect.Left)
- stepDown * (height / 2 - rect.Top));
for (var x = rect.Left; x < rect.Right; x++)
{
Vector4.Add(ref ray.Direction, stepRight);
rayTmp = ray;
for (var y = rect.Top; y < rect.Bottom; y++)
{
Vector4.Add(ref ray.Direction, stepDown);
float?tMin = null;
int foundIndex = -1;
for (var i = 0; i < circles.Length; i++)
{
if ((circles[i].Intersect(ray) is float tCur) && !(tCur > tMin))
{
tMin = tCur;
foundIndex = i;
}
}
if (tMin is float t)
{
var hit = ray.Origin + ray.Direction *t;
var normal = circles[foundIndex].CalculateNormal(hit);
var color = new Color(Math.Abs(normal.X), Math.Abs(normal.Y), Math.Abs(normal.Z));
for (var xx = 0; xx < pixelScaling; xx++)
{
for (var yy = 0; yy < pixelScaling; yy++)
{
window.Surface[x *pixelScaling + xx, y *pixelScaling + yy] = color;
}
}
}
}
ray = rayTmp;
}
})));
};
await window.Run();
}
public override Vector4 Add(Vector4 left, Vector4 right) => Vector4.Add(left, right);
SystemPosition4 VS(Position4 input)
{
Vector2 r2 = Vector2.Abs(VH.V2);
r2 = Vector2.Add(VH.V2, VH.V2);
r2 = Vector2.Clamp(VH.V2, VH.V2, VH.V2);
float r = Vector2.Distance(VH.V2, VH.V2);
r = Vector2.DistanceSquared(VH.V2, VH.V2);
r2 = Vector2.Divide(VH.V2, VH.V2);
r2 = Vector2.Divide(VH.V2, r);
r = Vector2.Dot(VH.V2, VH.V2);
r2 = Vector2.Lerp(VH.V2, VH.V2, 0.75f);
r2 = Vector2.Max(VH.V2, VH.V2);
r2 = Vector2.Min(VH.V2, VH.V2);
r2 = Vector2.Multiply(VH.V2, VH.V2);
r2 = Vector2.Multiply(VH.V2, r);
r2 = Vector2.Multiply(r, VH.V2);
r2 = Vector2.Negate(VH.V2);
r2 = Vector2.Normalize(VH.V2);
r2 = Vector2.Reflect(VH.V2, VH.V2);
r2 = Vector2.SquareRoot(VH.V2);
r2 = Vector2.Subtract(VH.V2, VH.V2);
r = VH.V2.Length();
r = VH.V2.LengthSquared();
r2 = Vector2.Transform(VH.V2, VH.M4x4);
Vector3 V3 = new Vector3(1, 2, 3);
Vector3 r3 = Vector3.Abs(VH.V3);
r3 = Vector3.Add(VH.V3, VH.V3);
r3 = Vector3.Clamp(VH.V3, VH.V3, VH.V3);
r3 = Vector3.Cross(VH.V3, VH.V3);
r = Vector3.Distance(VH.V3, VH.V3);
r = Vector3.DistanceSquared(VH.V3, VH.V3);
r3 = Vector3.Divide(VH.V3, VH.V3);
r3 = Vector3.Divide(VH.V3, r);
r = Vector3.Dot(VH.V3, VH.V3);
r3 = Vector3.Lerp(VH.V3, VH.V3, 0.75f);
r3 = Vector3.Max(VH.V3, VH.V3);
r3 = Vector3.Min(VH.V3, VH.V3);
r3 = Vector3.Multiply(VH.V3, VH.V3);
r3 = Vector3.Multiply(VH.V3, r);
r3 = Vector3.Multiply(r, VH.V3);
r3 = Vector3.Negate(VH.V3);
r3 = Vector3.Normalize(VH.V3);
r3 = Vector3.Reflect(VH.V3, VH.V3);
r3 = Vector3.SquareRoot(VH.V3);
r3 = Vector3.Subtract(VH.V3, VH.V3);
r = VH.V3.Length();
r = VH.V3.LengthSquared();
r3 = Vector3.Transform(VH.V3, VH.M4x4);
Vector4 V4 = new Vector4(1, 2, 3, 4);
Vector4 r4 = Vector4.Abs(VH.V4);
r4 = Vector4.Add(VH.V4, VH.V4);
r4 = Vector4.Clamp(VH.V4, VH.V4, VH.V4);
r = Vector4.Distance(VH.V4, VH.V4);
r = Vector4.DistanceSquared(VH.V4, VH.V4);
r4 = Vector4.Divide(VH.V4, VH.V4);
r4 = Vector4.Divide(VH.V4, r);
r = Vector4.Dot(VH.V4, VH.V4);
r4 = Vector4.Lerp(VH.V4, VH.V4, 0.75f);
r4 = Vector4.Max(VH.V4, VH.V4);
r4 = Vector4.Min(VH.V4, VH.V4);
r4 = Vector4.Multiply(VH.V4, VH.V4);
r4 = Vector4.Multiply(VH.V4, r);
r4 = Vector4.Multiply(r, VH.V4);
r4 = Vector4.Negate(VH.V4);
r4 = Vector4.Normalize(VH.V4);
r4 = Vector4.SquareRoot(VH.V4);
r4 = Vector4.Subtract(VH.V4, VH.V4);
r = VH.V4.Length();
r = VH.V4.LengthSquared();
r4 = Vector4.Transform(VH.V2, VH.M4x4);
r4 = Vector4.Transform(VH.V3, VH.M4x4);
r4 = Vector4.Transform(VH.V4, VH.M4x4);
SystemPosition4 output;
output.Position = input.Position;
return(output);
}
public Vector4 TempFixedUpdate(float timeElapsed)
{
return(Vector4.Add(position, Vector4.Multiply(velocity, timeElapsed)));
}
public void FixedUpdate(float timeElapsed)
{
position = Vector4.Add(position, Vector4.Multiply(velocity, timeElapsed));
}
internal override void Process(RegisterFile <Vector4> vRF, RegisterFile <Scalar> sRF, Memory mem, IntersectionCore ic)
{
Vector4 vec = new Vector4(sRF[r2].f, sRF[r2].f, sRF[r2].f, sRF[r2].f);
vRF[r0] = Vector4.Add(vRF[r1], vec);
}
private void FillBlobVB(Matrix pmatWorldView, Matrix pmatProjection)
{
ScreenVertex[] pBlobVertex = (ScreenVertex[])pBlobVB.Lock(0, LockFlags.None);
PointVertex[] blobPos = new PointVertex[blobPoints.Length];
for (int i = 0; i < blobPoints.Length; i++)
{
//transform point to camera space
Vector4 blobPosCamera = Vector3.Transform(blobPoints[i].pos, pmatWorldView);
blobPos[i] = blobPoints[i];
blobPos[i].pos.X = blobPosCamera.X;
blobPos[i].pos.Y = blobPosCamera.Y;
blobPos[i].pos.Z = blobPosCamera.Z;
}
int posCount = 0;
for (int i = 0; i < blobPoints.Length; i++)
{
Vector4 blobScreenPos;
// For calculating billboarding
Vector4 billOfs = new Vector4(blobPos[i].size, blobPos[i].size, blobPos[i].pos.Z, 1);
Vector4 billOfsScreen;
// Transform to screenspace
blobScreenPos = Vector3.Transform(blobPos[i].pos, pmatProjection);
billOfsScreen = Vector4.Transform(billOfs, pmatProjection);
// Project
blobScreenPos = Vector4.Scale(blobScreenPos, 1.0f / blobScreenPos.W);
billOfsScreen = Vector4.Scale(billOfsScreen, 1.0f / billOfsScreen.W);
Vector2[] vTexCoords = new Vector2[]
{
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 1.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 0.0f),
new Vector2(1.0f, 1.0f)
};
Vector4[] vPosOffset = new Vector4[]
{
new Vector4(-billOfsScreen.X, -billOfsScreen.Y, 0.0f, 0.0f),
new Vector4(billOfsScreen.X, -billOfsScreen.Y, 0.0f, 0.0f),
new Vector4(-billOfsScreen.X, billOfsScreen.Y, 0.0f, 0.0f),
new Vector4(-billOfsScreen.X, billOfsScreen.Y, 0.0f, 0.0f),
new Vector4(billOfsScreen.X, -billOfsScreen.Y, 0.0f, 0.0f),
new Vector4(billOfsScreen.X, billOfsScreen.Y, 0.0f, 0.0f)
};
SurfaceDescription pBackBufferSurfaceDesc = device.GetBackBuffer(0, 0, BackBufferType.Mono).Description;
// Set constants across quad
for (int j = 0; j < 6; j++)
{
// Scale to pixels
pBlobVertex[posCount].pos = Vector4.Add(blobScreenPos, vPosOffset[j]);
pBlobVertex[posCount].pos.X *= pBackBufferSurfaceDesc.Width;
pBlobVertex[posCount].pos.Y *= pBackBufferSurfaceDesc.Height;
pBlobVertex[posCount].pos.X += 0.5f * pBackBufferSurfaceDesc.Width;
pBlobVertex[posCount].pos.Y += 0.5f * pBackBufferSurfaceDesc.Height;
pBlobVertex[posCount].tCurr = vTexCoords[j];
pBlobVertex[posCount].tBack = new Vector2((0.5f + pBlobVertex[posCount].pos.X) * (1.0f / pBackBufferSurfaceDesc.Width),
(0.5f + pBlobVertex[posCount].pos.Y) * (1.0f / pBackBufferSurfaceDesc.Height));
pBlobVertex[posCount].fSize = blobPos[i].size;
pBlobVertex[posCount].vColor = blobPos[i].color;
posCount++;
}
}
pBlobVB.Unlock();
}
public void ExecuteTest(Operations operation, int innerIterations, Vector4 v1, Vector4 v2)
{
Vector4 res;
switch (operation)
{
case Operations.Add_Operator:
for (int i = 0; i < innerIterations; i++)
{
res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2;
}
break;
case Operations.Add_Function:
for (int i = 0; i < innerIterations; i++)
{
Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2); Vector4.Add(v1, v2);
}
break;
case Operations.Sub_Operator:
for (int i = 0; i < innerIterations; i++)
{
res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2;
}
break;
case Operations.Sub_Function:
for (int i = 0; i < innerIterations; i++)
{
Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2); Vector4.Subtract(v1, v2);
}
break;
case Operations.Mul_Operator:
for (int i = 0; i < innerIterations; i++)
{
res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2;
}
break;
case Operations.Mul_Function:
for (int i = 0; i < innerIterations; i++)
{
Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2); Vector4.Multiply(v1, v2);
}
break;
case Operations.Dot:
for (int i = 0; i < innerIterations; i++)
{
Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2); Vector4.Dot(v1, v2);
}
break;
case Operations.SquareRoot:
for (int i = 0; i < innerIterations; i++)
{
Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1); Vector4.SquareRoot(v1);
}
break;
case Operations.Length_Squared:
for (int i = 0; i < innerIterations; i++)
{
v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared();
}
break;
case Operations.Normalize:
for (int i = 0; i < innerIterations; i++)
{
Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1); Vector4.Normalize(v1);
}
break;
case Operations.Distance_Squared:
for (int i = 0; i < innerIterations; i++)
{
Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2); Vector4.DistanceSquared(v1, v2);
}
break;
}
}
internal override void Process(RegisterFile <Vector4> vRF, RegisterFile <Scalar> sRF, Memory mem, IntersectionCore ic)
{
vRF[r0] = Vector4.Add(vRF[r1], vRF[r2]);
}
/// <inheritdoc/>
public void Add(ref Vector4 value0, ref Vector4 value1, ref Vector4 result)
{
Vector4.Add(ref value0, ref value1, out result);
}
