Beispiel #1
0
 public void LookAt(Vector3 lookDir, Vector3 up)
 {
     lookDir.Normalize();
     Matrix matView = Matrix.LookAtLH(Vector3.Zero, lookDir, up);
     Quaternion qtnView = Quaternion.RotationMatrix(matView);
     m_Orientation = Quaternion.Invert(qtnView);
 }
Beispiel #2
0
        public void GlobalSetUp()
        {
            randomTriangles = new Vector3[TRIANGLE_COUNT * 3];
            for (int i = 0; i < TRIANGLE_COUNT * 3; i++)
            {
                randomTriangles[i] = RNG.RandomVector3();
            }

            origin = RNG.RandomVector3();
            direction = RNG.RandomVector3();
            direction.Normalize();
            testRay = new Ray(origin, direction);

            randomRays = new Ray[RAY_COUNT];
            for (int i = 0; i < RAY_COUNT; i++)
            {
                Vector3 thisOrigin = RNG.RandomVector3();
                Vector3 thisDirection = RNG.RandomVector3();
                thisDirection.Normalize();
                randomRays[i] = new Ray(thisOrigin, thisDirection);
            }

            heightmap = new float[256 * 256];
            for (int y = 0; y < 256; y++)
            {
                for (int x = 0; x < 256; x++)
                {
                    heightmap[y * 256 + x] = (float)Math.Max(RNG.NextGaussian(25.0, 10.0), 0);
                }
            }
        }
Beispiel #3
0
		public static Matrix4 Rotate (float angle, Vector3 r)
		{
			float a = RadiansOverPi (angle);
			float c = (float)Math.Cos (a);
			float s = (float)Math.Sin (a);

			float k = 1.0f - c;
			r.Normalize ();
			Vector3 u = r;
			Vector3 v = s * u;
			Vector3 w = k * u;

			Vector4 P = Vector4.Zero;
			Vector4 Q = Vector4.Zero;
			Vector4 R = Vector4.Zero;
			Vector4 S = Vector4.Zero;

			P.X = w.X * u.X + c;
			P.Y = w.X * u.Y + v.Z;
			P.Z = w.X * u.Z - v.Y;

			Q.X = w.X * u.Y - v.Z;
			Q.Y = w.Y * u.Y + c;
			Q.Z = w.Y * u.Z + v.X;

			R.X = w.X * u.Z + v.Y;
			R.Y = w.Y * u.Z - v.X;
			R.Z = w.Z * u.Z + c;

			S.W = 1.0f;

			return MakeResultMatrix (P, Q, R, S);
		}
Beispiel #4
0
 /// <summary>
 /// 拡大縮小ベクトルと回転行列と位置ベクトルに分割します。
 /// </summary>
 /// <param name="m">元の行列(戻り値は回転行列)</param>
 /// <param name="scaling">拡大縮小ベクトル</param>
 /// <returns>位置ベクトル</returns>
 public static Vector3 DecomposeMatrix(ref Matrix m, out Vector3 scaling)
 {
     Vector3 vx = new Vector3(m.M11, m.M12, m.M13);
     Vector3 vy = new Vector3(m.M21, m.M22, m.M23);
     Vector3 vz = new Vector3(m.M31, m.M32, m.M33);
     Vector3 vt = new Vector3(m.M41, m.M42, m.M43);
     float scax = vx.Length();
     float scay = vy.Length();
     float scaz = vz.Length();
     scaling = new Vector3(scax, scay, scaz);
     vx.Normalize();
     vy.Normalize();
     vz.Normalize();
     m.M11 = vx.X;
     m.M12 = vx.Y;
     m.M13 = vx.Z;
     m.M21 = vy.X;
     m.M22 = vy.Y;
     m.M23 = vy.Z;
     m.M31 = vz.X;
     m.M32 = vz.Y;
     m.M33 = vz.Z;
     m.M41 = 0;
     m.M42 = 0;
     m.M43 = 0;
     return vt;
 }
		public PistonConstraint(
			int indexA,
			int indexB,
			SimulationObject[] simulationObject,
			Vector3 startAnchorPosition,
			Vector3 pistonAxis,
			double restoreCoefficient,
			double springCoefficient)
		{
			IndexA = indexA;
			IndexB = indexB;
			KeyIndex = GetHashCode();
			RestoreCoefficient = restoreCoefficient;
			SpringCoefficient = springCoefficient;
			StartAnchorPoint = startAnchorPosition;

			PistonAxis = -1.0 * pistonAxis.Normalize ();

			SimulationObject objectA = simulationObject[IndexA];
			SimulationObject objectB = simulationObject[IndexB];

			Vector3 relativePos = objectA.RotationMatrix *
				(startAnchorPosition - objectA.StartPosition);

			AnchorPoint = relativePos + objectA.Position;

			StartErrorAxis1 = objectA.RotationMatrix.Transpose() *
									 (AnchorPoint - objectA.Position);

			StartErrorAxis2 = objectB.RotationMatrix.Transpose() *
									 (AnchorPoint - objectB.Position);

			RelativeOrientation = objectB.RotationStatus.Inverse() *
										 objectA.RotationStatus;
		}
Beispiel #6
0
 public void rotate(Vector3 axis, float angle)
 {
     axis.Normalize();
     axis = axis * (float)Math.Sin(angle / 2.0f);
     float scalar = (float)Math.Cos(angle / 2.0f);
     rotate(new Quaternion(axis, scalar));
 }
Beispiel #7
0
        public override float GetDistanceToCenter(
                Vector3 particlePosition, Vector3 particleVelocity,
                out Vector3 alongAxis, out Vector3 aroundAxis, out Vector3 awayAxis)
        {
            // Along - following the main axis
            alongAxis = mainAxis;

            // Toward - tawards the main axis
            awayAxis = particlePosition - fieldPosition;
            awayAxis.Y = 0; // In case of cylinder the away vector should be flat (away from the axis rather than just a point)
            awayAxis.Normalize();

            // Around - around the main axis, following the right hand rule
            aroundAxis = Vector3.Cross(alongAxis, awayAxis);

            particlePosition -= fieldPosition;
            inverseRotation.Rotate(ref particlePosition);
            particlePosition /= fieldSize;

            // Start of code for Cylinder
            if (Math.Abs(particlePosition.Y) >= halfHeight)
                return 1;

            particlePosition.Y = 0;

            particlePosition.X /= radius;
            particlePosition.Z /= radius;

            var maxDist = particlePosition.Length();
            // End of code for Cylinder

            return maxDist;
        }
Beispiel #8
0
        // レンダリング
        public void Render()
        {
            viewport.MakeCurrent();

            GL.Enable(EnableCap.DepthTest);
            GL.Enable(EnableCap.CullFace);
            GL.FrontFace(FrontFaceDirection.Cw);
            GL.CullFace(CullFaceMode.Back);

            GL.Viewport(0, 0, viewport.Width, viewport.Height);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            GL.UseProgram(program);

            Vector3 eyePos = new Vector3(5.0f, 5.0f, 5.0f);
            Vector3 lookAt = new Vector3(0.0f, 0.0f, 0.0f);
            Vector3 eyeUp = new Vector3(0.0f, 1.0f, 0.0f);
            Matrix4 viewMatrix = Matrix4.LookAt(eyePos, lookAt, eyeUp);
            Matrix4 projectionMatrix = Matrix4.CreatePerspectiveFieldOfView((float)System.Math.PI / 4.0f, (float)viewport.Width / (float)viewport.Height, 0.1f, 10.0f);
            Matrix4 viewProjectionMatrix = viewMatrix * projectionMatrix;
            GL.UniformMatrix4(GL.GetUniformLocation(program, "viewProjection"), false, ref viewProjectionMatrix);

            Matrix4 worldMatrix = Matrix4.Identity;
            GL.UniformMatrix4(GL.GetUniformLocation(program, "world"), false, ref worldMatrix);

            Vector3 lightDir = new Vector3((float)Math.Cos((float)lightAngle), -1.0f, (float)Math.Sin((float)lightAngle));
            lightDir.Normalize();
            GL.Uniform3(GL.GetUniformLocation(program, "lightDir"), lightDir);
            lightAngle += 0.001f;

            cube.Render();

            viewport.SwapBuffers();
        }
Beispiel #9
0
        /// <summary>
        /// Set of lines in 3D space.
        /// </summary>
        /// <param name="origin"></param>
        /// <param name="xAxis"></param>
        /// <param name="yAxis"></param>
        /// <param name="scale">Scaling the field extent.</param>
        /// <param name="field"></param>
        public LineBall(Plane plane, LineSet lines, RenderEffect effect = RenderEffect.DEFAULT, Colormap colormap = Colormap.Parula, bool flatten = false)
        {
            _thickness = lines.Thickness * plane.PointSize;
            _color = lines.Color;
            this._vertexSizeBytes = Marshal.SizeOf(typeof(Vector4));
            this._numVertices = lines.NumPoints * 2 - lines.Lines.Length * 2; // Linelist means, all points are there twice, minus the endpoints.
            if (_numVertices == 0)
                return;
            this._topology = PrimitiveTopology.LineList;

            // Setting up the vertex buffer.
            if (!flatten)
                GenerateGeometry(plane, lines);
            else
                GenerateGeometryFlatXY(plane, lines);

            //this._technique = _lineEffect.GetTechniqueByName("Render");
            UsedMap = colormap;
            _planeNormal = plane.ZAxis;
            _planeNormal.Normalize();
            _effect = _lineEffect;
            SetRenderEffect(effect);

            this._vertexLayout = new InputLayout(_device, _technique.GetPassByIndex(0).Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
                new InputElement("SCALAR", 0, Format.R32_Float, 12, 0)
            });
        }
			public void ComputeMatricies ( Matrix viewMatrix, Vector3 lightDir, int cascadeSize, float splitSize, float splitOffset, float splitFactor, float projDepth )
			{
				var	smSize		=	cascadeSize;
				var camMatrix	=	Matrix.Invert( viewMatrix );
				var viewPos		=	camMatrix.TranslationVector;

				lightDir.Normalize();


				for ( int i = 0; i<4; i++ ) {

					float	offset		=	splitOffset * (float)Math.Pow( splitFactor, i );
					float	radius		=	splitSize   * (float)Math.Pow( splitFactor, i );

					Vector3 viewDir		=	camMatrix.Forward.Normalized();
					Vector3	origin		=	viewPos + viewDir * offset;

					Matrix	lightRot	=	Matrix.LookAtRH( Vector3.Zero, Vector3.Zero + lightDir, Vector3.UnitY );
					Matrix	lightRotI	=	Matrix.Invert( lightRot );
					Vector3	lsOrigin	=	Vector3.TransformCoordinate( origin, lightRot );
					float	snapValue	=	4.0f * radius / smSize;
					lsOrigin.X			=	(float)Math.Round(lsOrigin.X / snapValue) * snapValue;
					lsOrigin.Y			=	(float)Math.Round(lsOrigin.Y / snapValue) * snapValue;
					lsOrigin.Z			=	(float)Math.Round(lsOrigin.Z / snapValue) * snapValue;
					origin				=	Vector3.TransformCoordinate( lsOrigin, lightRotI );//*/

					shadowViews[i]			=	Matrix.LookAtRH( origin, origin + lightDir, Vector3.UnitY );
					shadowProjections[i]	=	Matrix.OrthoRH( radius*2, radius*2, -projDepth/2, projDepth/2);
				}
			}
Beispiel #11
0
        /// <summary> Checks if this vector has 'good' values, i.e. components are not very little values. </summary>
        /// <param name="vector"> Vector to check. Must be a normalized vector. </param>
        public static void checkIntegrity(ref Vector3 vector)
        {
            float threshold = 0.000001f;
            bool mustRenormalize = false;

            if (Math.Abs(vector.X) < threshold)
            {
                vector.X = 0;
                mustRenormalize = true;
            }
            if (Math.Abs(vector.Y) < threshold)
            {
                vector.Y = 0;
                mustRenormalize = true;
            }
            if (Math.Abs(vector.Z) < threshold)
            {
                vector.Z = 0;
                mustRenormalize = true;
            }

            if( mustRenormalize )
                vector.Normalize();

            if (Math.Abs(vector.X) > 0.999999)
                vector.X = Math.Sign(vector.X);

            if (Math.Abs(vector.Y) > 0.999999)
                vector.Y = Math.Sign(vector.Y);

            if (Math.Abs(vector.Z) > 0.999999)
                vector.Z = Math.Sign(vector.Z);
        }
Beispiel #12
0
 private static float AngleBetween(Vector3 v1, Vector3 v2)
 {
     v1.Normalize();
     v2.Normalize();
     float dot = Vector3.Dot(v1, v2);
     return (float)Math.Acos(dot);
 }
Beispiel #13
0
        public Quad(int startX,int endX, int startZ, int endZ, Base.Content.Terrain.Terrain terrain, RenderManager renderer)
        {
            _bounds = new QuadBounds
            {
                MinX = startX / terrain.PointsPerMeter,
                MaxX = endX / terrain.PointsPerMeter,
                MinZ = startZ / terrain.PointsPerMeter,
                MaxZ = endZ / terrain.PointsPerMeter,
                MinY = terrain.Height[0],
                MaxY = terrain.Height[0]
            };
            HorizontalCenter = new Vector2(Bounds.MinX + (Bounds.MaxX - Bounds.MinX) / 2, Bounds.MinZ + (Bounds.MaxZ - Bounds.MinZ) / 2);

            int verticesX = endX - startX + 1;
            int verticesZ = endZ - startZ + 1;

            var dataStream = new DataStream(32 * verticesX * verticesZ, true, true);

            for (int i = 0; i < verticesX; i++)
            {
                for (int j = 0; j < verticesZ; j++)
                {
                    //Position
                    int xindex = Math.Min(i + startX, terrain.PointsX - 1);//Clamp to arraybounds if neccessary
                    int zindex = Math.Min(j + startZ, terrain.PointsZ - 1);//(Quadsize needs to be consistent for sharing IndexBuffers)
                    float x = xindex / terrain.PointsPerMeter;
                    float z = zindex / terrain.PointsPerMeter;
                    float y = terrain.Height[xindex * terrain.PointsZ + zindex];
                    dataStream.Write(new Vector3(x, y, z));

                    //Normal
                    float deltax = (terrain.Height[(xindex < terrain.PointsX - 1 ? xindex + 1 : xindex) * terrain.PointsZ + zindex]
                        - terrain.Height[(xindex != 0 ? xindex - 1 : xindex) * terrain.PointsZ + zindex]);

                    float deltaz = (terrain.Height[xindex * terrain.PointsZ + (zindex < terrain.PointsZ - 1 ? zindex + 1 : zindex)]
                        - terrain.Height[xindex * terrain.PointsZ + (zindex != 0 ? zindex - 1 : zindex)]);
                    if (xindex == 0 || xindex == terrain.PointsX - 1)
                        deltax *= 2;
                    if (zindex == 0 || zindex == terrain.PointsZ - 1)
                        deltaz *= 2;
                    var normal = new Vector3(-deltax, 2 / terrain.PointsPerMeter, deltaz);
                    normal.Normalize();
                    dataStream.Write(normal);

                    //TextureCoordinates
                    dataStream.Write(new Vector2(x / terrain.PointsX, z / terrain.PointsZ));

                    //Boundingbox-Params
                    if (y < _bounds.MinY)
                        _bounds.MinY = y;
                    if (y > _bounds.MaxY)
                        _bounds.MaxY = y;
                }
            }

            dataStream.Position = 0;
            VBuffer = new Buffer(renderer.D3DDevice, dataStream, 32 * verticesX * verticesZ, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
            VertexBuffer = new VertexBufferBinding(VBuffer, 32, 0);
            dataStream.Dispose();
        }
        /// <summary>
        /// Creates the instance of the camera at the given location.
        /// </summary>
        /// <param name="position">Position of the camera.</param>
        /// <param name="target">The target towards which the camera is pointing.</param>
        public Camera(Game game, Vector3 position, Vector3 target)
            : this(game)
        {
            m_position = position;
            m_direction = target - m_position;
            m_direction.Normalize();

            View = CreateLookAt();
        }
Beispiel #15
0
        /// <summary>
        /// Modifies the orientation of the camera to get the camera to look in a particular direction.
        /// </summary>
        /// <param name="direction">The direction to have the camera look.</param>
        public void SetDirection(Vector3 direction)
        {
            if (direction == Vector3.Zero) return;

            Vector3 zvec = -direction.Normalize();
            Vector3 xvec = Vector3.Up.Cross(zvec).Normalize();
            Vector3 yvec = zvec.Cross(xvec).Normalize();
            Orientation = Quaternion.FromAxis(xvec, yvec, zvec);
        }
        public void LookTo(Vector3 direction)
        {
            if (direction == Vector3.Zero)
                return;

            direction.Normalize();
            var angle = (float)Math.Atan2(-direction.X, direction.Z);
            Object.Transform = Matrix.RotationY(angle) * Matrix.Translation(Object.Transform.TranslationVector);
        }
 /// <summary>
 /// Generates a random tangent and binormal for a given normal, 
 /// usefull for creating plane vertices or orienting objects (lookat) where the rotation along the normal doesn't matter
 /// </summary>
 /// <param name="normal"></param>
 /// <param name="tangent"></param>
 /// <param name="binormal"></param>
 public static void GenerateTangentBinormal(Vector3 normal, out Vector3 tangent, out Vector3 binormal)
 {
     tangent = Math.Abs(normal.Y) < 0.01f
         ? new Vector3(normal.Z, normal.Y, -normal.X)
         : new Vector3(-normal.Y, normal.X, normal.Z);
     tangent.Normalize();
     binormal = Vector3.Cross(normal, tangent);
     tangent = Vector3.Cross(binormal, normal);
 }
Beispiel #18
0
 public Plane(Vector3 v1, Vector3 v2, Vector3 v3)
 {
     vec1 = v1;
     vec2 = v2;
     vec3 = v3;
     Normal = Vector3.Cross((v2 - v1), (v3 - v1));
     Normal.Normalize();
     D = (float)-Vector3.Dot(Normal, vec1);
 }
        public Particle AddParticle(Vector3 Location, float Speed)
        {
            //create a random direction first.
            Vector3 RandomDirection = new Vector3((float) (PrehenderGame.rgen.NextDouble() - 0.5),
                (float) (PrehenderGame.rgen.NextDouble() - 0.5),
                (float) (PrehenderGame.rgen.NextDouble() - 0.5));

            RandomDirection.Normalize();
            return AddParticle(Location, RandomDirection * Speed);
        }
Beispiel #20
0
		public Collider(Vector3 position, Vector3 direction, float forwardRange)
		{
			direction.Normalize();
			this.forwardNormal = this.Forward = direction;
			this.Forward *= forwardRange;
			this.Direction2D = new Vector3(direction.X, 0, direction.Z);
			this.Direction2D.Normalize();
			this.Position = position;
			this.forwardRange = forwardRange;
		}
        /// <summary>
        /// Creates the instance of the camera.
        /// </summary>
        public Camera(Game game)
        {
            // Create the direction vector and normalize it since it will be used for movement
            m_direction = Vector3.Zero - m_position;
            m_direction.Normalize();

            // Create default camera matrices
            Projection = Matrix4.CreatePerspectiveFieldOfView(MathHelper.PiOver4, game.Width / (float)game.Height, 0.01f, 1000);
            View = CreateLookAt();
        }
Beispiel #22
0
        void UpdateDirection()
        {
            Vector3 dir = new Vector3(0, 0.5f, -1.0f);
            dir.Normalize();

            emitDirection = Vector3.TransformSimple(dir, parent.CurrentFacing);
            emitPosition = Vector3.TransformSimple(new Vector3(0, 380, -125), parent.CurrentFacing);
            Vector3 right = Vector3.TransformSimple(Vector3.UnitX, parent.CurrentFacing);
            emitNormal = Vector3.Cross(right, emitDirection);

        }
Beispiel #23
0
        private static Matrix4 Matrix4_CreateBillboardRotation(Vector3 targetpos, Vector3 viewpos, Vector3 right)
        {
            Vector3 view = targetpos - viewpos; view.Normalize();
            Vector3 up = Vector3.Cross(right, view); right.Normalize();
            view = Vector3.Cross(up, right); up.Normalize();

            return new Matrix4(right.X, right.Y, right.Z, 0.0f,
                up.X, up.Y, up.Z, 0.0f,
                view.X, view.Y, view.Z, 0.0f,
                0.0f, 0.0f, 0.0f, 1.0f);
        }
        public static Vector3 RandomXY()
        {
            Random random = new Random(Environment.TickCount);

            Vector3 vector3 = new Vector3();
            vector3.X = (float)(random.NextDouble() - 0.5);
            vector3.Y = (float)(random.NextDouble() - 0.5);
            vector3.Z = 0.0f;
            vector3.Normalize();
            return vector3;
        }
Beispiel #25
0
        public static Vector3 vectorize(Point3 p1, Point3 p2)
        {
            Vector3 v = new Vector3();

             v.X = p2.x - p1.x;
             v.Y = p2.y - p1.y;
             v.Z = p2.z - p1.z;
             v.Normalize();

             return v;
        }
 public PerspectiveCamera()
 {
     location = new Vector3(100, 100, 0);
     lookAt = new Vector3(0, 0, 0);
     eyeDirection = new Vector3(-1, -1, 0);
     eyeDirection.Normalize();
     up = new Vector3(-1, 1, 0);
     up.Normalize();
     right = new Vector3(0, 0, -1);
     Name = "Perspective Camera";
 }
Beispiel #27
0
 /// <summary>
 /// Shoot a projectile.
 /// </summary>
 public void fire(Vector2 dir)
 {
     Vector3 direction = new Vector3(dir.X, dir.Y, 0);
     direction.Normalize();
     game.Add(new Projectile(game,
         game.assets.GetModel("shot", CreateEnemyProjectileModel),
         pos,
         direction * 10,
         this
     ));
 }
Beispiel #28
0
        public Matrix4 GetViewMatrix()
        {
            Vector3 lookat = new Vector3();

            lookat.X = (float)(Math.Sin((float)Orientation.X) * Math.Cos((float)Orientation.Y));
            lookat.Y = (float)Math.Sin((float)Orientation.Y);
            lookat.Z = (float)(Math.Cos((float)Orientation.X) * Math.Cos((float)Orientation.Y));
            lookat.Normalize();

            return Matrix4.LookAt(Position, Position + lookat, Vector3.UnitY);
        }
Beispiel #29
0
        public ShotTrail( SfxSystem sfxSystem, FXEvent fxEvent )
            : base(sfxSystem, fxEvent)
        {
            sparkDir = Matrix.RotationQuaternion(fxEvent.Rotation).Forward + rand.GaussRadialDistribution(0, 0.1f);
            sparkDir.Normalize();

            AddParticleStage("bulletSpark", 0, 0f, 0.1f, 10, false, EmitSpark );

            AddLightStage( fxEvent.Origin + sparkDir * 0.1f	, new Color4(125,110, 35,1), 0.5f, 100f, 3f );

            //AddSoundStage( @"sound\weapon\bulletHit",	fxEvent.Origin, 1, false );
        }
Beispiel #30
0
        private void UpdateView()
        {
            mForward = mTarget - Position;
            mForward.Normalize();
            mViewNoTranspose = LeftHanded == false ? Matrix.LookAtRH(Position, mTarget, mUp) : Matrix.LookAtLH(Position, mTarget, mUp);
            Matrix.Invert(ref mViewNoTranspose, out mViewInverted);
            Matrix.Transpose(ref mViewNoTranspose, out mMatView);
            if (ViewChanged != null)
                ViewChanged(this, mMatView);

            mFrustum.Update(mViewNoTranspose, mProjNoTranspose);
        }