//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="CascadedShadow"/> class. /// </summary> public CascadedShadow() { NumberOfCascades = 4; Distances = new Vector4F(4, 12, 20, 80); MinLightDistance = 100; DepthBias = new Vector4F(5); NormalOffset = new Vector4F(2); NumberOfSamples = -1; FilterRadius = 1; JitterResolution = 2048; FadeOutRange = 0.1f; ShadowFog = 0; #if XBOX CascadeSelection = ShadowCascadeSelection.Fast; #else CascadeSelection = ShadowCascadeSelection.Best; #endif IsCascadeLocked = new[] { false, false, false, false }; #pragma warning disable 618 SplitDistribution = 0.9f; FadeOutDistance = 50; MaxDistance = 70; DepthBiasScale = new Vector4F(0.99f); DepthBiasOffset = new Vector4F(-0.001f); #pragma warning restore 618 }
public void Addition() { Vector4F a = new Vector4F(1.0f, 2.0f, 3.0f, 4.0f); Vector4F b = new Vector4F(2.0f, 3.0f, 4.0f, 5.0f); Vector4F c = Vector4F.Add(a, b); Assert.AreEqual(new Vector4F(3.0f, 5.0f, 7.0f, 9.0f), c); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="GradientTextureSkyNode" /> class. /// </summary> public GradientTextureSkyNode() { SunDirection = new Vector3F(1, 1, 1); TimeOfDay = new TimeSpan(12, 0, 0); Color = new Vector4F(1, 1, 1, 1); CieSkyParameters = CieSkyParameters.Type12; }
public void AdditionOperator() { Vector4F a = new Vector4F(1.0f, 2.0f, 3.0f, 4.0f); Vector4F b = new Vector4F(2.0f, 3.0f, 4.0f, 5.0f); Vector4F c = a + b; Assert.AreEqual(new Vector4F(3.0f, 5.0f, 7.0f, 9.0f), c); }
public void IdentityTest() { var traits = Vector4FTraits.Instance; var value = new Vector4F(-1, -2, 3, 1); Assert.AreEqual(value, traits.Add(value, traits.Identity())); Assert.AreEqual(value, traits.Add(traits.Identity(), value)); }
public void Normalize() { Vector4F v, n1, n2; float magnitude; v = new Vector4F(3.0f, 4.0f, 0.0f, 0.0f); n1 = v.Normalize(); n2 = v.Normalize(out magnitude); Assert.AreEqual(1.0f, n1.Magnitude, 1e-14); Assert.AreEqual(1.0f, n2.Magnitude, 1e-14); Assert.AreEqual(5.0f, magnitude, 1e-14); v = new Vector4F(3.0f, 0.0f, 4.0f, 0.0f); n1 = v.Normalize(); n2 = v.Normalize(out magnitude); Assert.AreEqual(1.0f, n1.Magnitude, 1e-14); Assert.AreEqual(1.0f, n2.Magnitude, 1e-14); Assert.AreEqual(5.0f, magnitude, 1e-14); v = new Vector4F(0.0f, 3.0f, 4.0f, 0.0f); n1 = v.Normalize(); n2 = v.Normalize(out magnitude); Assert.AreEqual(1.0f, n1.Magnitude, 1e-14); Assert.AreEqual(1.0f, n2.Magnitude, 1e-14); Assert.AreEqual(5.0f, magnitude, 1e-14); v = new Vector4F(0.0f, 0.0f, 3.0f, 4.0f); n1 = v.Normalize(); n2 = v.Normalize(out magnitude); Assert.AreEqual(1.0f, n1.Magnitude, 1e-14); Assert.AreEqual(1.0f, n2.Magnitude, 1e-14); Assert.AreEqual(5.0f, magnitude, 1e-14); }
public void Construct2() { Vector4F v = new Vector4F(new Vector2F(1.0f, 2.0f), 3.0f, 4.0f); Assert.AreEqual(1.0f, v.X); Assert.AreEqual(2.0f, v.Y); Assert.AreEqual(3.0f, v.Z); Assert.AreEqual(4.0f, v.W); }
public void InterpolationTest() { var traits = Vector4FTraits.Instance; var value0 = new Vector4F(1, 2, 3, 1); var value1 = new Vector4F(-4, 5, -6, 5); Assert.IsTrue(Vector4F.AreNumericallyEqual(value0, traits.Interpolate(value0, value1, 0.0f))); Assert.IsTrue(Vector4F.AreNumericallyEqual(value1, traits.Interpolate(value0, value1, 1.0f))); Assert.IsTrue(Vector4F.AreNumericallyEqual(0.25f * value0 + 0.75f * value1, traits.Interpolate(value0, value1, 0.75f))); }
public static Vector4F VectorMultiply(Matrix4x4F a, Vector4F b) { return new Vector4F( a.M11 * b.X + a.M21 * b.Y + a.M31 * b.Z + a.M41 * b.W, a.M12 * b.X + a.M22 * b.Y + a.M32 * b.Z + a.M42 * b.W, a.M13 * b.X + a.M23 * b.Y + a.M33 * b.Z + a.M43 * b.W, a.M14 * b.X + a.M24 * b.Y + a.M34 * b.Z + a.M44 * b.W ); }
public static UnityEngine.Vector3 ToUnityVector(Vector4F vector4F) { if (!vector4F.W.NearlyEquals(1)) { Debug.Log("Losing accuracy on " + vector4F + " conversion, as w is not one!"); } return(new UnityEngine.Vector3(vector4F.X, vector4F.Y, vector4F.Z)); }
public static Vector4F CrossProduct3D(Vector4FParam1_3 left, Vector4FParam1_3 right) { if (Sse.IsSupported) { #region Comments /* Cross product of A(x, y, z, _) and B(x, y, z, _) is * 0 1 2 3 0 1 2 3 * * '(X = (Ay * Bz) - (Az * By), Y = (Az * Bx) - (Ax * Bz), Z = (Ax * By) - (Ay * Bx)' * 1 2 1 2 1 2 * So we can do (Ay, Az, Ax, _) * (Bz, Bx, By, _) (last elem is irrelevant, as this is for Vector3) * which leaves us with a of the first subtraction element for each (marked 1 above) * Then we repeat with the right hand of subtractions (Az, Ax, Ay, _) * (By, Bz, Bx, _) * which leaves us with the right hand sides (marked 2 above) * Then we subtract them to get the correct vector * We then mask out W to zero, because that is required for the Vector3 representation * * We perform the first 2 multiplications by shuffling the vectors and then multiplying them * Helpers.Shuffle is the same as the C++ macro _MM_SHUFFLE, and you provide the order you wish the elements * to be in *reversed* (no clue why), so here (3, 0, 2, 1) means you have the 2nd elem (1, 0 indexed) in the first slot, * the 3rd elem (2) in the next one, the 1st elem (0) in the next one, and the 4th (3, W/_, unused here) in the last reg */ #endregion /* * lhs1 goes from x, y, z, _ to y, z, x, _ * rhs1 goes from x, y, z, _ to z, x, y, _ */ Vector4F leftHandSide1 = Sse.Shuffle(left, left, Helpers.Shuffle(3, 0, 2, 1)); Vector4F rightHandSide1 = Sse.Shuffle(right, right, Helpers.Shuffle(3, 1, 0, 2)); /* * lhs2 goes from x, y, z, _ to z, x, y, _ * rhs2 goes from x, y, z, _ to y, z, x, _ */ Vector4F leftHandSide2 = Sse.Shuffle(left, left, Helpers.Shuffle(3, 1, 0, 2)); Vector4F rightHandSide2 = Sse.Shuffle(right, right, Helpers.Shuffle(3, 0, 2, 1)); Vector4F mul1 = Sse.Multiply(leftHandSide1, rightHandSide1); Vector4F mul2 = Sse.Multiply(leftHandSide2, rightHandSide2); Vector4F resultNonMaskedW = Sse.Subtract(mul1, mul2); return(Sse.And(resultNonMaskedW, MaskW)); // TODO reuse vectors (minimal register usage) - potentially prevent any stack spilling } return(CrossProduct3D_Software(left, right)); }
/// <summary> /// Initializes a new instance of the <see cref="RenderState"/> class. /// </summary> public RenderState() { FlagsMode = RenderStateFlagsMode.Opaque; FlagsBlendMode = RenderStateFlagsBlendMode.None; PolygonControl = new PolygonControl() { CullBack = false, CullFront = false, FrontFace = GX2FrontFaceMode.CounterClockwise, PolygonModeBack = GX2PolygonMode.Triangle, PolygonModeFront = GX2PolygonMode.Triangle, PolygonOffsetBackEnabled = false, PolygonOffsetFrontEnabled = false, PolygonLineOffsetEnabled = false, PolygonModeEnabled = true, }; AlphaControl = new AlphaControl() { AlphaFunc = GX2CompareFunction.GreaterOrEqual, }; DepthControl = new DepthControl() { BackStencilEnabled = false, BackStencilFail = GX2StencilFunction.Replace, BackStencilFunc = GX2CompareFunction.Always, BackStencilZFail = GX2StencilFunction.Replace, BackStencilZPass = GX2StencilFunction.Replace, DepthFunc = GX2CompareFunction.LessOrEqual, DepthTestEnabled = true, DepthWriteEnabled = true, FrontStencilFail = GX2StencilFunction.Replace, FrontStencilFunc = GX2CompareFunction.Always, FrontStencilZFail = GX2StencilFunction.Replace, FrontStencilZPass = GX2StencilFunction.Replace, StencilTestEnabled = false, }; AlphaRefValue = 0.5F; BlendControl = new BlendControl() { AlphaCombine = GX2BlendCombine.Add, AlphaDestinationBlend = GX2BlendFunction.Zero, AlphaSourceBlend = GX2BlendFunction.Zero, ColorCombine = GX2BlendCombine.Add, ColorDestinationBlend = GX2BlendFunction.OneMinusSourceAlpha, ColorSourceBlend = GX2BlendFunction.SourceAlpha, SeparateAlphaBlend = true, }; BlendColor = new Vector4F(0, 0, 0, 0); }
public void example_2() { var left = new Vector4F(1.0f, 3.0f, 4.0f, 9.0f); var right = new Vector4F(-2.0f, 5.6f, -9.0f, 0.1f); var expected = 1.7537363654297111f; var actual = left.GetAngleBetween(right); Assert.Equal(expected, actual, 10); }
public void opposite_vector_angle_is_pi() { var left = new Vector4F(14.0f, 98, -19, 88); var right = left.GetNegative(); var expected = (float)Math.PI; var actual = left.GetAngleBetween(right); Assert.Equal(expected, actual, 10); }
public static Vector4F Divide(Vector4FParam1_3 dividend, float scalarDivisor) { if (Sse.IsSupported) { Vector4F expand = Vector128.Create(scalarDivisor); return(Sse.Divide(dividend, expand)); } return(SoftwareFallbacks.SoftwareFallbacksVector4F.Divide_Software(dividend, scalarDivisor)); }
public void right_angle_is_half_pi() { var left = new Vector4F(1.0f, 0, 1, 0); var right = new Vector4F(0.0f, 1, 0, 1); var expected = (float)(Math.PI / 2.0); var actual = left.GetAngleBetween(right); Assert.Equal(expected, actual, 10); }
public void projecting_against_zero_results_in_same_vector() { var u = new Vector4F(); var v = new Vector4F(-3.0f, 8, 5, -10); var expected = new Vector4F(v); var actual = u.GetProjected(v); Assert.Equal(expected, actual); }
public void projection_example_1() { var u = new Vector4F(-1.0f, 2, 1, 3); var v = new Vector4F(2.0f, -1, 3, 1); var expected = u.GetScaled(2.0f / 15.0f); var actual = u.GetProjected(v); Assert.Equal(expected, actual); }
public void can_find_distance() { var a = new Vector4F(1.0f, -2, 3, 0); var b = new Vector4F(4.0f, 0, -3, 5); var expected = (float)Math.Sqrt(74); var actual = a.GetDistance(b); Assert.Equal(expected, actual); }
public void can_find_distance() { var a = new Vector4F(1.0f, -2, 3, 0); var b = new Vector4F(4.0f, 0, -3, 5); var expected = 74.0f; var actual = a.GetDistanceSquared(b); Assert.Equal(expected, actual); }
public void adding_vector_produces_sum_vector() { var left = new Vector4F(1.0f, 2, 10, -4); var right = new Vector4F(3.0f, 4, 11, 1); var expected = new Vector4F(4.0f, 6, 21, -3); var actual = left.GetSum(right); Assert.Equal(expected, actual); }
public void adding_vector_adds_to_components() { var actual = new Vector4F(1.0f, 2, 10, -4); var right = new Vector4F(3.0f, 4, 11, 1); var expected = new Vector4F(4.0f, 6, 21, -3); actual.Add(right); Assert.Equal(expected, actual); }
public void op_multiply_scalar_mimics_scale_first() { var vector = new Vector4F(1.0f, 2, 3, 4); var scalar = 2.4f; var expected = vector.GetScaled(scalar); var actual = scalar * vector; Assert.Equal(expected, actual); }
public void op_multiply_scalar_mimics_divide() { var vector = new Vector4F(1.0f, 2, 3, 4); var divisor = 2.4f; var expected = vector.GetQuotient(divisor); var actual = vector / divisor; Assert.Equal(expected, actual); }
public void op_multiply_mimics_dot() { var left = new Vector4F(1.0f, 2, 4, 5); var right = new Vector4F(-3.0f, -100, 40, 52); var expected = left.GetDot(right); var actual = left * right; Assert.Equal(expected, actual); }
public void op_subtraction_mimics_subtract() { var left = new Vector4F(1.0f, 2, 4, 5); var right = new Vector4F(-3.0f, -100, 40, 52); var expected = left.GetDifference(right); var actual = left - right; Assert.Equal(expected, actual); }
public void op_addition_mimics_add() { var left = new Vector4F(1.0f, 2, 4, 5); var right = new Vector4F(-3.0f, -100, 40, 52); var expected = left.GetSum(right); var actual = left + right; Assert.Equal(expected, actual); }
public void example_1() { var left = new Vector4F(1.0f, 0, 0, 0); var right = new Vector4F(1.0f, 0, 1, 0); var expected = (float)Math.Acos(1.0 / Math.Sqrt(2.0)); var actual = left.GetAngleBetween(right); Assert.Equal(expected, actual, 5); }
public void adding_vectors_leaves_right_unchanged() { var left = new Vector4F(1.0f, 2, 10, -4); var right = new Vector4F(3.0f, 4, 11, 1); var expectedRight = new Vector4F(right); left.Add(right); Assert.Equal(expectedRight, right); }
/// <inheritdoc/> public void Interpolate(ref Vector4F source, ref Vector4F target, float parameter, ref Vector4F result) { //result = source + (target - source) * parameter; // Optimized by inlining. result.X = source.X + (target.X - source.X) * parameter; result.Y = source.Y + (target.Y - source.Y) * parameter; result.Z = source.Z + (target.Z - source.Z) * parameter; result.W = source.W + (target.W - source.W) * parameter; }
public void subtracting_vector_produces_diff_vector() { var left = new Vector4F(1.0f, 15, 5, 3); var right = new Vector4F(3.0f, 2, 10, 1); var expected = new Vector4F(-2.0f, 13, -5, 2); var actual = left.GetDifference(right); Assert.Equal(expected, actual); }
public void can_find_distance_in_both_directions() { var a = new Vector4F(1.0f, -2, -5, 0); var b = new Vector4F(3.0f, 5, 1, 9); var expected = a.GetDistance(b); var actual = b.GetDistance(a); Assert.Equal(expected, actual); }
public void subtracting_vector_subtracts_from_components() { var actual = new Vector4F(1.0f, 15, 5, 3); var right = new Vector4F(3.0f, 4, 10, 1); var expected = new Vector4F(-2.0f, 11, -5, 2); actual.Subtract(right); Assert.Equal(expected, actual); }
public void can_find_distance_in_both_directions() { var a = new Vector4F(16.0f, 2, 5, 3); var b = new Vector4F(3.0f, 5, 1, -1); var expected = a.GetDistanceSquared(b); var actual = b.GetDistanceSquared(a); Assert.Equal(expected, actual); }
public void subtracting_vectors_leaves_right_unchanged() { var left = new Vector4F(1.0f, 2, 3, 4); var right = new Vector4F(3.0f, 4, 5, 6); var expectedRight = new Vector4F(right); left.Subtract(right); Assert.Equal(expectedRight, right); }
public static Vector4F Subtract(Vector4FParam1_3 vector, float scalar) { if (Sse.IsSupported) { Vector4F expand = Vector128.Create(scalar); return(Sse.Add(vector, expand)); } return(SoftwareFallbacks.SoftwareFallbacksVector4F.Subtract_Software(vector, scalar)); }
public void can_get_dot() { var left = new Vector4F(9.0f, 1.2f, 3.5f, 0.1f); var right = new Vector4F(-0.3f, 3.0f, -0.9f, 2.1f); var expected = (9.0f * -0.3f) + (1.2f * 3.0f) + (3.5f * -0.9f) + (0.1f * 2.1f); var actual = left.GetDot(right); Assert.Equal(expected, actual, 5); }
public static Vector4F Clamp(Vector4FParam1_3 vector, Vector4FParam1_3 low, Vector4FParam1_3 high) { if (Sse.IsSupported) { Vector4F temp = Sse.Min(vector, high); return(Sse.Max(temp, low)); } return(SoftwareFallbacks.SoftwareFallbacksVector4F.Clamp_Software(vector, low, high)); }
public void projecting_zero_against_another_vector_results_in_zero() { var u = new Vector4F(3.0f, -17, 5, -6); var v = new Vector4F(); var expected = new Vector4F(); var actual = u.GetProjected(v); Assert.Equal(expected, actual); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="Fog"/> class. /// </summary> public Fog() { Density = 1f; Height0 = 0; Color0 = new Vector4F(0.5f, 0.5f, 0.5f, 1); Height1 = 100; Color1 = new Vector4F(0.5f, 0.5f, 0.5f, 1); HeightFalloff = 0; Start = 0; End = 50; }
public void MultiplyTest() { var traits = Vector4FTraits.Instance; var value = new Vector4F(-1, -2, 3, 1); Assert.IsTrue(Vector4F.AreNumericallyEqual(Vector4F.Zero, traits.Multiply(value, 0))); Assert.IsTrue(Vector4F.AreNumericallyEqual(value, traits.Multiply(value, 1))); Assert.IsTrue(Vector4F.AreNumericallyEqual(value + value, traits.Multiply(value, 2))); Assert.IsTrue(Vector4F.AreNumericallyEqual(value + value + value, traits.Multiply(value, 3))); Assert.IsTrue(Vector4F.AreNumericallyEqual(-value, traits.Multiply(value, -1))); Assert.IsTrue(Vector4F.AreNumericallyEqual(-value - value, traits.Multiply(value, -2))); Assert.IsTrue(Vector4F.AreNumericallyEqual(-value - value - value, traits.Multiply(value, -3))); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="Terrain"/> class. /// </summary> public Terrain() { InvalidBaseRegions = new List<Aabb>(); InvalidDetailRegions = new List<Aabb>(); Shape = Shape.Infinite; BaseClearValues = new Vector4F[4]; DetailClearValues = new Vector4F[4]; BaseClearValues[0] = new Vector4F(-10000, 0, 0, 1); Tiles = new TerrainTileCollection(this); Aabb = new Aabb(); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="GradientSkyNode" /> class. /// </summary> public GradientSkyNode() { SunDirection = new Vector3F(1, 1, 1); FrontColor = new Vector4F(0.9f, 0.5f, 0, 1); ZenithColor = new Vector4F(0, 0.4f, 0.9f, 1); BackColor = new Vector4F(0.4f, 0.6f, 0.9f, 1); GroundColor = new Vector4F(1, 0.8f, 0.6f, 1); FrontZenithShift = 0.5f; BackZenithShift = 0.5f; FrontGroundShift = 0.5f; BackGroundShift = 0.5f; CieSkyParameters = CieSkyParameters.Type12; }
public void FromByTest() { // IAnimationValueTraits<T> is used in a from-by animation to a add a relative offset to // the start value. var traits = Vector4FTraits.Instance; var from = new Vector4F(-1, -2, 3, 1); var by = new Vector4F(4, -5, 6, 1); var to = traits.Add(from, by); Assert.IsTrue(Vector4F.AreNumericallyEqual(by + from, to)); Assert.IsTrue(Vector4F.AreNumericallyEqual(from, traits.Add(to, traits.Inverse(by)))); Assert.IsTrue(Vector4F.AreNumericallyEqual(by, traits.Add(traits.Inverse(from), to))); }
public void AreEqual() { float originalEpsilon = Numeric.EpsilonF; Numeric.EpsilonF = 1e-8f; Vector4F u = new Vector4F(1.0f, 2.0f, 3.0f, 4.0f); Vector4F v = new Vector4F(1.000001f, 2.000001f, 3.000001f, 4.000001f); Vector4F w = new Vector4F(1.00000001f, 2.00000001f, 3.00000001f, 4.00000001f); Assert.IsTrue(Vector4F.AreNumericallyEqual(u, u)); Assert.IsFalse(Vector4F.AreNumericallyEqual(u, v)); Assert.IsTrue(Vector4F.AreNumericallyEqual(u, w)); Numeric.EpsilonF = originalEpsilon; }
public void AbsoluteStatic() { Vector4F v = new Vector4F(-1, -2, -3, -4); Vector4F absoluteV = Vector4F.Absolute(v); Assert.AreEqual(1, absoluteV.X); Assert.AreEqual(2, absoluteV.Y); Assert.AreEqual(3, absoluteV.Z); Assert.AreEqual(4, absoluteV.W); v = new Vector4F(1, 2, 3, 4); absoluteV = Vector4F.Absolute(v); Assert.AreEqual(1, absoluteV.X); Assert.AreEqual(2, absoluteV.Y); Assert.AreEqual(3, absoluteV.Z); Assert.AreEqual(4, absoluteV.W); }
public void Absolute() { Vector4F v = new Vector4F(-1, -2, -3, -4); v.Absolute(); Assert.AreEqual(1, v.X); Assert.AreEqual(2, v.Y); Assert.AreEqual(3, v.Z); Assert.AreEqual(4, v.W); v = new Vector4F(1, 2, 3, 4); v.Absolute(); Assert.AreEqual(1, v.X); Assert.AreEqual(2, v.Y); Assert.AreEqual(3, v.Z); Assert.AreEqual(4, v.W); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="FigureNode" /> class. /// </summary> /// <param name="figure">The figure.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="figure"/> is <see langword="null"/>. /// </exception> public FigureNode(Figure figure) { if (figure == null) throw new ArgumentNullException("figure"); IsRenderable = true; _figure = figure; Shape = figure.BoundingShape; StrokeColor = new Vector3F(1, 1, 1); StrokeAlpha = 1; StrokeThickness = 1; StrokeDashPattern = new Vector4F(1, 0, 0, 0); DashInWorldSpace = true; FillColor = new Vector3F(1, 1, 1); FillAlpha = 1; }
public void Magnitude() { Vector4F v = new Vector4F(3.0f, 4.0f, 0.0f, 0.0f); Assert.AreEqual(25.0f, v.MagnitudeSquared, 1e-14); Assert.AreEqual(5.0f, v.Magnitude, 1e-14); v = new Vector4F(3.0f, 0.0f, 4.0f, 0.0f); Assert.AreEqual(25.0f, v.MagnitudeSquared, 1e-14); Assert.AreEqual(5.0f, v.Magnitude, 1e-14); v = new Vector4F(0.0f, 3.0f, 4.0f, 0.0f); Assert.AreEqual(25.0f, v.MagnitudeSquared, 1e-14); Assert.AreEqual(5.0f, v.Magnitude, 1e-14); v = new Vector4F(0.0f, 0.0f, 3.0f, 4.0f); Assert.AreEqual(25.0f, v.MagnitudeSquared, 1e-14); Assert.AreEqual(5.0f, v.Magnitude, 1e-14); }
public void CycleOffsetTest() { // IAnimationValueTraits<T> is used in a cyclic animation to a add the cycle offset in // each iteration. var traits = Vector4FTraits.Instance; var first = new Vector4F(1, 2, 3, 1); // Animation value of first key frame. var last = new Vector4F(-4, 5, -6, 5); // Animation value of last key frame. var cycleOffset = traits.Add(traits.Inverse(first), last); // Cycle offset should be the difference between last and first key frame. Assert.IsTrue(Vector4F.AreNumericallyEqual(last, traits.Add(first, cycleOffset))); Assert.IsTrue(Vector4F.AreNumericallyEqual(last, cycleOffset + first)); // Check multiple cycles (post-loop). Assert.IsTrue(Vector4F.AreNumericallyEqual(last, traits.Add(first, traits.Multiply(cycleOffset, 1)))); Assert.IsTrue(Vector4F.AreNumericallyEqual(cycleOffset + cycleOffset + last, traits.Add(first, traits.Multiply(cycleOffset, 3)))); // Check multiple cycles (pre-loop). Assert.IsTrue(Vector4F.AreNumericallyEqual(first, traits.Add(last, traits.Multiply(cycleOffset, -1)))); Assert.IsTrue(Vector4F.AreNumericallyEqual(first - cycleOffset - cycleOffset, traits.Add(last, traits.Multiply(cycleOffset, -3)))); }
private void ScaleCameraDistance(float scale) { Vector4F eye4 = new Vector4F(Eye.X, Eye.Y, Eye.Z, 0); Matrix4x4F transform = MatrixMath.MatrixScale(scale, scale, scale); eye4 = MatrixMath.VectorMultiply(transform, eye4); Eye = new Vector3F(eye4.X, eye4.Y, eye4.Z); effects.ViewMatrix = DXUtil.Camera.MatrixLookAtLH(Eye, At, Up); }
private void RenderFlag(float t, double a, int shells) { TechniqueDescription techDesc = effects.Technique.Description; for (int x = -shells; x <= shells; x++) { for (int z = -shells; z <= shells; z++) { float height = ((float)Math.Sin(0.5 * (x + 4 * t)) + (float)Math.Cos(0.25 * (z + 2 * t))); Vector4F vBaseColor = new Vector4F( 0.0f, 0.0f, 0.0f, 1.0f ); if (x < 0 && z > 0) vBaseColor.X = 0.75f + 0.125f * height; //red else if (x > 0 && z > 0) vBaseColor.Y = 0.75f + 0.125f * height; //green else if (x < 0 && z < 0) vBaseColor.Z = 0.75f + 0.125f * height; //blue else if (x > 0 && z < 0) {//yellow vBaseColor.X= 0.75f + 0.125f * height; vBaseColor.Y = 0.75f + 0.125f * height; } else continue; effects.BaseColor = vBaseColor; float yScale = 5f + 0.5f * height; effects.WorldMatrix = MatrixMath.MatrixScale(0.35f, yScale, 0.35f) * MatrixMath.MatrixTranslate(x, yScale - 10 , z); for (uint p = 0; p < techDesc.Passes; ++p) { effects.Technique.GetPassByIndex(p).Apply(); device.DrawIndexed(36, 0, 0); } } } }
/// <summary> /// Gets the bounds of the specified sphere relative to the viewport. /// </summary> /// <param name="cameraNode">The camera node.</param> /// <param name="positionWorld">The sphere center in world space.</param> /// <param name="radius">The sphere radius.</param> /// <returns> /// The bounds (left, top, right, bottom) where each entry is in the range [0, 1]. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="cameraNode"/> is <see langword="null"/>. /// </exception> internal static Vector4F GetBounds(CameraNode cameraNode, Vector3F positionWorld, float radius) { var camera = cameraNode.Camera; var projection = camera.Projection; float near = projection.Near; float left = projection.Left; float width = projection.Width; float top = projection.Top; float height = projection.Height; Vector3F l = cameraNode.PoseWorld.ToLocalPosition(positionWorld); float r = radius; // Default bounds (left, top, right, bottom) var bounds = new Vector4F(0, 0, 1, 1); // ----- Solve for N = (x, 0, z). // Discriminant already divided by 4: float d = (r * r * l.X * l.X - (l.X * l.X + l.Z * l.Z) * (r * r - l.Z * l.Z)); if (d > 0) { // Camera is outside the sphere. float rootD = (float)Math.Sqrt(d); // Now check two possible solutions (+/- rootD): float nx1 = (r * l.X + rootD) / (l.X * l.X + l.Z * l.Z); float nx2 = (r * l.X - rootD) / (l.X * l.X + l.Z * l.Z); float nz1 = (r - nx1 * l.X) / l.Z; float nz2 = (r - nx2 * l.X) / l.Z; // Compute tangent position (px, 0, pz) on the sphere. float pz1 = (l.X * l.X + l.Z * l.Z - r * r) / (l.Z - (nz1 / nx1) * l.X); float pz2 = (l.X * l.X + l.Z * l.Z - r * r) / (l.Z - (nz2 / nx2) * l.X); if (pz1 < 0) { // Plane (nx1, 0, nz1) is within camera frustum. float px = -pz1 * nz1 / nx1; float x = nz1 * near / nx1; // x coordinate on the near plane. float boundsX = (x - left) / width; // Value relative to viewport. (0 = left, 1 = right) // Shrink the scissor rectangle on the left or on the right side. if (px < l.X) bounds.X = Math.Max(bounds.X, boundsX); else bounds.Z = Math.Min(bounds.Z, boundsX); } if (pz2 < 0) { float px = -pz2 * nz2 / nx2; float x = nz2 * near / nx2; float scissorX = (x - left) / width; if (px < l.X) bounds.X = Math.Max(bounds.X, scissorX); else bounds.Z = Math.Min(bounds.Z, scissorX); } } // ----- Solve for N = (0, y, z) first. d = (r * r * l.Y * l.Y - (l.Y * l.Y + l.Z * l.Z) * (r * r - l.Z * l.Z)); if (d > 0) { // Camera is outside the sphere. float rootD = (float)Math.Sqrt(d); float ny1 = (r * l.Y + rootD) / (l.Y * l.Y + l.Z * l.Z); float ny2 = (r * l.Y - rootD) / (l.Y * l.Y + l.Z * l.Z); float nz1 = (r - ny1 * l.Y) / l.Z; float nz2 = (r - ny2 * l.Y) / l.Z; float pz1 = (l.Y * l.Y + l.Z * l.Z - r * r) / (l.Z - (nz1 / ny1) * l.Y); float pz2 = (l.Y * l.Y + l.Z * l.Z - r * r) / (l.Z - (nz2 / ny2) * l.Y); if (pz1 < 0) { float py = -pz1 * nz1 / ny1; float y = nz1 * near / ny1; float scissorY = -(y - top) / height; if (py > l.Y) bounds.Y = Math.Max(bounds.Y, scissorY); else bounds.W = Math.Min(bounds.W, scissorY); } if (pz2 < 0) { float py = -pz2 * nz2 / ny2; float y = nz2 * near / ny2; float scissorY = -(y - top) / height; if (py > l.Y) bounds.Y = Math.Max(bounds.Y, scissorY); else bounds.W = Math.Min(bounds.W, scissorY); } } bounds.X = MathHelper.Clamp(bounds.X, 0, 1); bounds.Y = MathHelper.Clamp(bounds.Y, 0, 1); bounds.Z = MathHelper.Clamp(bounds.Z, bounds.X, 1); bounds.W = MathHelper.Clamp(bounds.W, bounds.Y, 1); return bounds; }
public static void SetColor(this EffectParameter parameter, Vector4F color) { if (parameter.ColumnCount == 4) { parameter.SetValue((Vector4)color); } else { Vector3 value = new Vector3(color.X, color.Y, color.Z); parameter.SetValue(value); } }
private void Render(RenderContext context, Vector4F color, Texture2D colorTexture, bool preserveColor) { if (context == null) throw new ArgumentNullException("context"); context.Validate(_effect); context.ThrowIfCameraMissing(); context.ThrowIfGBuffer0Missing(); var graphicsDevice = _effect.GraphicsDevice; var savedRenderState = new RenderStateSnapshot(graphicsDevice); graphicsDevice.DepthStencilState = GraphicsHelper.DepthStencilStateAlways; graphicsDevice.RasterizerState = RasterizerState.CullNone; if (preserveColor) graphicsDevice.BlendState = GraphicsHelper.BlendStateNoColorWrite; else graphicsDevice.BlendState = BlendState.Opaque; if (colorTexture != null) { if (TextureHelper.IsFloatingPointFormat(colorTexture.Format)) graphicsDevice.SamplerStates[1] = SamplerState.PointClamp; else graphicsDevice.SamplerStates[1] = SamplerState.LinearClamp; } var projection = context.CameraNode.Camera.Projection; bool isPerspective = projection is PerspectiveProjection; float near = projection.Near * NearBias; float far = projection.Far * FarBias; var biasedProjection = isPerspective ? Matrix44F.CreatePerspectiveOffCenter( projection.Left, projection.Right, projection.Bottom, projection.Top, near, far) : Matrix44F.CreateOrthographicOffCenter( projection.Left, projection.Right, projection.Bottom, projection.Top, near, far); var viewport = graphicsDevice.Viewport; _parameterViewportSize.SetValue(new Vector2(viewport.Width, viewport.Height)); _parameterProjection.SetValue((Matrix)biasedProjection); _parameterCameraFar.SetValue(projection.Far); _parameterGBuffer0.SetValue(context.GBuffer0); _parameterColor.SetValue((Vector4)color); _parameterSourceTexture.SetValue(colorTexture); _effect.CurrentTechnique = isPerspective ? _techniquePerspective : _techniqueOrthographic; _effect.CurrentTechnique.Passes[(colorTexture == null) ? 0 : 1].Apply(); graphicsDevice.DrawFullScreenQuad(); graphicsDevice.ResetTextures(); savedRenderState.Restore(); }
//-------------------------------------------------------------- /// <overloads> /// <summary> /// Rebuilds the current hardware Z-buffer from the G-Buffer and optionally writes a color or /// texture to the render target. /// </summary> /// </overloads> /// /// <summary> /// Rebuilds the current hardware Z-buffer from the G-Buffer and writes the specified color /// value to the current render target. /// </summary> /// <param name="context"> /// The render context. (<see cref="RenderContext.CameraNode"/> and /// <see cref="RenderContext.GBuffer0"/> need to be set.) /// </param> /// <param name="color">The color to be written to the render target.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="context"/> is <see langword="null"/>. /// </exception> public void Render(RenderContext context, Vector4F color) { Render(context, color, null, false); }
protected override void OnProcess(RenderContext context) { context.ThrowIfCameraMissing(); context.ThrowIfGBuffer0Missing(); var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; // Get temporary render targets. var sourceSize = new Vector2F(source.Width, source.Height); var isFloatingPointFormat = TextureHelper.IsFloatingPointFormat(source.Format); var sceneFormat = new RenderTargetFormat(source.Width, source.Height, false, source.Format, DepthFormat.None); var maskedScene = renderTargetPool.Obtain2D(sceneFormat); var rayFormat = new RenderTargetFormat( Math.Max(1, (int)(sourceSize.X / DownsampleFactor)), Math.Max(1, (int)(sourceSize.Y / DownsampleFactor)), false, source.Format, DepthFormat.None); var rayImage0 = renderTargetPool.Obtain2D(rayFormat); var rayImage1 = renderTargetPool.Obtain2D(rayFormat); // Get view and view-projection transforms. var cameraNode = context.CameraNode; Matrix44F projection = cameraNode.Camera.Projection.ToMatrix44F(); Matrix44F view = cameraNode.View; Matrix44F viewProjection = projection * view; // We simply place the light source "far away" in opposite light ray direction. Vector4F lightPositionWorld = new Vector4F(-LightDirection * 10000, 1); // Convert to clip space. Vector4F lightPositionProj = viewProjection * lightPositionWorld; Vector3F lightPositionClip = Vector4F.HomogeneousDivide(lightPositionProj); // Convert from clip space [-1, 1] to texture space [0, 1]. Vector2 lightPosition = new Vector2(lightPositionClip.X * 0.5f + 0.5f, -lightPositionClip.Y * 0.5f + 0.5f); // We use dot²(forward, -LightDirection) as a smooth S-shaped attenuation // curve to reduce the god ray effect when we look orthogonal or away from the sun. var lightDirectionView = view.TransformDirection(LightDirection); float z = Math.Max(0, lightDirectionView.Z); float attenuation = z * z; // Common effect parameters. _parameters0Parameter.SetValue(new Vector4(lightPosition.X, lightPosition.Y, LightRadius * LightRadius, Scale)); _parameters1Parameter.SetValue(new Vector2(Softness, graphicsDevice.Viewport.AspectRatio)); _intensityParameter.SetValue((Vector3)Intensity * attenuation); _numberOfSamplesParameter.SetValue(NumberOfSamples); _gBuffer0Parameter.SetValue(context.GBuffer0); // First, create a scene image where occluders are black. graphicsDevice.SetRenderTarget(maskedScene); _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sourceTextureParameter.SetValue(source); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; graphicsDevice.SamplerStates[1] = SamplerState.PointClamp; // G-Buffer 0. _createMaskPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Downsample image. context.SourceTexture = maskedScene; context.RenderTarget = rayImage0; context.Viewport = new Viewport(0, 0, rayImage0.Width, rayImage0.Height); _downsampleFilter.Process(context); // Compute light shafts. _viewportSizeParameter.SetValue(new Vector2(context.Viewport.Width, context.Viewport.Height)); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; for (int i = 0; i < NumberOfPasses; i++) { graphicsDevice.SetRenderTarget(rayImage1); _sourceTextureParameter.SetValue(rayImage0); _blurPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Put the current result in variable rayImage0. MathHelper.Swap(ref rayImage0, ref rayImage1); } // Combine light shaft image with scene. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sourceTextureParameter.SetValue(source); _rayTextureParameter.SetValue(rayImage0); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; graphicsDevice.SamplerStates[1] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; _combinePass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Clean-up _sourceTextureParameter.SetValue((Texture2D)null); _gBuffer0Parameter.SetValue((Texture2D)null); _rayTextureParameter.SetValue((Texture2D)null); renderTargetPool.Recycle(maskedScene); renderTargetPool.Recycle(rayImage0); renderTargetPool.Recycle(rayImage1); context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }
public static void SetDirection(this EffectParameter parameter, Vector4F direction) { CheckDirectionVector(parameter, (Vector4)direction); if (parameter.ColumnCount == 4) { parameter.SetValue((Vector4)direction); } else { Vector3 value = new Vector3(direction.X, direction.Y, direction.Z); parameter.SetValue(value); } }
public static void SetPosition(this EffectParameter parameter, Vector4F position) { CheckPositionVector(parameter, (Vector4)position); if (parameter.ColumnCount == 4) { parameter.SetValue((Vector4)position); } else { Vector3 value = new Vector3(position.X, position.Y, position.Z); parameter.SetValue(value); } }
public void GetValueTest() { var animation = new AnimationClip<float> { Animation = new SingleFromToByAnimation { From = 100, To = 200, Duration = TimeSpan.FromSeconds(6.0), }, Delay = TimeSpan.FromSeconds(10), Speed = 2, FillBehavior = FillBehavior.Hold, }; var animation2 = new AnimationClip<float> { Animation = new SingleFromToByAnimation { From = 10, To = 20, Duration = TimeSpan.FromSeconds(5.0), }, Delay = TimeSpan.Zero, Speed = 1, FillBehavior = FillBehavior.Hold, }; var animation3 = new AnimationClip<float> { Animation = new SingleFromToByAnimation { From = 5, To = -5, Duration = TimeSpan.FromSeconds(10), }, Delay = TimeSpan.FromSeconds(5), Speed = 1, FillBehavior = FillBehavior.Hold, }; var animation4 = new AnimationClip<float> { Animation = new SingleFromToByAnimation { From = 1000, To = 1100, Duration = TimeSpan.FromSeconds(5.0), }, Delay = TimeSpan.FromSeconds(5), Speed = 1, FillBehavior = FillBehavior.Stop, }; var animationEx = new Vector4FAnimation { X = animation, Y = animation2, Z = animation3, W = animation4, }; var defaultSource = new Vector4F(1, 2, 3, 4); var defaultTarget = new Vector4F(5, 6, 7, 8); var result = animationEx.GetValue(TimeSpan.FromSeconds(0.0), defaultSource, defaultTarget); Assert.AreEqual(defaultSource.X, result.X); // animation has not started. Assert.AreEqual(10.0f, result.Y); // animation2 has started. Assert.AreEqual(defaultSource.Z, result.Z); // animation3 has not started. Assert.AreEqual(defaultSource.W, result.W); // animation4 has not started. result = animationEx.GetValue(TimeSpan.FromSeconds(5.0), defaultSource, defaultTarget); Assert.AreEqual(defaultSource.X, result.X); // animation has not started. Assert.AreEqual(20.0f, result.Y); // animation2 has ended. Assert.AreEqual(5, result.Z); // animation3 has started. Assert.AreEqual(1000, result.W); // animation4 has started. result = animationEx.GetValue(TimeSpan.FromSeconds(5.0), defaultSource, defaultTarget); Assert.AreEqual(defaultSource.X, result.X); // animation has not started. Assert.AreEqual(20.0f, result.Y); // animation2 has ended. Assert.AreEqual(5, result.Z); // animation3 has started. Assert.AreEqual(1000, result.W); // animation4 has started. result = animationEx.GetValue(TimeSpan.FromSeconds(13.0), defaultSource, defaultTarget); Assert.AreEqual(200, result.X); // animation has ended. Assert.AreEqual(20.0f, result.Y); // animation2 is filling. Assert.AreEqual(-3, result.Z); // animation3 is active. Assert.AreEqual(defaultSource.W, result.W); // animation4 is stopped. }