C# Vector3f.Normalized方法代码示例

        public static Matrix3f RotateAxis( Vector3f axis, float radians )
        {
            var normalizedAxis = axis.Normalized();
            float cosTheta = ( float )( Math.Cos( radians ) );
            float sinTheta = ( float )( Math.Sin( radians ) );

            float x = normalizedAxis.x;
            float y = normalizedAxis.y;
            float z = normalizedAxis.z;

            var m = new Matrix3f();

            m[ 0, 0 ] = x * x * ( 1.0f - cosTheta ) + cosTheta;
            m[ 0, 1 ] = y * x * ( 1.0f - cosTheta ) - z * sinTheta;
            m[ 0, 2 ] = z * x * ( 1.0f - cosTheta ) + y * sinTheta;

            m[ 1, 0 ] = x * y * ( 1.0f - cosTheta ) + z * sinTheta;
            m[ 1, 1 ] = y * y * ( 1.0f - cosTheta ) + cosTheta;
            m[ 1, 2 ] = z * y * ( 1.0f - cosTheta ) - x * sinTheta;

            m[ 2, 0 ] = x * z * ( 1.0f - cosTheta ) - y * sinTheta;
            m[ 2, 1 ] = y * z * ( 1.0f - cosTheta ) + x * sinTheta;
            m[ 2, 2 ] = z * z * ( 1.0f - cosTheta ) + cosTheta;

            return m;
        }

        public Camera(Vector3f position, Vector3f forward, Vector3f worldUp, float fieldOfView, Size renderSize)
            : base(position)
        {
            this.ReflectionDepth = 5;
            this.forward = forward.Normalized();
            this.right = Util.CrossProduct(worldUp, forward).Normalized();
            this.up = -Util.CrossProduct(right, forward).Normalized();
            this.fieldOfView = fieldOfView;
            this.RenderSize = renderSize;

            RecalculateFieldOfView();
        }

        /// <summary>
        /// Constructs a plane with the properties provided
        /// </summary>
        /// <param name="position">The position of the plane's center</param>
        /// <param name="material">The plane's material</param>
        /// <param name="normalDirection">The normal direction of the plane</param>
        /// <param name="cellWidth">The width of a cell in the plane, used for texture coordinate mapping.</param>
        public Plane(Vector3f position, Material material, Vector3f normalDirection, float cellWidth)
            : base(position, material)
        {
            this.normalDirection = normalDirection.Normalized();
            if (normalDirection == Util.ForwardVector)
            {
                this.uDirection = -Util.RightVector;
            }
            else if (normalDirection == -Util.ForwardVector)
            {
                this.uDirection = Util.RightVector;
            }
            else
            {
                this.uDirection = Util.CrossProduct(normalDirection, Util.ForwardVector).Normalized();
            }

            this.vDirection = -Util.CrossProduct(normalDirection, uDirection).Normalized();
            this.cellWidth = cellWidth;
        }

        /// <summary>
        /// Returns an orthonormal basis u, v, and n on the plane
        /// given a preferred u vector.  If u is not on the plane,
        /// then u is projected onto the plane first
        /// </summary>
        /// <param name="u"></param>
        /// <returns></returns>
        public Matrix3f Basis( Vector3f u )
        {
            // normalize u first
            u = u.Normalized();
            var n = UnitNormal;

            // u is the vector triple product: ( n x u ) x n
            //
            // u is the preferred direction, which may be be in the plane
            // we want u to be the projection of u in the plane
            // and v to be perpendicular to both
            // but v is n cross u regardless of whether u is in the plane or not
            // so compute v, then cross v with n to get u in the plane
            var v = Vector3f.Cross( n, u ).Normalized();
            u = Vector3f.Cross( v, n ).Normalized();

            return new Matrix3f( u, v, n );
        }

 /// <summary>
 /// Construct a plane given a point on the plane and its normal (does not need to be unit length)
 /// </summary>
 /// <param name="p"></param>
 /// <param name="normal"></param>
 public Plane3f( Vector3f p, Vector3f normal )
 {
     var unitNormal = normal.Normalized();
     var d = -Vector3f.Dot( unitNormal, p );
     ABCD = new Vector4f( unitNormal, d );
 }

 public static Vector3f Projection(Vector3f projectedVector, Vector3f directionVector)
 {
     var mag = VectorMath.DotProduct(projectedVector, directionVector.Normalized());
     return directionVector * mag;
 }

 public Ray(Vector3f start, Vector3f direction, float distance)
 {
     this.Origin = start;
     this.Direction = direction.Normalized();
     this.Distance = distance;
 }