/// <summary> /// /// </summary> /// <param name="sceneMgr"></param> private void SetupBody(SceneManager sceneMgr) { // create main model bodyNode = sceneMgr.RootSceneNode.CreateChildSceneNode(Axiom.Math.Vector3.UnitY * CharHeight); bodyEnt = sceneMgr.CreateEntity("SinbadBody", "Sinbad.mesh"); bodyNode.AttachObject(bodyEnt); // create swords and attach to sheath sword1 = sceneMgr.CreateEntity("SinbadSword1", "Sword.mesh"); sword2 = sceneMgr.CreateEntity("SinbadSword2", "Sword.mesh"); bodyEnt.AttachObjectToBone("Sheath.L", sword1); bodyEnt.AttachObjectToBone("Sheath.R", sword2); // create a couple of ribbon trails for the swords, just for fun NamedParameterList paras = new NamedParameterList(); paras["numberOfChains"] = "2"; paras["maxElements"] = "80"; swordTrail = (RibbonTrail)sceneMgr.CreateMovableObject("SinbadRibbon", "RibbonTrail", paras); swordTrail.MaterialName = "Examples/LightRibbonTrail"; swordTrail.TrailLength = 20; swordTrail.IsVisible = false; sceneMgr.RootSceneNode.AttachObject(swordTrail); for (int i = 0; i < 2; i++) { swordTrail.SetInitialColor(i, new ColorEx(1, 0.8f, 0)); swordTrail.SetColorChange(i, new ColorEx(0.75f, 0.25f, 0.25f, 0.25f)); swordTrail.SetWidthChange(i, 1); swordTrail.SetInitialWidth(i, 0.5f); } keyDirection = Axiom.Math.Vector3.Zero; verticalVelocity = 0; }
/// <summary> /// /// </summary> /// <param name="deltaTime"></param> private void UpdateBody(Real deltaTime) { // we will calculate this goalDirection = Axiom.Math.Vector3.Zero; if (keyDirection != Axiom.Math.Vector3.Zero && baseAnimID != AnimationID.Dance) { // calculate actually goal direction in world based on player's key directions goalDirection += keyDirection.z * cameraNode.Orientation.ZAxis; goalDirection += keyDirection.x * cameraNode.Orientation.XAxis; goalDirection.y = 0; goalDirection.Normalize(); Quaternion toGoal = bodyNode.Orientation.ZAxis.GetRotationTo(goalDirection); // calculate how much the character has to turn to face goal direction Real yawToGlobal = toGoal.Yaw; // this is how much the character CAN turn this frame Real yawAtSpeed = yawToGlobal / Utility.Abs(yawToGlobal) * deltaTime * TurnSpeed; // reduce "turnability" if we're in midair if (baseAnimID == AnimationID.JumpLoop) { yawAtSpeed *= 0.2; } // turn as much as we can, but not more than we need to if (yawToGlobal < 0) { yawToGlobal = Utility.Min <Real>(yawToGlobal, yawAtSpeed); } else if (yawToGlobal > 0) { yawToGlobal = Utility.Max <Real>(0, Utility.Min <Real>(yawToGlobal, yawAtSpeed)); } bodyNode.Yaw(yawToGlobal); // move in current body direction (not the goal direction) bodyNode.Translate(new Axiom.Math.Vector3(0, 0, deltaTime * RunSpeed * anims[(int)baseAnimID].Weight), TransformSpace.Local); } if (baseAnimID == AnimationID.JumpLoop) { // if we're jumping, add a vertical offset too, and apply gravity bodyNode.Translate(new Axiom.Math.Vector3(0, verticalVelocity * deltaTime, 0), TransformSpace.Local); verticalVelocity -= Gravity * deltaTime; Axiom.Math.Vector3 pos = bodyNode.Position; if (pos.y <= CharHeight) { // if we've hit the ground, change to landing state pos.y = CharHeight; bodyNode.Position = pos; SetBaseAnimation(AnimationID.JumpEnd, true); timer = 0; } } }
/// <summary> /// /// </summary> /// <param name="deltaTime"></param> private void UpdateCamera(Real deltaTime) { // place the camera pivot roughly at the character's shoulder cameraPivot.Position = bodyNode.Position + Axiom.Math.Vector3.UnitY * CamHeight; // move the camera smoothly to the goal Axiom.Math.Vector3 goalOffset = cameraGoal.DerivedPosition - cameraNode.Position; cameraNode.Translate(goalOffset * deltaTime * 9.0f); // always look at the pivot cameraNode.LookAt(cameraPivot.DerivedPosition, TransformSpace.World); }
/// <summary> /// /// </summary> public TerrainSample() { Metadata[ "Title" ] = "Terrain"; Metadata[ "Description" ] = "Demonstrates use of the terrain rendering plugin."; Metadata[ "Thumbnail" ] = "thumb_terrain.png"; Metadata[ "Category" ] = "Environment"; Metadata[ "Help" ] = "Left click and drag anywhere in the scene to look around. Let go again to show " + "cursor and access widgets. Use WASD keys to move. Use +/- keys when in edit mode to change content."; mode = Mode.Normal; layerEdit = 1; brushSizeTerrainSpace = 0.02f; terrainPos = new Vector3( 1000, 0, 5000 ); // Update terrain at max 20fps heightUpdateRate = 1.0f / 2.0f; }
public Triangle( Vector3 v1, Vector3 v2, Vector3 v3, ColorEx c1, ColorEx c2, ColorEx c3 ) { vertexData = new VertexData(); renderOperation.vertexData = vertexData; renderOperation.vertexData.vertexCount = 3; renderOperation.vertexData.vertexStart = 0; renderOperation.indexData = null; renderOperation.operationType = OperationType.TriangleList; renderOperation.useIndices = false; var decl = vertexData.vertexDeclaration; var binding = vertexData.vertexBufferBinding; // add a position and color element to the declaration decl.AddElement( POSITION, 0, VertexElementType.Float3, VertexElementSemantic.Position ); decl.AddElement( COLOR, 0, VertexElementType.Color, VertexElementSemantic.Diffuse ); // POSITIONS // create a vertex buffer for the position var buffer = HardwareBufferManager.Instance.CreateVertexBuffer( decl.Clone( POSITION ), vertexData.vertexCount, BufferUsage.StaticWriteOnly ); var positions = new Vector3[] { v1, v2, v3 }; // write the positions to the buffer buffer.WriteData( 0, buffer.Size, positions, true ); // bind the position buffer binding.SetBinding( POSITION, buffer ); // COLORS // create a color buffer buffer = HardwareBufferManager.Instance.CreateVertexBuffer( decl.Clone( COLOR ), vertexData.vertexCount, BufferUsage.StaticWriteOnly ); // create an int array of the colors to use. // note: these must be converted to the current API's // preferred packed int format var colors = new int[] { Root.Instance.RenderSystem.ConvertColor( c1 ), Root.Instance.RenderSystem.ConvertColor( c2 ), Root.Instance.RenderSystem.ConvertColor( c3 ) }; // write the colors to the color buffer buffer.WriteData( 0, buffer.Size, colors, true ); // bind the color buffer binding.SetBinding( COLOR, buffer ); // MATERIAL // grab a copy of the BaseWhite material for our use var material = (Material)MaterialManager.Instance.GetByName( "BaseWhite" ); material = material.Clone( "TriMat" ); // disable lighting to vertex colors are used material.Lighting = false; // set culling to none so the triangle is drawn 2 sided material.CullingMode = CullingMode.None; Material = material; // set the bounding box of the tri // TODO: not right, but good enough for now box = new AxisAlignedBox( new Vector3( 25, 50, 0 ), new Vector3( -25, 0, 0 ) ); }
/// <summary> /// /// </summary> /// <param name="sceneMgr"></param> private void SetupBody( SceneManager sceneMgr ) { // create main model bodyNode = sceneMgr.RootSceneNode.CreateChildSceneNode( Vector3.UnitY * CharHeight ); bodyEnt = sceneMgr.CreateEntity( "SinbadBody", "Sinbad.mesh" ); bodyNode.AttachObject( bodyEnt ); // create swords and attach to sheath sword1 = sceneMgr.CreateEntity( "SinbadSword1", "Sword.mesh" ); sword2 = sceneMgr.CreateEntity( "SinbadSword2", "Sword.mesh" ); bodyEnt.AttachObjectToBone( "Sheath.L", sword1 ); bodyEnt.AttachObjectToBone( "Sheath.R", sword2 ); // create a couple of ribbon trails for the swords, just for fun NamedParameterList paras = new NamedParameterList(); paras[ "numberOfChains" ] = "2"; paras[ "maxElements" ] = "80"; swordTrail = (RibbonTrail)sceneMgr.CreateMovableObject( "SinbadRibbon", "RibbonTrail", paras ); swordTrail.MaterialName = "Examples/LightRibbonTrail"; swordTrail.TrailLength = 20; swordTrail.IsVisible = false; sceneMgr.RootSceneNode.AttachObject( swordTrail ); for ( int i = 0; i < 2; i++ ) { swordTrail.SetInitialColor( i, new ColorEx( 1, 0.8f, 0 ) ); swordTrail.SetColorChange( i, new ColorEx( 0.75f, 0.25f, 0.25f, 0.25f ) ); swordTrail.SetWidthChange( i, 1 ); swordTrail.SetInitialWidth( i, 0.5f ); } keyDirection = Vector3.Zero; verticalVelocity = 0; }
/// <summary> /// Construct a plane through a normal, and a distance to move the plane along the normal. /// </summary> /// <param name="normal"></param> /// <param name="constant"></param> public Plane( Vector3 normal, Real constant ) { this.Normal = normal; this.D = -constant; }
/// <summary> /// Construct a plane from 3 coplanar points. /// </summary> /// <param name="point0">First point.</param> /// <param name="point1">Second point.</param> /// <param name="point2">Third point.</param> public void Redefine( Vector3 point0, Vector3 point1, Vector3 point2 ) { Vector3 edge1 = point1 - point0; Vector3 edge2 = point2 - point0; this.Normal = edge1.Cross( edge2 ); this.Normal.Normalize(); this.D = -this.Normal.Dot( point0 ); }
/// <summary> /// Project a point onto the plane. /// </summary> /// <param name="v"></param> /// <returns></returns> public Vector3 ProjectVector( Vector3 point ) { // We know plane normal is unit length, so use simple method Matrix3 xform; xform.m00 = 1.0f - this.Normal.x * this.Normal.x; xform.m01 = -this.Normal.x * this.Normal.y; xform.m02 = -this.Normal.x * this.Normal.z; xform.m10 = -this.Normal.y * this.Normal.x; xform.m11 = 1.0f - this.Normal.y * this.Normal.y; xform.m12 = -this.Normal.y * this.Normal.z; xform.m20 = -this.Normal.z * this.Normal.x; xform.m21 = -this.Normal.z * this.Normal.y; xform.m22 = 1.0f - this.Normal.z * this.Normal.z; return xform * point; }
/// <summary> /// /// </summary> /// <param name="point"></param> /// <returns></returns> public PlaneSide GetSide( Vector3 point ) { Real distance = this.GetDistance( point ); if( distance < 0.0f ) { return PlaneSide.Negative; } if( distance > 0.0f ) { return PlaneSide.Positive; } return PlaneSide.None; }
// set the origin value public void SetOrigin( Vector3 newOrigin ) { mOrigin = newOrigin; }
protected override void SetupContent() { var blankTerrain = false; this.editMarker = SceneManager.CreateEntity( "editMarker", "sphere.mesh" ); this.editNode = SceneManager.RootSceneNode.CreateChildSceneNode(); this.editNode.AttachObject( this.editMarker ); this.editNode.Scale = new Vector3( 0.05f, 0.05f, 0.05f ); _setupControls(); CameraManager.TopSpeed = 50; DragLook = true; MaterialManager.Instance.SetDefaultTextureFiltering( TextureFiltering.Anisotropic ); MaterialManager.Instance.DefaultAnisotropy = 7; SceneManager.SetFog( FogMode.Linear, new ColorEx( 0.07f, 0.07f, 0.08f ), 0, 10000, 25000 ); var lightDir = new Vector3( 0.55f, 0.3f, 0.75f ); lightDir.Normalize(); var l = SceneManager.CreateLight( "tsLight" ); l.Type = LightType.Directional; l.Direction = lightDir; l.Diffuse = ColorEx.White; l.Specular = new ColorEx( 0.4f, 0.4f, 0.4f ); SceneManager.AmbientLight = new ColorEx( 0.2f, 0.2f, 0.2f ); this.terrainGroup = new TerrainGroup( SceneManager, Alignment.Align_X_Z, (ushort)TerrainSize, TerrainWorldSize ); this.terrainGroup.SetFilenameConvention( TerrainFilePrefix, TerrainFileSuffix ); this.terrainGroup.Origin = this.terrainPos; _configureTerrainDefaults( l ); #if PAGING // Paging setup pageManager = new PageManager(); // Since we're not loading any pages from .page files, we need a way just // to say we've loaded them without them actually being loaded pageManager.PageProvider = dummyPageProvider; pageManager.AddCamera( Camera ); terrainPaging = new TerrainPaging( pageManager ); PagedWorld world = pageManager.CreateWorld(); terrainPaging.CreateWorldSection( world, terrainGroup, 2000, 3000, TerrainPageMinX, TerrainPageMinY, TerrainPageMaxX, TerrainPageMaxY ); #else for ( long x = TerrainPageMinX; x <= TerrainPageMaxX; ++x ) { for ( long y = TerrainPageMinY; y <= TerrainPageMaxY; ++y ) { _defineTerrain( x, y, blankTerrain ); } } // sync load since we want everything in place when we start this.terrainGroup.LoadAllTerrains( true ); #endif if ( this.terrainsImported ) { foreach ( var ts in this.terrainGroup.TerrainSlots ) { _initBlendMaps( ts.Instance ); } } this.terrainGroup.FreeTemporaryResources(); var e = SceneManager.CreateEntity( "TudoMesh", "tudorhouse.mesh" ); var entPos = new Vector3( this.terrainPos.x + 2043, 0, this.terrainPos.z + 1715 ); var rot = new Quaternion(); entPos.y = this.terrainGroup.GetHeightAtWorldPosition( entPos ) + 65.5 + this.terrainPos.y; rot = Quaternion.FromAngleAxis( Utility.RangeRandom( -180, 180 ), Vector3.UnitY ); var sn = SceneManager.RootSceneNode.CreateChildSceneNode( entPos, rot ); sn.Scale = new Vector3( 0.12, 0.12, 0.12 ); sn.AttachObject( e ); this.houseList.Add( e ); e = SceneManager.CreateEntity( "TudoMesh1", "tudorhouse.mesh" ); entPos = new Vector3( this.terrainPos.x + 1850, 0, this.terrainPos.z + 1478 ); entPos.y = this.terrainGroup.GetHeightAtWorldPosition( entPos ) + 65.5 + this.terrainPos.y; rot = Quaternion.FromAngleAxis( Utility.RangeRandom( -180, 180 ), Vector3.UnitY ); sn = SceneManager.RootSceneNode.CreateChildSceneNode( entPos, rot ); sn.Scale = new Vector3( 0.12, 0.12, 0.12 ); sn.AttachObject( e ); this.houseList.Add( e ); e = SceneManager.CreateEntity( "TudoMesh2", "tudorhouse.mesh" ); entPos = new Vector3( this.terrainPos.x + 1970, 0, this.terrainPos.z + 2180 ); entPos.y = this.terrainGroup.GetHeightAtWorldPosition( entPos ) + 65.5 + this.terrainPos.y; rot = Quaternion.FromAngleAxis( Utility.RangeRandom( -180, 180 ), Vector3.UnitY ); sn = SceneManager.RootSceneNode.CreateChildSceneNode( entPos, rot ); sn.Scale = new Vector3( 0.12, 0.12, 0.12 ); sn.AttachObject( e ); this.houseList.Add( e ); //SceneManager.SetSkyDome( true, "Examples/CloudyNoonSkyBox", 5000, 8 ); SceneManager.SetSkyDome( true, "Examples/CloudySky", 5000, 8 ); }
/// <summary> /// /// </summary> /// <param name="startPoint">Point where the line will start.</param> /// <param name="direction">The direction the vector is heading in.</param> /// <param name="length">The length (magnitude) of the line vector.</param> /// <param name="color">The color which this line should be.</param> public Line3d( Vector3 startPoint, Vector3 direction, float length, ColorEx color ) { // normalize the direction vector to ensure all elements fall in [0,1] range. direction.Normalize(); // calculate the actual endpoint var endPoint = startPoint + ( direction*length ); vertexData = new VertexData(); renderOperation.vertexData = vertexData; renderOperation.vertexData.vertexCount = 2; renderOperation.vertexData.vertexStart = 0; renderOperation.indexData = null; renderOperation.operationType = OperationType.LineList; renderOperation.useIndices = false; var decl = vertexData.vertexDeclaration; var binding = vertexData.vertexBufferBinding; // add a position and color element to the declaration decl.AddElement( POSITION, 0, VertexElementType.Float3, VertexElementSemantic.Position ); decl.AddElement( COLOR, 0, VertexElementType.Color, VertexElementSemantic.Diffuse ); // create a vertex buffer for the position var buffer = HardwareBufferManager.Instance.CreateVertexBuffer( decl.Clone( POSITION ), vertexData.vertexCount, BufferUsage.StaticWriteOnly ); var pos = new Vector3[] { startPoint, endPoint }; // write the data to the position buffer buffer.WriteData( 0, buffer.Size, pos, true ); // bind the position buffer binding.SetBinding( POSITION, buffer ); // create a color buffer buffer = HardwareBufferManager.Instance.CreateVertexBuffer( decl.Clone( COLOR ), vertexData.vertexCount, BufferUsage.StaticWriteOnly ); var colorValue = Root.Instance.RenderSystem.ConvertColor( color ); var colors = new int[] { colorValue, colorValue }; // write the data to the position buffer buffer.WriteData( 0, buffer.Size, colors, true ); // bind the color buffer binding.SetBinding( COLOR, buffer ); // MATERIAL // grab a copy of the BaseWhite material for our use var material = (Material)MaterialManager.Instance.GetByName( "BaseWhite" ); material = material.Clone( "LineMat" ); // disable lighting to vertex colors are used material.Lighting = false; // set culling to none so the triangle is drawn 2 sided material.CullingMode = CullingMode.None; Material = material; // set the bounding box of the line box = new AxisAlignedBox( startPoint, endPoint ); }
public virtual bool frameRenderingQueued( FrameEventArgs evt ) { if ( mStyle == CameraStyle.FreeLook ) { // build our acceleration vector based on keyboard input composite Vector3 accel = Vector3.Zero; if ( mGoingForward ) accel += mCamera.Direction; if ( mGoingBack ) accel -= mCamera.Direction; if ( mGoingRight ) accel += mCamera.Right; if ( mGoingLeft ) accel -= mCamera.Right; if ( mGoingUp ) accel += mCamera.Up; if ( mGoingDown ) accel -= mCamera.Up; // if accelerating, try to reach top speed in a certain time if ( accel.LengthSquared != 0 ) { accel.Normalize(); mVelocity += accel * TopSpeed * evt.TimeSinceLastFrame * 10; } // if not accelerating, try to stop in a certain time else mVelocity -= mVelocity * evt.TimeSinceLastFrame * 10; // keep camera velocity below top speed and above zero if ( mVelocity.LengthSquared > TopSpeed * TopSpeed ) { mVelocity.Normalize(); mVelocity *= TopSpeed; } else if ( mVelocity.LengthSquared < 0.1 ) mVelocity = Vector3.Zero; if ( mVelocity != Vector3.Zero ) mCamera.Move( mVelocity * evt.TimeSinceLastFrame ); } return true; }
/*----------------------------------------------------------------------------- | Manually stops the camera when in free-look mode. -----------------------------------------------------------------------------*/ public virtual void manualStop() { if ( mStyle == CameraStyle.FreeLook ) { mGoingForward = false; mGoingBack = false; mGoingLeft = false; mGoingRight = false; mGoingUp = false; mGoingDown = false; mVelocity = Vector3.Zero; } }
public SdkCameraManager( Camera cam ) { mTarget = null; mOrbiting = false; mZooming = false; mCamera = null; TopSpeed = 150; mGoingForward = false; mGoingBack = false; mGoingLeft = false; mGoingRight = false; mGoingUp = false; mGoingDown = false; mVelocity = Vector3.Zero; Camera = cam; setStyle( CameraStyle.FreeLook ); }
//---------------------------------------------------------------------------- public void Set( Vector3 newOrigin, Vector3 newEnd ) { Origin = newOrigin; // calc the direction vector Direction = newEnd - Origin; Extent = Direction.Normalize(); }
// set the origin plane public void SetOriginPlane( Vector3 rkNormal, Vector3 rkPoint ) { mOriginPlane.Redefine( rkNormal, rkPoint ); }
/// <summary> /// /// </summary> protected void Initialize() { Vector3 ax = Vector3.Zero, ay = Vector3.Zero, az = Vector3.Zero; int x = 0; Quaternion q = Quaternion.Identity; this.things.Clear(); this.orbits.Clear(); for ( x = 0; x < this.count; x++ ) { ax = new Vector3( GenerateRandomFloat(), GenerateRandomFloat(), GenerateRandomFloat() ); ay = new Vector3( GenerateRandomFloat(), GenerateRandomFloat(), GenerateRandomFloat() ); az = ax.Cross( ay ); ay = az.Cross( ax ); ax.Normalize(); ay.Normalize(); az.Normalize(); q = Quaternion.FromAxes( ax, ay, az ); this.things.Add( q ); ax = new Vector3( GenerateRandomFloat(), GenerateRandomFloat(), GenerateRandomFloat() ); ay = new Vector3( GenerateRandomFloat(), GenerateRandomFloat(), GenerateRandomFloat() ); az = ax.Cross( ay ); ay = az.Cross( ax ); ax.Normalize(); ay.Normalize(); az.Normalize(); q = Quaternion.FromAxes( ax, ay, az ); this.orbits.Add( q ); } int nVertices = this.count*4; var indexData = new IndexData(); var vertexData = new VertexData(); //Quads var faces = new short[this.count*6]; for ( x = 0; x < this.count; x++ ) { faces[ x*6 + 0 ] = (short)( x*4 + 0 ); faces[ x*6 + 1 ] = (short)( x*4 + 1 ); faces[ x*6 + 2 ] = (short)( x*4 + 2 ); faces[ x*6 + 3 ] = (short)( x*4 + 0 ); faces[ x*6 + 4 ] = (short)( x*4 + 2 ); faces[ x*6 + 5 ] = (short)( x*4 + 3 ); } vertexData.vertexStart = 0; vertexData.vertexCount = nVertices; VertexDeclaration decl = vertexData.vertexDeclaration; VertexBufferBinding bind = vertexData.vertexBufferBinding; int offset = 0; offset += decl.AddElement( 0, offset, VertexElementType.Float3, VertexElementSemantic.Position ).Size; this.vertexBuffer = HardwareBufferManager.Instance.CreateVertexBuffer( decl.Clone( 0 ), nVertices, BufferUsage.DynamicWriteOnly ); bind.SetBinding( 0, this.vertexBuffer ); HardwareIndexBuffer indexBuffer = HardwareBufferManager.Instance.CreateIndexBuffer( IndexType.Size16, this.count*6, BufferUsage.StaticWriteOnly ); indexData.indexBuffer = indexBuffer; indexData.indexStart = 0; indexData.indexCount = this.count*6; indexBuffer.WriteData( 0, indexBuffer.Size, faces, true ); faces = null; renderOperation.operationType = OperationType.TriangleList; renderOperation.indexData = indexData; renderOperation.vertexData = vertexData; renderOperation.useIndices = true; }
/// <summary> /// /// </summary> protected override void SetupContent() { bool blankTerrain = false; //editMarker = SceneManager.CreateEntity( "editMarker", "sphere.mesh" ); //editNode = SceneManager.RootSceneNode.CreateChildSceneNode(); //editNode.AttachObject( editMarker ); //editNode.Scale = new Vector3( 0.05f, 0.05f, 0.05f ); SetupControls(); CameraManager.TopSpeed = 50; DragLook = true; MaterialManager.Instance.SetDefaultTextureFiltering( TextureFiltering.Anisotropic ); MaterialManager.Instance.DefaultAnisotropy = 7; SceneManager.SetFog( FogMode.Linear, new ColorEx( 0.07f, 0.07f, 0.08f ), 0, 10000, 25000 ); Vector3 lightDir = new Vector3( 0.55f, 0.3f, 0.75f ); lightDir.Normalize(); Light l = SceneManager.CreateLight( "tsLight" ); l.Type = LightType.Directional; l.Direction = lightDir; l.Diffuse = ColorEx.White; l.Specular = new ColorEx( 0.4f, 0.4f, 0.4f ); SceneManager.AmbientLight = new ColorEx( 0.8f, 0.8f, 0.8f ); terrainGroup = new TerrainGroup( SceneManager, Alignment.Align_X_Z, (ushort)TerrainSize, TerrainWorldSize ); terrainGroup.SetFilenamConvention( TerrainFilePrefix, TerrainFileSuffix ); terrainGroup.Origin = Vector3.Zero; Axiom.Components.Terrain.Terrain terrain = new Components.Terrain.Terrain( SceneManager ); terrain.Position = terrainPos; ImportData data = ConfigureTerrainDefaults( l ); for ( long x = TerrainPageMinX; x <= TerrainPageMaxX; x++ ) { for ( long y = TerrainPageMinY; y <= TerrainPageMaxY; y++ ) { DefineTerrain( x, y, false ); } } // sync load since we want everything in place when we start terrainGroup.LoadAllTerrains( true ); if ( terrainsImported) { Axiom.Components.Terrain.Terrain t = terrainGroup.GetTerrain( 0, 0 ); InitBlendMaps( t ); } //Entity e = SceneManager.CreateEntity( "TudoMesh", "tudorhouse.mesh" ); //Vector3 entPos = new Vector3( terrainPos.x + 2043, 0, terrainPos.z + 1715 ); //Quaternion rot = new Quaternion(); //entPos.y = terrainGroup.GetTerrain(0,0).GetHeightAtWorldPosition( entPos ) + 65.5f + terrainPos.y; //rot = Quaternion.FromAngleAxis( Utility.RangeRandom( -180, 180 ), Vector3.UnitY ); //SceneNode sn = SceneManager.RootSceneNode.CreateChildSceneNode( entPos, rot ); //sn.Scale = new Vector3( 0.12, 0.12, 0.12 ); //sn.AttachObject( e ); //Camera.Position = entPos; terrainGroup.FreeTemporaryResources(); SceneManager.SetSkyDome( true, "Examples/CloudySky", 5, 8 ); //SceneManager.SetSkyBox( true, "Examples/CloudyNoonSkyBox" , 5000); }
public virtual PageID GetPageID( Vector3 worldPos ) { return this.mStrategy.GetPageID( worldPos, this ); }
/// <summary> /// This is a pseudodistance. The sign of the return value is /// positive if the point is on the positive side of the plane, /// negative if the point is on the negative side, and zero if the /// point is on the plane. /// The absolute value of the return value is the true distance only /// when the plane normal is a unit length vector. /// </summary> /// <param name="point"></param> /// <returns></returns> public Real GetDistance( Vector3 point ) { return this.Normal.Dot( point ) + this.D; }
public virtual Page LoadOrCreatePage( Vector3 worldPos ) { PageID id = GetPageID( worldPos ); // this will create a Page instance no matter what, even if load fails // we force the load attempt to happen immediately (forceSynchronous) LoadPage( id, true ); return GetPage( id ); }
/// <summary> /// Returns which side of the plane that the given box lies on. /// The box is defined as centre/half-size pairs for effectively. /// </summary> /// <param name="centre">The centre of the box.</param> /// <param name="halfSize">The half-size of the box.</param> /// <returns> /// Positive if the box complete lies on the "positive side" of the plane, /// Negative if the box complete lies on the "negative side" of the plane, /// and Both if the box intersects the plane. /// </returns> public PlaneSide GetSide( Vector3 centre, Vector3 halfSize ) { // Calculate the distance between box centre and the plane Real dist = this.GetDistance( centre ); // Calculate the maximise allows absolute distance for // the distance between box centre and plane Real maxAbsDist = this.Normal.AbsDot( halfSize ); if( dist < -maxAbsDist ) { return PlaneSide.Negative; } if( dist > +maxAbsDist ) { return PlaneSide.Positive; } return PlaneSide.Both; }
/// <summary> /// Default Costructor /// </summary> public DeflectorPlaneAffector() { this.type = "DeflectorPlane"; // defaults _planePoint = Vector3.Zero; _planeNormal = Vector3.UnitY; _bounce = 1.0f; }
/// <summary> /// Redefine this plane based on a normal and a point. /// </summary> /// <param name="rkNormal">Normal vector</param> /// <param name="rkPoint">Point vector</param> public void Redefine( Vector3 rkNormal, Vector3 rkPoint ) { this.Normal = rkNormal; this.D = -rkNormal.Dot( rkPoint ); }
private static void _createSphere( Mesh mesh ) { // sphere creation code taken from the DeferredShading sample, originally from the [Ogre] wiki var pSphereVertex = mesh.CreateSubMesh(); const int NUM_SEGMENTS = 16; const int NUM_RINGS = 16; const float SPHERE_RADIUS = 50.0f; mesh.SharedVertexData = new VertexData(); var vertexData = mesh.SharedVertexData; // define the vertex format var vertexDecl = vertexData.vertexDeclaration; var offset = 0; // positions vertexDecl.AddElement( 0, offset, VertexElementType.Float3, VertexElementSemantic.Position ); offset += VertexElement.GetTypeSize( VertexElementType.Float3 ); // normals vertexDecl.AddElement( 0, offset, VertexElementType.Float3, VertexElementSemantic.Normal ); offset += VertexElement.GetTypeSize( VertexElementType.Float3 ); // two dimensional texture coordinates vertexDecl.AddElement( 0, offset, VertexElementType.Float2, VertexElementSemantic.TexCoords, 0 ); offset += VertexElement.GetTypeSize( VertexElementType.Float2 ); // allocate the vertex buffer vertexData.vertexCount = ( NUM_RINGS + 1 )*( NUM_SEGMENTS + 1 ); var vBuf = HardwareBufferManager.Instance.CreateVertexBuffer( vertexDecl.Clone( 0 ), vertexData.vertexCount, BufferUsage.StaticWriteOnly, false ); var binding = vertexData.vertexBufferBinding; binding.SetBinding( 0, vBuf ); // allocate index buffer pSphereVertex.IndexData.indexCount = 6*NUM_RINGS*( NUM_SEGMENTS + 1 ); pSphereVertex.IndexData.indexBuffer = HardwareBufferManager.Instance.CreateIndexBuffer( IndexType.Size16, pSphereVertex.IndexData. indexCount, BufferUsage.StaticWriteOnly, false ); var iBuf = pSphereVertex.IndexData.indexBuffer; #if !AXIOM_SAFE_ONLY unsafe #endif { var iVertex = 0; var pVertex = vBuf.Lock( BufferLocking.Discard ).ToFloatPointer(); var iIndices = 0; var pIndices = iBuf.Lock( BufferLocking.Discard ).ToUShortPointer(); float fDeltaRingAngle = ( Utility.PI/NUM_RINGS ); float fDeltaSegAngle = ( 2*Utility.PI/NUM_SEGMENTS ); ushort wVerticeIndex = 0; // Generate the group of rings for the sphere for ( var ring = 0; ring <= NUM_RINGS; ring++ ) { float r0 = SPHERE_RADIUS*Utility.Sin( ring*fDeltaRingAngle ); float y0 = SPHERE_RADIUS*Utility.Cos( ring*fDeltaRingAngle ); // Generate the group of segments for the current ring for ( var seg = 0; seg <= NUM_SEGMENTS; seg++ ) { float x0 = r0*Utility.Sin( seg*fDeltaSegAngle ); float z0 = r0*Utility.Cos( seg*fDeltaSegAngle ); // Add one vertex to the strip which makes up the sphere pVertex[ iVertex++ ] = x0; pVertex[ iVertex++ ] = y0; pVertex[ iVertex++ ] = z0; var vNormal = new Vector3( x0, y0, z0 ).ToNormalized(); pVertex[ iVertex++ ] = vNormal.x; pVertex[ iVertex++ ] = vNormal.y; pVertex[ iVertex++ ] = vNormal.z; pVertex[ iVertex++ ] = (float)seg/(float)NUM_SEGMENTS; pVertex[ iVertex++ ] = (float)ring/(float)NUM_RINGS; if ( ring != NUM_RINGS ) { // each vertex (except the last) has six indicies pointing to it pIndices[ iIndices++ ] = (ushort)( wVerticeIndex + NUM_SEGMENTS + 1 ); pIndices[ iIndices++ ] = (ushort)( wVerticeIndex ); pIndices[ iIndices++ ] = (ushort)( wVerticeIndex + NUM_SEGMENTS ); pIndices[ iIndices++ ] = (ushort)( wVerticeIndex + NUM_SEGMENTS + 1 ); pIndices[ iIndices++ ] = (ushort)( wVerticeIndex + 1 ); pIndices[ iIndices++ ] = (ushort)( wVerticeIndex ); wVerticeIndex++; } } ; // end for seg } // end for ring } // Unlock vBuf.Unlock(); iBuf.Unlock(); // Generate face list pSphereVertex.useSharedVertices = true; // the original code was missing this line: mesh.BoundingBox = new AxisAlignedBox( new Vector3( -SPHERE_RADIUS, -SPHERE_RADIUS, -SPHERE_RADIUS ), new Vector3( SPHERE_RADIUS, SPHERE_RADIUS, SPHERE_RADIUS ) ); mesh.BoundingSphereRadius = SPHERE_RADIUS; }
//public Plane() //{ // this.Normal = Vector3.Zero; // this.D = Real.NaN; //} public Plane( Plane plane ) { this.Normal = plane.Normal; this.D = plane.D; }
/// <summary> /// Default Costructor /// </summary> public DeflectorPlaneAffector( ParticleSystem psys ) : base( psys ) { type = "DeflectorPlane"; // defaults this._planePoint = Vector3.Zero; this._planeNormal = Vector3.UnitY; this._bounce = 1.0f; }
public Plane( Vector3 normal, Vector3 point ) { this.Normal = normal; this.D = -normal.Dot( point ); }
public override void CreateScene() { // Register Compositor Logics CompositorManager.Instance.RegisterCompositorLogic( "HDR", new HdrLogic() ); scene.ShadowTechnique = ShadowTechnique.TextureModulative; scene.ShadowFarDistance = 1000; scene.AmbientLight = new ColorEx( 0.3f, 0.3f, 0.2f ); Light light = scene.CreateLight( "Light2" ); Vector3 dir = new Vector3( -1, -1, 0 ); dir.Normalize(); light.Type = LightType.Directional; light.Direction = dir; light.Diffuse = new ColorEx( 1.0f, 1.0f, 0.8f ); light.Specular = new ColorEx( 1.0f, 1.0f, 1.0f ); Entity entity; // House entity = scene.CreateEntity( "1", "tudorhouse.mesh" ); SceneNode n1 = scene.RootSceneNode.CreateChildSceneNode( new Vector3( 350, 450, -200 ) ); n1.AttachObject( entity ); entity = scene.CreateEntity( "2", "tudorhouse.mesh" ); SceneNode n2 = scene.RootSceneNode.CreateChildSceneNode( new Vector3( -350, 450, -200 ) ); n2.AttachObject( entity ); entity = scene.CreateEntity( "3", "knot.mesh" ); _spinny = scene.RootSceneNode.CreateChildSceneNode( new Vector3( 0, 0, 300 ) ); _spinny.AttachObject( entity ); entity.MaterialName = "Examples/MorningCubeMap"; scene.SetSkyBox( true, "Examples/MorningSkyBox", 50 ); Plane plane = new Plane(); plane.Normal = Vector3.UnitY; plane.D = 100; MeshManager.Instance.CreatePlane( "Myplane", ResourceGroupManager.DefaultResourceGroupName, plane, 1500, 1500, 10, 10, true, 1, 5, 5, Vector3.UnitZ ); Entity planeEntity = scene.CreateEntity( "plane", "Myplane" ); planeEntity.MaterialName = "Examples/Rockwall"; planeEntity.CastShadows = false; scene.RootSceneNode.CreateChildSceneNode().AttachObject( planeEntity ); camera.Position = new Vector3( -400, 50, 900 ); camera.LookAt( new Vector3( 0, 80, 0 ) ); /// Create a couple of hard coded postfilter effects as an example of how to do it /// but the preferred method is to use compositor scripts. _createEffects(); foreach ( string name in _compositorList ) { CompositorManager.Instance.AddCompositor( this.window.GetViewport( 0 ), name ); } //CompositorManager.Instance.SetCompositorEnabled(this.window.GetViewport(0), // _compositorList[_compositorList.Length - 2], // true); CompositorManager.Instance.SetCompositorEnabled( this.window.GetViewport( 0 ), _compositorList[ 0 ], true ); }
/// <summary> /// /// </summary> /// <param name="deltaTime"></param> private void UpdateBody( Real deltaTime ) { // we will calculate this goalDirection = Vector3.Zero; if ( keyDirection != Vector3.Zero && baseAnimID != AnimationID.Dance ) { // calculate actually goal direction in world based on player's key directions goalDirection += keyDirection.z * cameraNode.Orientation.ZAxis; goalDirection += keyDirection.x * cameraNode.Orientation.XAxis; goalDirection.y = 0; goalDirection.Normalize(); Quaternion toGoal = bodyNode.Orientation.ZAxis.GetRotationTo( goalDirection ); // calculate how much the character has to turn to face goal direction Real yawToGlobal = toGoal.Yaw; // this is how much the character CAN turn this frame Real yawAtSpeed = yawToGlobal / Utility.Abs( yawToGlobal ) * deltaTime * TurnSpeed; // reduce "turnability" if we're in midair if ( baseAnimID == AnimationID.JumpLoop ) yawAtSpeed *= 0.2; // turn as much as we can, but not more than we need to if ( yawToGlobal < 0 ) yawToGlobal = Utility.Min<Real>( yawToGlobal, yawAtSpeed ); else if ( yawToGlobal > 0 ) yawToGlobal = Utility.Max<Real>( 0, Utility.Min<Real>( yawToGlobal, yawAtSpeed ) ); bodyNode.Yaw( yawToGlobal ); // move in current body direction (not the goal direction) bodyNode.Translate( new Vector3( 0, 0, deltaTime * RunSpeed * anims[ (int)baseAnimID ].Weight ), TransformSpace.Local ); } if ( baseAnimID == AnimationID.JumpLoop ) { // if we're jumping, add a vertical offset too, and apply gravity bodyNode.Translate( new Vector3( 0, verticalVelocity * deltaTime, 0 ), TransformSpace.Local ); verticalVelocity -= Gravity * deltaTime; Vector3 pos = bodyNode.Position; if ( pos.y <= CharHeight ) { // if we've hit the ground, change to landing state pos.y = CharHeight; bodyNode.Position = pos; SetBaseAnimation( AnimationID.JumpEnd, true ); timer = 0; } } }
public void DoTerrainModify( Axiom.Components.Terrain.Terrain terrain, Vector3 centrepos, Real timeElapsed ) { var tsPos = Vector3.Zero; terrain.GetTerrainPosition( centrepos, ref tsPos ); #if !( WINDOWS_PHONE || XBOX || XBOX360 || ANDROID || IOS ) if ( Keyboard.IsKeyDown( SIS.KeyCode.Key_EQUALS ) || Keyboard.IsKeyDown( SIS.KeyCode.Key_ADD ) || Keyboard.IsKeyDown( SIS.KeyCode.Key_MINUS ) || Keyboard.IsKeyDown( SIS.KeyCode.Key_SUBTRACT ) ) { switch ( this.mode ) { case Mode.EditHeight: { // we need point coords Real terrainSize = ( terrain.Size - 1 ); var startx = (long)( ( tsPos.x - this.brushSizeTerrainSpace )*terrainSize ); var starty = (long)( ( tsPos.y - this.brushSizeTerrainSpace )*terrainSize ); var endx = (long)( ( tsPos.x + this.brushSizeTerrainSpace )*terrainSize ); var endy = (long)( ( tsPos.y + this.brushSizeTerrainSpace )*terrainSize ); startx = Utility.Max( startx, 0L ); starty = Utility.Max( starty, 0L ); endx = Utility.Min( endx, (long)terrainSize ); endy = Utility.Min( endy, (long)terrainSize ); for ( long y = starty; y <= endy; ++y ) { for ( long x = startx; x <= endx; ++x ) { Real tsXdist = ( x/terrainSize ) - tsPos.x; Real tsYdist = ( y/terrainSize ) - tsPos.y; Real weight = Utility.Min( (Real)1.0, Utility.Sqrt( tsYdist*tsYdist + tsXdist*tsXdist )/ (Real)( 0.5*this.brushSizeTerrainSpace ) ); weight = 1.0 - ( weight*weight ); var addedHeight = weight*250.0*timeElapsed; float newheight; if ( Keyboard.IsKeyDown( SIS.KeyCode.Key_EQUALS ) || Keyboard.IsKeyDown( SIS.KeyCode.Key_ADD ) ) { newheight = terrain.GetHeightAtPoint( x, y ) + addedHeight; } else { newheight = terrain.GetHeightAtPoint( x, y ) - addedHeight; } terrain.SetHeightAtPoint( x, y, newheight ); } } if ( this.heightUpdateCountDown == 0 ) { this.heightUpdateCountDown = this.heightUpdateRate; } } break; case Mode.EditBlend: { var layer = terrain.GetLayerBlendMap( this.layerEdit ); // we need image coords Real imgSize = terrain.LayerBlendMapSize; var startx = (long)( ( tsPos.x - this.brushSizeTerrainSpace )*imgSize ); var starty = (long)( ( tsPos.y - this.brushSizeTerrainSpace )*imgSize ); var endx = (long)( ( tsPos.x + this.brushSizeTerrainSpace )*imgSize ); var endy = (long)( ( tsPos.y + this.brushSizeTerrainSpace )*imgSize ); startx = Utility.Max( startx, 0L ); starty = Utility.Max( starty, 0L ); endx = Utility.Min( endx, (long)imgSize ); endy = Utility.Min( endy, (long)imgSize ); for ( var y = (int)starty; y <= endy; ++y ) { for ( var x = (int)startx; x <= endx; ++x ) { Real tsXdist = ( x/imgSize ) - tsPos.x; Real tsYdist = ( y/imgSize ) - tsPos.y; Real weight = Utility.Min( (Real)1.0, Utility.Sqrt( tsYdist*tsYdist + tsXdist*tsXdist )/ (Real)( 0.5*this.brushSizeTerrainSpace ) ); weight = 1.0 - ( weight*weight ); float paint = weight*timeElapsed; var imgY = (int)( imgSize - y ); float val; if ( Keyboard.IsKeyDown( SIS.KeyCode.Key_EQUALS ) || Keyboard.IsKeyDown( SIS.KeyCode.Key_ADD ) ) { val = layer.GetBlendValue( x, imgY ) + paint; } else { val = layer.GetBlendValue( x, imgY ) - paint; } val = Utility.Clamp( val, 1.0f, 0.0f ); layer.SetBlendValue( x, imgY, val ); } } layer.Update(); } break; case Mode.Normal: case Mode.Count: default: break; } ; } #endif }