Пример #1
0
        static byte PaethVec(byte a, byte b, byte c)
        {
            var p      = a + b - c;
            var resVec = Vector3.Abs(new Vector3(p, p, p) - new Vector3(a, b, c));

            return(resVec.X <= resVec.Y && resVec.X <= resVec.Z ? a : (resVec.Y <= resVec.Z ? b : c));
        }
Пример #2
0
        // Manipulation, highlight

        protected override Axis GetInferredManipulationAxis(
            Vector3 primary, Vector3 secondary, bool secondaryInside)
        {
            if (secondaryInside)
            {
                return(Axis.Invalid);
            }

            Vector3 vHandsInObjectSpace = transform.InverseTransformDirection(primary - secondary);
            Vector3 vAbs = vHandsInObjectSpace.Abs();

            Axis  bestAxis = Axis.Invalid;
            float bestDot  = 0;

            for (int i = 0; i < sm_AxisDirections.Length; ++i)
            {
                float dot = Vector3.Dot(vAbs, sm_AxisDirections[i].direction);
                if (dot > bestDot)
                {
                    bestDot  = dot;
                    bestAxis = sm_AxisDirections[i].axis;
                }
            }

            return(bestAxis);
        }
Пример #3
0
        public async static Task <bool> WithinCuboid(
            [InputPin(PropertyMode = PropertyMode.Never)] PoseModel source,
            [InputPin(PropertyMode = PropertyMode.Default, Editor = "Pose")] PoseProperty center,
            [InputPin(PropertyMode = PropertyMode.Default)] double width  = 0.1,
            [InputPin(PropertyMode = PropertyMode.Default)] double height = 0.1,
            [InputPin(PropertyMode = PropertyMode.Default)] double depth  = 0.1,
            CancellationToken cancel = default(CancellationToken))
        {
            if (center == null)
            {
                throw new ArgumentNullException(nameof(center), "Required property 'center' of CheckCurrentPose module was not specified.");
            }

            if (source == null)
            {
                throw new ArgumentNullException(nameof(source), "Required property 'source' of CheckCurrentPose module was not specified.");
            }

            var centerPose = await ResolveProperty(center);

            var currentPose = source.ToPose();

            var dist = Vector3.Abs(Vector3.Subtract(centerPose.Translation, currentPose.Translation));

            return(dist.X < width && dist.Y < height && dist.Z < depth);
        }
Пример #4
0
        public float ProjectedArea(Vector3 viewDir)
        {
            Vector3 span = Max - Min;
            Vector3 size = new Vector3(span.Y, span.Z, span.X) * new Vector3(span.Z, span.X, span.Y);

            return(Vector3.Abs(viewDir).Dot(size));
        }
Пример #5
0
        private static int EncodeAC(Vector3 value, float maximumValue)
        {
            Vector3 scaledValue = value / maximumValue;
            Vector3 calc        = Vector3.Clamp(CopySign(Vector3.SquareRoot(Vector3.Abs(scaledValue)), scaledValue) * 9 + vector95, Vector3.Zero, vector18);

            return((int)calc.X * 19 * 19 + (int)calc.Y * 19 + (int)calc.Z);
        }
Пример #6
0
        public bool ContainsPoint(Vector3 point)
        {
            Matrix4x4.Invert(Transformation, out var invMatrix);
            var local = Vector3.Abs(Vector3.Transform(point, invMatrix));

            return(local.X <= HalfExtents.X && local.Y <= HalfExtents.Y && local.Z <= HalfExtents.Z);
        }
Пример #7
0
        /// <inheritdoc />
        public override void Refresh()
        {
            base.Refresh();

            if (!HasDifferentValues)
            {
                var   value = (Vector4)Values[0];
                var   color = new Vector3(value);
                var   scale = value.W;
                float min   = color.MinValue;
                float max   = color.MaxValue;
                if (min < 0.0f)
                {
                    // Negative color case (e.g. offset)
                }
                else if (max > 1.0f)
                {
                    // HDR color case
                    color /= max;
                    scale *= max;
                }
                _xElement.Value = color.X;
                _yElement.Value = color.Y;
                _zElement.Value = color.Z;
                _wElement.Value = scale;
                _trackball.CustomControl.Color = Vector3.Abs(color);
            }
        }
    public static void PerpendicularBasis(this Vector3 vector, out Vector3 outA, out Vector3 outB)
    {
        Vector3 a = vector.Abs();
        Vector3 q;

        if (a.x <= a.y)
        {
            if (a.x <= a.z)
            {
                q = Vector3.right;
            }
            else
            {
                q = Vector3.forward;
            }
        }
        else if (a.y <= a.z)
        {
            q = Vector3.up;
        }
        else
        {
            q = Vector3.forward;
        }

        outA = Vector3.Cross(vector, q).normalized;
        outB = Vector3.Cross(vector, outA).normalized;
    }
Пример #9
0
        private BoundingBox CalculateBoundingBox(MyObjectBuilder_CubeGrid grid)
        {
            float       cubeSize    = MyDefinitionManager.Static.GetCubeSize(grid.GridSizeEnum);
            BoundingBox boundingBox = new BoundingBox(Vector3.MaxValue, Vector3.MinValue);

            try
            {
                foreach (MyObjectBuilder_CubeBlock cubeBlock in grid.CubeBlocks)
                {
                    MyCubeBlockDefinition blockDefinition;
                    if (!MyDefinitionManager.Static.TryGetCubeBlockDefinition(cubeBlock.GetId(), out blockDefinition))
                    {
                        continue;
                    }
                    MyBlockOrientation blockOrientation = (MyBlockOrientation)cubeBlock.BlockOrientation;
                    Vector3            vector3          = Vector3.Abs(Vector3.TransformNormal(new Vector3(blockDefinition.Size) * cubeSize, blockOrientation));
                    Vector3            point1           = new Vector3((Vector3I)cubeBlock.Min) * cubeSize - new Vector3(cubeSize / 2f);
                    Vector3            point2           = point1 + vector3;
                    boundingBox.Include(point1);
                    boundingBox.Include(point2);
                }
            }
            catch (Exception e)
            {
                Core.GeneralLog.WriteToLog("CalculateBoundingBox", $"Exception:\t{e}");
                return(new BoundingBox());
            }
            return(boundingBox);
        }
Пример #10
0
        private static Vector3 CopySign(Vector3 value, Vector3 sign)
        {
            Vector3 signs    = new Vector3(MathF.Sign(sign.X), MathF.Sign(sign.Y), MathF.Sign(sign.Z));
            Vector3 valueAbs = Vector3.Abs(value);

            return(valueAbs * signs);
        }
Пример #11
0
        public static Vector3 RandomVector3(Vector3 minRange, Vector3 maxRange)
        {
            minRange = -minRange.Abs();
            minRange = maxRange.Abs();

            return(new Vector3(RandomRange(minRange.x, maxRange.x), CGRandom.RandomRange(minRange.y, maxRange.y), CGRandom.RandomRange(minRange.z, maxRange.z)));
        }
Пример #12
0
        private int GetStepsFromOrigin()
        {
            var absValue = Vector3.Abs(_coordinates);
            var steps    = (absValue.X + absValue.Y + absValue.Z) / 2;

            return(Convert.ToInt32(steps));
        }
        private HkdBreakableShape AddMountForShape(HkdBreakableShape shape, Matrix transform, ref BoundingBox blockBB)
        {
            Vector4 min;
            Vector4 max;

            shape.GetShape().GetLocalAABB(0.01f, out min, out max);//.Transform(CubeGrid.PositionComp.WorldMatrix);
            var bb = new BoundingBox(new Vector3(min), new Vector3(max));

            bb      = bb.Transform(transform);
            bb.Min /= CubeGrid.GridSize; //normalize for mount point
            bb.Max /= CubeGrid.GridSize;

            bb.Inflate(0.04f);//add tolerance (fracture shapes are smaller than block)
            bb.Min += blockBB.HalfExtents;
            bb.Max += blockBB.HalfExtents;

            if (blockBB.Contains(bb) == ContainmentType.Intersects)
            {
                bb.Inflate(-0.04f);
                foreach (var directionEnum in Base6Directions.EnumDirections)
                {
                    int     dirEnum   = (int)directionEnum;
                    Vector3 direction = Base6Directions.Directions[dirEnum];
                    Vector3 absDir    = Vector3.Abs(direction);
                    var     mp        = new MyCubeBlockDefinition.MountPoint();
                    mp.Start   = bb.Min;
                    mp.End     = bb.Max;
                    mp.Enabled = true;
                    var  start = mp.Start * absDir / (blockBB.HalfExtents * 2) - absDir * 0.04f;
                    var  end   = mp.End * absDir / (blockBB.HalfExtents * 2) + absDir * 0.04f;
                    bool add   = false;
                    bool one   = false;
                    if (start.Max() < 1 && end.Max() > 1 && direction.Max() > 0)
                    {
                        add = true;
                        one = true;
                    }
                    else if (start.Min() < 0 && end.Max() > 0 && direction.Min() < 0)
                    {
                        add = true;
                    }
                    if (!add)
                    {
                        continue;
                    }
                    mp.Start -= mp.Start * absDir - absDir * 0.04f;
                    mp.End   -= mp.End * absDir + absDir * 0.04f;
                    if (one)
                    {
                        mp.Start += absDir * blockBB.HalfExtents * 2;
                        mp.End   += absDir * blockBB.HalfExtents * 2;
                    }
                    mp.Start -= blockBB.HalfExtents - Vector3.One / 2;
                    mp.End   -= blockBB.HalfExtents - Vector3.One / 2;
                    mp.Normal = new Vector3I(direction);
                    MountPoints.Add(mp);
                }
            }
            return(shape);
        }
Пример #14
0
        /// <summary>
        /// Returns the inputs required to rotate the car to a desired orientation.
        /// </summary>
        /// <param name="car">The car that needs to be rotated.</param>
        /// <param name="target">The desired rotation.</param>
        /// <param name="dt">The time till the next frame in seconds.</param>
        /// <returns>Returns a Vector3 where X is roll, Y is pitch and Z is yaw.</returns>
        public static Vector3 GetInputs(Car car, Quaternion target, float dt)
        {
            Quaternion relativeRotation = Quaternion.Multiply(Quaternion.Inverse(car.Rotation), target);
            Vector3    geodesicLocal    = relativeRotation.ToRotationAxis();

            // figure out the axis of minimal rotation to target
            Vector3 geodesicWorld = Vector3.Transform(geodesicLocal, car.Rotation);

            // get the angular acceleration
            Vector3 alpha = new Vector3(Controller(geodesicWorld.X, car.AngularVelocity.X, dt),
                                        Controller(geodesicWorld.Y, car.AngularVelocity.Y, dt),
                                        Controller(geodesicWorld.Z, car.AngularVelocity.Z, dt));

            // reduce the corrections for when the solution is nearly converged
            Vector3 error = Vector3.Abs(geodesicWorld) + Vector3.Abs(car.AngularVelocity);

            alpha = q(error) * alpha;

            // set the desired next angular velocity
            Vector3 omega_next = car.AngularVelocity + alpha * dt;

            // determine the controls that produce that angular velocity
            Vector3 rollPitchYaw = AerialRollPitchYaw(car.AngularVelocity, omega_next, car.Rotation, dt);

            return(rollPitchYaw);
        }
Пример #15
0
        public static float CosAngleBetween(this Vector3 start, Vector3 to)
        {
            float num1 = Vector3.Dot(start, to);
            float num2 = start.Abs() * to.Abs();

            return(num1 / num2);
        }
Пример #16
0
        public void Render(ITransformation camera)
        {
#if SOLUTION
            for (int i = 0; i < instanceCount; ++i)
            {
                instancePositions[i] += instanceVelocity[i];
                var abs = Vector3.One - Vector3.Abs(instancePositions[i]);
                if (abs.X < 0 || abs.Y < 0 || abs.Z < 0)
                {
                    instanceVelocity[i] = -instanceVelocity[i];
                }
                instanceRotation[i] += 0.1f;
            }
            geometry.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "instancePosition"), instancePositions, true);
            geometry.SetAttribute(shaderProgram.GetResourceLocation(ShaderResourceType.Attribute, "instanceRotation"), instanceRotation, true);
#endif

            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
            shaderProgram.Activate();
#if SOLUTION
            shaderProgram.Uniform("camera", camera);
#endif
            geometry.Draw();
            shaderProgram.Deactivate();
        }
Пример #17
0
        public static void PointOutsideBox(ref Vector3 position, Vector3 boxSize)
        {
            Vector3 distanceToCenter = position.Abs();

            if (distanceToCenter.x < boxSize.x && distanceToCenter.y < boxSize.y && distanceToCenter.z < boxSize.z)
            {
                Vector3 distance = (distanceToCenter - boxSize).Abs();
                if (distance.x < distance.y)
                {
                    if (distance.x < distance.z)
                    {
                        position.x = Mathf.Sign(position.x) * boxSize.x;
                    }
                    else
                    {
                        position.z = Mathf.Sign(position.z) * boxSize.z;
                    }
                }
                else
                {
                    if (distance.y < distance.z)
                    {
                        position.y = Mathf.Sign(position.y) * boxSize.y;
                    }
                    else
                    {
                        position.z = Mathf.Sign(position.z) * boxSize.z;
                    }
                }
            }
        }
Пример #18
0
        public static void CalculateTexcoordForFace(ref Vector3 localPos, int face, out Vector2 texCoord)
        {
            Vector3 abs = Vector3.Abs(localPos);

            switch (face)
            {
            case (int)Faces.XPositive:
                localPos  /= abs.X;
                texCoord.Y = -localPos.Y;
                texCoord.X = -localPos.Z;
                break;

            case (int)Faces.XNegative:
                localPos  /= abs.X;
                texCoord.Y = -localPos.Y;
                texCoord.X = localPos.Z;
                break;

            case (int)Faces.YPositive:
                localPos  /= abs.Y;
                texCoord.Y = -localPos.Z;
                texCoord.X = -localPos.X;
                break;

            case (int)Faces.YNegative:
                localPos  /= abs.Y;
                texCoord.Y = -localPos.Z;
                texCoord.X = localPos.X;
                break;

            case (int)Faces.ZPositive:
                localPos  /= abs.Z;
                texCoord.Y = -localPos.Y;
                texCoord.X = localPos.X;
                break;

            case (int)Faces.ZNegative:
                localPos  /= abs.Z;
                texCoord.Y = -localPos.Y;
                texCoord.X = -localPos.X;
                break;

            default:
                Debug.Fail("Bad face number!!!!!");
                texCoord = Vector2.Zero;
                break;
            }

            texCoord = ((texCoord + 1f) * .5f);

            if (texCoord.X == 1)
            {
                texCoord.X = 0.999999f;
            }
            if (texCoord.Y == 1)
            {
                texCoord.Y = 0.999999f;
            }
        }
Пример #19
0
        public void GetBoxFromMatrix(MatrixD m, out Vector3 halfExtents, out Vector3D position, out Quaternion orientation)
        {
            var world = MatrixD.Normalize(m) * this.WorldMatrix;

            orientation = Quaternion.CreateFromRotationMatrix(world);
            halfExtents = Vector3.Abs(m.Scale) / 2;
            position    = world.Translation;
        }
Пример #20
0
        public static void CalcRightTexcoord(ref Vector3 localPos, out Vector2 texCoord)
        {
            Vector3 vector = Vector3.Abs(localPos);

            texCoord.Y = -localPos.Y / vector.X;
            texCoord.X = localPos.Z / vector.X;
            texCoord   = (texCoord + 1f) * 0.5f;
        }
Пример #21
0
        public static float AngleBetween(this Vector3 start, Vector3 to, bool returndegree = true)
        {
            float num1 = Vector3.Dot(start, to);
            float num2 = start.Abs() * to.Abs();
            var   num3 = num1 / num2;

            return(returndegree ? (float)(Math.Acos(num3) / Math.PI * 180) : (float)Math.Acos(num3));
        }
Пример #22
0
        public static void CalcFrontTexcoord(ref Vector3 localPos, out Vector2 texCoord)
        {
            Vector3 vector = Vector3.Abs(localPos);

            texCoord.Y = -localPos.Y / vector.Z;
            texCoord.X = -localPos.X / vector.Z;
            texCoord   = (texCoord + 1f) * 0.5f;
        }
Пример #23
0
        private static bool AreNearlyEqual(Vector3 a, Vector3 b)
        {
            Vector3 delta = Vector3.Abs(a - b);

            return(delta.X < Epsilon &&
                   delta.Y < Epsilon &&
                   delta.Z < Epsilon);
        }
Пример #24
0
        /// <inheritdoc/>
        public bool AlmostEquals(Hsl other, float precision)
        {
            Vector3 result = Vector3.Abs(this.backingVector - other.backingVector);

            return(result.X < precision &&
                   result.Y < precision &&
                   result.Z < precision);
        }
Пример #25
0
 public static Func <Vector3, float> Box(Vector3 b)
 {
     return(p => {
         Vector3 d = Vector3.Abs(p) - b;
         return Vector3.Max(d, Vector3.Zero).Length() +
         (float)Math.Min(Math.Max(d.X, Math.Max(d.Y, d.Z)), 0.0);
     });
 }
Пример #26
0
        public override bool CanDrag(MapViewport viewport, OrthographicCamera camera, ViewportEvent e, Vector3 position)
        {
            var width          = Width;
            var screenPosition = camera.WorldToScreen(Position);
            var diff           = Vector3.Abs(e.Location - screenPosition);

            return(diff.X < width && diff.Y < width);
        }
Пример #27
0
        /// <summary>
        /// Returns whether the given world-space point projects inside this Rect. Optionally
        /// also outputs the calculated rect-space point to point_rect.
        /// </summary>
        public bool ContainsProjectedPoint(Vector3 point, out Vector3 point_rect)
        {
            point_rect = this.matrix.inverse.MultiplyPoint3x4(point);

            var absPoint_rect = point_rect.Abs();

            return(absPoint_rect.x <= radii.x && absPoint_rect.y <= radii.y);
        }
Пример #28
0
        private void GetBoxFromMatrix(Matrix m, out Vector3 halfExtents, out Vector3 position, out Quaternion orientation)
        {
            MatrixD matrix = Matrix.Normalize(m) * base.WorldMatrix;

            orientation = Quaternion.CreateFromRotationMatrix(matrix);
            halfExtents = Vector3.Abs(m.Scale) / 2f;
            halfExtents = new Vector3(halfExtents.X, halfExtents.Y, halfExtents.Z);
            position    = (Vector3)matrix.Translation;
        }
Пример #29
0
        private void GetBoxFromMatrix(Matrix m, out Vector3 halfExtents, out Vector3 position, out Quaternion orientation)
        {
            var world = Matrix.Normalize(m) * this.WorldMatrix;

            orientation = Quaternion.CreateFromRotationMatrix(world);
            halfExtents = Vector3.Abs(m.Scale) / 2;
            halfExtents = new Vector3(halfExtents.X, halfExtents.Y, halfExtents.Z);
            position    = world.Translation;
        }
Пример #30
0
        public override bool CanDrag(MapViewport viewport, OrthographicCamera camera, ViewportEvent e, Vector3 position)
        {
            const int width          = 8;
            var       pos            = GetWorldPositionAndScreenOffset(viewport.Viewport.Camera);
            var       screenPosition = camera.WorldToScreen(pos.Item1) + pos.Item2;
            var       diff           = Vector3.Abs(e.Location - screenPosition);

            return(diff.X < width && diff.Y < width);
        }
Пример #31
0
 public static float sdHexPrism(Vector3 p, Vector2 h)
 {
     Vector3 q = p.Abs();
     return Math.Max(q.Z - h.Y, Math.Max((q.X * 0.866025f + q.Y * 0.5f), q.Y) - h.X);
 }