| public static ToRadians ( float degrees ) : float | ||
| degrees | float | |
| return | float | |
public WpRagdollSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
GraphicsScreen.ClearBackground = true;
GraphicsScreen.BackgroundColor = Color.CornflowerBlue;
// Set a fixed camera.
var projection = new PerspectiveProjection();
projection.SetFieldOfView(
MathHelper.ToRadians(30),
GraphicsService.GraphicsDevice.Viewport.AspectRatio,
1f,
100.0f);
Vector3F cameraTarget = new Vector3F(0, 1, 0);
Vector3F cameraPosition = new Vector3F(0, 12, 0);
Vector3F cameraUpVector = new Vector3F(0, 0, -1);
GraphicsScreen.CameraNode = new CameraNode(new Camera(projection))
{
View = Matrix44F.CreateLookAt(cameraPosition, cameraTarget, cameraUpVector),
};
InitializePhysics();
}
private void BuildStation()
{
BuildRings(125, 175);
BuildRings(250, 300);
BuildBridge(175, 250, 45, 45.2f, floorTile);
BuildBridge(175, 250, 45.2f, 45.2f, 3);
BuildBridge(175, 250, 45, 45, 3);
BuildBridge(175, 250, 45 - 180, 45.2f - 180, floorTile);
BuildBridge(175, 250, 45.2f - 180f, 45.2f - 180, 3);
BuildBridge(175, 250, 45 - 180, 45 - 180, 3);
BuildBridge(175, 250, 45 - 360, 45.2f - 360, floorTile);
BuildBridge(175, 250, 45.2f - 360, 45.2f - 360, 3);
BuildBridge(175, 250, 45 - 360, 45 - 360, 3);
GameData <Room> roomData = new GameData <Room>();
roomData.folderPath = @"Saves\Rooms\";
Room tempRoom = roomData.LoadObjectData("FloorDecal3");
rooms.Add(tempRoom);
BuildRoomsOnRing(150, MathHelper.ToRadians(10f));
BuildRooms(125, 175, 1.85f);
BuildRooms(250, 300, 1.95f);
}
private void BuildRooms(int r1, int r2, float roomModifier)
{
int tileX = 0;
int tileY = 0;
float startAngle;
float endAngle;
float roomSize = roomModifier;
//float mRadius;
Point middle = new Point(tileMap.GetLength(0) / 2, tileMap.GetLength(1) / 2);
for (float d = 0; d < 2 * Math.PI; d += .0001f)
{
startAngle = d;
endAngle = startAngle + MathHelper.ToRadians(Game1.random.Next(3, 7));
// Close Room
for (float a = startAngle; a < endAngle; a += .0001f)
{
tileX = (int)(Math.Cos(a) * ((r1 + r2) / roomSize)) + middle.X;
tileY = (int)(Math.Sin(a) * ((r1 + r2) / roomSize)) + middle.Y;
tileMap[tileX, tileY] = 3;
tileX = (int)(Math.Cos(a) * r2) + middle.X;
tileY = (int)(Math.Sin(a) * r2) + middle.Y;
tileMap[tileX, tileY] = 3;
}
float roomOpening = ((startAngle + endAngle) / 2);
for (float r = roomOpening; r <= roomOpening + MathHelper.ToRadians(.5f); r += .001f)
{
tileX = (int)(Math.Cos(r) * ((r1 + r2) / roomSize)) + middle.X;
tileY = (int)(Math.Sin(r) * ((r1 + r2) / roomSize)) + middle.Y;
tileMap[tileX, tileY] = floorTile;
}
BuildWall(r1, r2, roomSize, startAngle);
BuildWall(r1, r2, roomSize, endAngle);
d = endAngle + MathHelper.ToRadians(3);
}
//tileMap[tileX, tileY] = 3;
}
public WindowsPhoneSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
GraphicsScreen.ClearBackground = true;
GraphicsScreen.BackgroundColor = Color.CornflowerBlue;
// Set a fixed camera.
var projection = new PerspectiveProjection();
projection.SetFieldOfView(
MathHelper.ToRadians(30),
GraphicsService.GraphicsDevice.Viewport.AspectRatio,
1f,
1000.0f);
Vector3F cameraTarget = new Vector3F(0, 1, 0);
Vector3F cameraPosition = new Vector3F(0, 12, 0);
Vector3F cameraUpVector = new Vector3F(0, 0, -1);
GraphicsScreen.CameraNode = new CameraNode(new Camera(projection))
{
View = Matrix44F.CreateLookAt(cameraPosition, cameraTarget, cameraUpVector),
};
// We use the accelerometer to control the camera view. The accelerometer registers every
// little change, but we do not want a shaky camera. We can use a low-pass filter to smooth
// the sensor signal.
_lowPassFilter = new LowPassFilter(new Vector3F(0, -1, 0))
{
TimeConstant = 0.15f, // Let's try a time constant of 0.15 seconds.
// When increasing the time constant the camera becomes more stable,
// but also slower.
};
// Enable touch gestures
_originalEnabledGestures = TouchPanel.EnabledGestures;
TouchPanel.EnabledGestures =
GestureType.Tap // Tap is used to drop new bodies.
| GestureType.Flick // Flick creates an explosion.
| GestureType.Hold // Hold to clear the scene.
| GestureType.Pinch; // Pinch can be used to zoom in or out.
InitializePhysics();
}
public SpaceStation(int radius, string name)
{
InitializeMap(radius);
entityName = name;
GameData <Room> roomData = new GameData <Room>();
roomData.folderPath = @"Saves\Rooms\";
Room tempRoom = roomData.LoadObjectData("Room1");
rooms.Add(tempRoom);
BuildRoomsOnRing(radius / 4, MathHelper.ToRadians(20));
BuildRoomsOnRing(radius / 2, MathHelper.ToRadians(10));
position = new Vector2();
nodeMesh = new World.NodeMesh();
InitializeCellSpacePartition();
InitializeILocalCellPartition();
}
public override void Update(System.TimeSpan time)
{
base.Update(time);
_angle -= MathHelper.ToRadians(0.5f);
if (_angle < 0.0f)
{
_angle += MathHelper.TwoPi;
}
if (SadConsole.Global.KeyboardState.IsKeyReleased(Microsoft.Xna.Framework.Input.Keys.T))
{
toggle = !toggle;
Clear();
}
if (SadConsole.Global.KeyboardState.IsKeyReleased(Microsoft.Xna.Framework.Input.Keys.B))
{
reader1.UseBlockMode = !reader1.UseBlockMode;
}
}
public SplitScreenSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
SampleFramework.IsMouseVisible = false;
_graphicsScreen = new SplitScreen(Services);
_graphicsScreen.DrawReticle = true;
GraphicsService.Screens.Insert(0, _graphicsScreen);
Services.Register(typeof(DebugRenderer), null, _graphicsScreen.DebugRenderer);
Services.Register(typeof(IScene), null, _graphicsScreen.Scene);
// Add gravity and damping to the physics Simulation.
Simulation.ForceEffects.Add(new Gravity());
Simulation.ForceEffects.Add(new Damping());
// Add a custom game object which controls the camera of player A.
var cameraGameObject = new CameraObject(Services);
GameObjectService.Objects.Add(cameraGameObject);
_graphicsScreen.ActiveCameraNode = cameraGameObject.CameraNode;
var projection = (PerspectiveProjection)cameraGameObject.CameraNode.Camera.Projection;
projection.SetFieldOfView(
projection.FieldOfViewY,
GraphicsService.GraphicsDevice.Viewport.AspectRatio / 2,
projection.Near,
projection.Far);
cameraGameObject.CameraNode.Camera = new Camera(projection);
// A second camera for player B.
_cameraNodeB = new CameraNode(cameraGameObject.CameraNode.Camera);
_graphicsScreen.ActiveCameraNodeB = _cameraNodeB;
GameObjectService.Objects.Add(new GrabObject(Services));
GameObjectService.Objects.Add(new GroundObject(Services));
GameObjectService.Objects.Add(new DudeObject(Services));
GameObjectService.Objects.Add(new ObjectCreatorObject(Services));
GameObjectService.Objects.Add(new LavaBallsObject(Services));
GameObjectService.Objects.Add(new FogObject(Services));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Barrier", 0.9f, new Pose(new Vector3(0, 0, -2))));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Cylinder", 0.9f, new Pose(new Vector3(3, 0, 0), Quaternion.CreateRotationY(MathHelper.ToRadians(-20)))));
GameObjectService.Objects.Add(new StaticSkyObject(Services));
// Add a few palm trees.
Random random = new Random(12345);
for (int i = 0; i < 10; i++)
{
Vector3 position = new Vector3(random.NextFloat(-3, -8), 0, random.NextFloat(0, -5));
Matrix orientation = Matrix.CreateRotationY(random.NextFloat(0, ConstantsF.TwoPi));
float scale = random.NextFloat(0.5f, 1.2f);
GameObjectService.Objects.Add(new StaticObject(Services, "PalmTree/palm_tree", scale, new Pose(position, orientation)));
}
}
public SkySample(Microsoft.Xna.Framework.Game game)
: base(game)
{
SampleFramework.IsMouseVisible = false;
_graphicsScreen = new DeferredGraphicsScreen(Services);
_graphicsScreen.DrawReticle = true;
GraphicsService.Screens.Insert(0, _graphicsScreen);
GameObjectService.Objects.Add(new DeferredGraphicsOptionsObject(Services));
Services.Register(typeof(DebugRenderer), null, _graphicsScreen.DebugRenderer);
Services.Register(typeof(IScene), null, _graphicsScreen.Scene);
// Add gravity and damping to the physics Simulation.
Simulation.ForceEffects.Add(new Gravity());
Simulation.ForceEffects.Add(new Damping());
// Add a custom game object which controls the camera.
var cameraGameObject = new CameraObject(Services);
GameObjectService.Objects.Add(cameraGameObject);
_graphicsScreen.ActiveCameraNode = cameraGameObject.CameraNode;
GameObjectService.Objects.Add(new GrabObject(Services));
GameObjectService.Objects.Add(new GroundObject(Services));
GameObjectService.Objects.Add(new DudeObject(Services));
GameObjectService.Objects.Add(new ObjectCreatorObject(Services));
GameObjectService.Objects.Add(new LavaBallsObject(Services));
GameObjectService.Objects.Add(new FogObject(Services));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Barrier", 0.9f, new Pose(new Vector3(0, 0, -2))));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Cylinder", 0.9f, new Pose(new Vector3(3, 0, 0), Quaternion.CreateRotationY(MathHelper.ToRadians(-20)))));
// The DynamicSkyObject creates the dynamic sky and lights.
GameObjectService.Objects.Add(new DynamicSkyObject(Services));
// Add a few palm trees.
Random random = new Random(12345);
for (int i = 0; i < 10; i++)
{
Vector3 position = new Vector3(random.NextFloat(-3, -8), 0, random.NextFloat(0, -5));
Matrix orientation = Matrix.CreateRotationY(random.NextFloat(0, ConstantsF.TwoPi));
float scale = random.NextFloat(0.5f, 1.2f);
GameObjectService.Objects.Add(new StaticObject(Services, "PalmTree/palm_tree", scale, new Pose(position, orientation)));
}
// Add a grain filter to add some noise in the night.
_graphicsScreen.PostProcessors.Add(new GrainFilter(GraphicsService)
{
IsAnimated = true,
LuminanceThreshold = 0.3f,
ScaleWithLuminance = true,
Strength = 0.04f,
GrainScale = 1.5f,
});
}
// Add a 3D coordinate cross.
private void CreateGizmo(SpriteFont spriteFont)
{
var gizmoNode = new SceneNode
{
Name = "Gizmo",
Children = new SceneNodeCollection(),
PoseLocal = new Pose(new Vector3F(3, 2, 0)),
ScaleLocal = new Vector3F(0.5f)
};
// Red arrow
var arrow = new PathFigure2F();
arrow.Segments.Add(new LineSegment2F {
Point1 = new Vector2F(0, 0), Point2 = new Vector2F(1, 0)
});
arrow.Segments.Add(new LineSegment2F {
Point1 = new Vector2F(1, 0), Point2 = new Vector2F(0.9f, 0.02f)
});
arrow.Segments.Add(new LineSegment2F {
Point1 = new Vector2F(1, 0), Point2 = new Vector2F(0.9f, -0.02f)
});
var figureNode = new FigureNode(arrow)
{
Name = "Gizmo X",
StrokeThickness = 2,
StrokeColor = new Vector3F(1, 0, 0),
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Green arrow
var transformedArrow = new TransformedFigure(arrow)
{
Pose = new Pose(Matrix33F.CreateRotationZ(MathHelper.ToRadians(90)))
};
figureNode = new FigureNode(transformedArrow)
{
Name = "Gizmo Y",
StrokeThickness = 2,
StrokeColor = new Vector3F(0, 1, 0),
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Blue arrow
transformedArrow = new TransformedFigure(arrow)
{
Pose = new Pose(Matrix33F.CreateRotationY(MathHelper.ToRadians(-90)))
};
figureNode = new FigureNode(transformedArrow)
{
Name = "Gizmo Z",
StrokeThickness = 2,
StrokeColor = new Vector3F(0, 0, 1),
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Red arc
var arc = new PathFigure2F();
arc.Segments.Add(
new StrokedSegment2F(
new LineSegment2F {
Point1 = new Vector2F(0, 0), Point2 = new Vector2F(1, 0),
},
false));
arc.Segments.Add(
new ArcSegment2F
{
Point1 = new Vector2F(1, 0),
Point2 = new Vector2F(0, 1),
Radius = new Vector2F(1, 1)
});
arc.Segments.Add(
new StrokedSegment2F(
new LineSegment2F {
Point1 = new Vector2F(0, 1), Point2 = new Vector2F(0, 0),
},
false));
var transformedArc = new TransformedFigure(arc)
{
Scale = new Vector3F(0.333f),
Pose = new Pose(Matrix33F.CreateRotationY(MathHelper.ToRadians(-90)))
};
figureNode = new FigureNode(transformedArc)
{
Name = "Gizmo YZ",
StrokeThickness = 2,
StrokeColor = new Vector3F(1, 0, 0),
FillColor = new Vector3F(1, 0, 0),
FillAlpha = 0.5f,
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Green arc
transformedArc = new TransformedFigure(arc)
{
Scale = new Vector3F(0.333f),
Pose = new Pose(Matrix33F.CreateRotationX(MathHelper.ToRadians(90)))
};
figureNode = new FigureNode(transformedArc)
{
Name = "Gizmo XZ",
StrokeThickness = 2,
StrokeColor = new Vector3F(0, 1, 0),
FillColor = new Vector3F(0, 1, 0),
FillAlpha = 0.5f,
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Blue arc
transformedArc = new TransformedFigure(arc)
{
Scale = new Vector3F(0.333f),
};
figureNode = new FigureNode(transformedArc)
{
Name = "Gizmo XY",
StrokeThickness = 2,
StrokeColor = new Vector3F(0, 0, 1),
FillColor = new Vector3F(0, 0, 1),
FillAlpha = 0.5f,
PoseLocal = new Pose(new Vector3F(0, 0, 0))
};
gizmoNode.Children.Add(figureNode);
// Labels "X", "Y", "Z"
var spriteNode = new SpriteNode(new TextSprite("X", spriteFont))
{
Color = new Vector3F(1, 0, 0),
Origin = new Vector2F(0, 1),
PoseLocal = new Pose(new Vector3F(1, 0, 0))
};
gizmoNode.Children.Add(spriteNode);
spriteNode = new SpriteNode(new TextSprite("Y", spriteFont))
{
Color = new Vector3F(0, 1, 0),
Origin = new Vector2F(0, 1),
PoseLocal = new Pose(new Vector3F(0, 1, 0))
};
gizmoNode.Children.Add(spriteNode);
spriteNode = new SpriteNode(new TextSprite("Z", spriteFont))
{
Color = new Vector3F(0, 0, 1),
Origin = new Vector2F(0, 1),
PoseLocal = new Pose(new Vector3F(0, 0, 1))
};
gizmoNode.Children.Add(spriteNode);
_scene.Children.Add(gizmoNode);
}
private float SinOscillate(float freq, int range, uint current_tick)
{
float anglef = (float)((int)((current_tick / 2.7777f) * freq) % 360);
return(Math.Sign(MathHelper.ToRadians(anglef)) * range);
}
private bool _cullingEnabled = true; // True to use frustum culling. False to disable frustum culling.
public FrustumCullingSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
GraphicsScreen.ClearBackground = true;
GraphicsScreen.BackgroundColor = Color.CornflowerBlue;
// The top-down camera.
var orthographicProjection = new OrthographicProjection();
orthographicProjection.Set(
LevelSize * 1.1f * GraphicsService.GraphicsDevice.Viewport.AspectRatio,
LevelSize * 1.1f,
1,
10000f);
var topDownCamera = new Camera(orthographicProjection);
_topDownCameraNode = new CameraNode(topDownCamera)
{
View = Matrix44F.CreateLookAt(new Vector3F(0, 1000, 0), new Vector3F(0, 0, 0), -Vector3F.UnitZ),
};
// The perspective camera moving through the scene.
var perspectiveProjection = new PerspectiveProjection();
perspectiveProjection.SetFieldOfView(
MathHelper.ToRadians(45),
GraphicsService.GraphicsDevice.Viewport.AspectRatio,
1,
500);
var sceneCamera = new Camera(perspectiveProjection);
_sceneCameraNode = new CameraNode(sceneCamera);
// Initialize collision detection.
// We use one collision domain that manages all objects.
_domain = new CollisionDomain(new CollisionDetection())
{
// We exchange the default broad phase with a DualPartition. The DualPartition
// has special support for frustum culling.
BroadPhase = new DualPartition <CollisionObject>(),
};
// Create a lot of random objects and add them to the collision domain.
RandomHelper.Random = new Random(12345);
for (int i = 0; i < NumberOfObjects; i++)
{
// A real scene consists of a lot of complex objects such as characters, vehicles,
// buildings, lights, etc. When doing frustum culling we need to test each objects against
// the viewing frustum. If it intersects with the viewing frustum, the object is visible
// from the camera's point of view. However, in practice we do not test the exact object
// against the viewing frustum. Each objects is approximated by a simpler shape. In our
// example, we assume that each object is approximated with an oriented bounding box.
// (We could also use an other shape, such as a bounding sphere.)
// Create a random box.
Shape randomShape = new BoxShape(RandomHelper.Random.NextVector3F(1, 10));
// Create a random position.
Vector3F randomPosition;
randomPosition.X = RandomHelper.Random.NextFloat(-LevelSize / 2, LevelSize / 2);
randomPosition.Y = RandomHelper.Random.NextFloat(0, 2);
randomPosition.Z = RandomHelper.Random.NextFloat(-LevelSize / 2, LevelSize / 2);
// Create a random orientation.
QuaternionF randomOrientation = RandomHelper.Random.NextQuaternionF();
// Create object and add it to collision domain.
var geometricObject = new GeometricObject(randomShape, new Pose(randomPosition, randomOrientation));
var collisionObject = new CollisionObject(geometricObject)
{
CollisionGroup = 0,
};
_domain.CollisionObjects.Add(collisionObject);
}
// Per default, the collision domain computes collision between all objects.
// In this sample we do not need this information and disable it with a collision
// filter.
// In a real application, we would use this collision information for rendering,
// for example, to find out which lights overlap with which meshes, etc.
var filter = new CollisionFilter();
// Disable collision between objects in collision group 0.
filter.Set(0, 0, false);
_domain.CollisionDetection.CollisionFilter = filter;
// Start with the top-down camera.
GraphicsScreen.CameraNode = _topDownCameraNode;
// We will collect a few statistics for debugging.
Profiler.SetFormat("NoCull", 1000, "Time in ms to submit DebugRenderer draw jobs without frustum culling.");
Profiler.SetFormat("WithCull", 1000, "Time in ms to submit DebugRenderer draw jobs with frustum culling.");
}
public EnvironmentLightSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
SampleFramework.IsMouseVisible = false;
_graphicsScreen = new DeferredGraphicsScreen(Services);
_graphicsScreen.DrawReticle = true;
GraphicsService.Screens.Insert(0, _graphicsScreen);
GameObjectService.Objects.Add(new DeferredGraphicsOptionsObject(Services));
Services.Register(typeof(DebugRenderer), null, _graphicsScreen.DebugRenderer);
Services.Register(typeof(IScene), null, _graphicsScreen.Scene);
// Add gravity and damping to the physics Simulation.
Simulation.ForceEffects.Add(new Gravity());
Simulation.ForceEffects.Add(new Damping());
// Add a custom game object which controls the camera.
var cameraGameObject = new CameraObject(Services);
GameObjectService.Objects.Add(cameraGameObject);
_graphicsScreen.ActiveCameraNode = cameraGameObject.CameraNode;
GameObjectService.Objects.Add(new GrabObject(Services));
GameObjectService.Objects.Add(new GroundObject(Services));
GameObjectService.Objects.Add(new DudeObject(Services));
var lavaBallsObject = new LavaBallsObject(Services);
GameObjectService.Objects.Add(lavaBallsObject);
GameObjectService.Objects.Add(new ObjectCreatorObject(Services));
GameObjectService.Objects.Add(new FogObject(Services));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Barrier", 0.9f, new Pose(new Vector3(0, 0, -2))));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Cylinder", 0.9f, new Pose(new Vector3(3, 0, 0), Quaternion.CreateRotationY(MathHelper.ToRadians(-20)))));
GameObjectService.Objects.Add(new StaticSkyObject(Services));
// Add a few palm trees.
Random random = new Random(12345);
for (int i = 0; i < 10; i++)
{
Vector3 position = new Vector3(random.NextFloat(-3, -8), 0, random.NextFloat(0, -5));
Matrix orientation = Matrix.CreateRotationY(random.NextFloat(0, ConstantsF.TwoPi));
float scale = random.NextFloat(0.5f, 1.2f);
GameObjectService.Objects.Add(new StaticObject(Services, "PalmTree/palm_tree", scale, new Pose(position, orientation)));
}
// Add some more dynamic objects.
for (int i = 0; i < 5; i++)
{
lavaBallsObject.Spawn();
GameObjectService.Objects.Add(new ProceduralObject(Services));
GameObjectService.Objects.Add(new DynamicObject(Services, 7));
}
// To show the effect of the EnvironmentLight in isolation, disable all other light sources.
//foreach (var light in _graphicsScreen.Scene.GetDescendants().OfType<LightNode>())
// light.IsEnabled = false;
// Add the environment light.
var environmentLight = new EnvironmentLight
{
Color = new Vector3(0.1f),
DiffuseIntensity = 0,
SpecularIntensity = 1,
EnvironmentMap = ContentManager.Load <TextureCube>("Sky2"),
};
var environmentLightNode = new LightNode(environmentLight)
{
Name = "Environment",
};
_graphicsScreen.Scene.Children.Add(environmentLightNode);
// The EnvironmentLight is a new light type. We have to register a light renderer
// for this light in the LightRenderer of the DeferredGraphicsScreen.
_graphicsScreen.LightBufferRenderer.LightRenderer.Renderers.Add(new EnvironmentLightRenderer(GraphicsService));
// EnvironmentLight.fx uses the specular power of the materials to determine
// which mip map level of the cube is reflected.
// In reality, a high specular power is necessary to reflect the cube map
// with all its detail. To reflect a cube map level with 512 texels size, we
// need a specular power of ~200000.
// To make the reflection effects more obvious, let's change some material properties
// and make the more reflective.
// ProceduralObject:
var proceduralObjects = _graphicsScreen.Scene
.GetDescendants()
.OfType <MeshNode>()
.Where(mn => mn.Mesh.Name == "ProceduralObject")
.Select(mn => mn.Mesh);
foreach (var mesh in proceduralObjects)
{
foreach (var material in mesh.Materials)
{
material["GBuffer"].Set("SpecularPower", 10000f);
material["Material"].Set("DiffuseColor", new Vector3(0.01f));
material["Material"].Set("SpecularColor", new Vector3(1));
}
}
// Frame of GlassBox:
var glassBoxes = _graphicsScreen.Scene
.GetDescendants()
.OfType <ModelNode>()
.Where(mn => mn.Name == "GlassBox")
.Select(mn => ((MeshNode)mn.Children[0]).Mesh);
foreach (var mesh in glassBoxes)
{
foreach (var material in mesh.Materials.Where(m => m.Contains("GBuffer")))
{
material["GBuffer"].Set("SpecularPower", 100000f);
material["Material"].Set("DiffuseColor", new Vector3(0.0f));
material["Material"].Set("SpecularColor", new Vector3(1));
}
}
// LavaBall:
var lavaBalls = _graphicsScreen.Scene
.GetDescendants()
.OfType <ModelNode>()
.Where(mn => mn.Name == "LavaBall")
.Select(mn => ((MeshNode)mn.Children[0]).Mesh);
foreach (var mesh in lavaBalls)
{
foreach (var material in mesh.Materials.Where(m => m.Contains("GBuffer")))
{
material["GBuffer"].Set("SpecularPower", 10000f);
material["Material"].Set("DiffuseColor", new Vector3(0.0f));
material["Material"].Set("SpecularColor", new Vector3(10));
material["Material"].Set("EmissiveColor", new Vector3(0.0f));
}
}
// Ground plane:
var groundPlanes = _graphicsScreen.Scene
.GetDescendants()
.OfType <ModelNode>()
.Where(mn => mn.Name == "Ground")
.Select(mn => ((MeshNode)mn.Children[0]).Mesh);
foreach (var mesh in groundPlanes)
{
foreach (var material in mesh.Materials.Where(m => m.Contains("GBuffer")))
{
material["GBuffer"].Set("SpecularPower", 200000.0f);
material["Material"].Set("DiffuseColor", new Vector3(0.5f));
material["Material"].Set("SpecularColor", new Vector3(0.4f));
}
}
// Please note, XNA does not filter cube maps over cube map borders. Therefore, reflections
// of low resolution mip map levels might show obvious borders between the cube map
// sides. In this case you can change the EnvironmentLight.fx effect to always reflect
// the mip map level 0.
// This is not a problem with MonoGame because DirectX automatically filters cube map borders.
}
private void InitializeSky(ContentManager content)
{
// This scene node is used as the parent of all sky nodes created here.
_skyGroupNode = new SceneNode
{
Name = "ScatteringSkyGroup",
Children = new SceneNodeCollection()
};
// If we render the sky into a cube map, then we do not add the sky nodes to the scene.
if (!_cacheSky)
{
_scene.Children.Add(_skyGroupNode);
}
// Add a skybox with milky way cube map.
_milkyWayNode = new SkyboxNode(content.Load <TextureCube>("Sky/MilkyWay"))
{
Color = new Vector3F(MilkyWayLightScale),
};
_skyGroupNode.Children.Add(_milkyWayNode);
// Add a starfield with all visible stars from a star catalog.
InitializeStarfield();
_skyGroupNode.Children.Add(_starfieldNode);
// Add a node which draws a sun disk.
_sunNode = new SkyObjectNode
{
GlowExponent0 = 4000,
};
_skyGroupNode.Children.Add(_sunNode);
// Add a node which draws a moon texture including moon phase.
_moonNode = new SkyObjectNode
{
Texture = new PackedTexture(content.Load <Texture2D>("Sky/Moon")),
LightWrap = 0.1f,
LightSmoothness = 1,
AngularDiameter = new Vector2F(MathHelper.ToRadians(5)),
// Disable glow.
GlowColor0 = new Vector3F(0),
GlowColor1 = new Vector3F(0),
};
_skyGroupNode.Children.Add(_moonNode);
// Add a ScatteringSky which renders the sky colors using a physically-based model.
_scatteringSkyNode = new ScatteringSkyNode
{
SunIntensity = 1,
// Set a base color to get a dark blue instead of a pitch black night.
BaseHorizonColor = new Vector3F(0.043f, 0.090f, 0.149f) * 0.01f,
BaseZenithColor = new Vector3F(0.024f, 0.051f, 0.102f) * 0.01f,
BaseColorShift = 0.5f
};
_skyGroupNode.Children.Add(_scatteringSkyNode);
if (_enableClouds)
{
InitializeClouds();
}
// The following scene nodes inherit from SkyNode and are rendered by a SkyRenderer
// in the DeferredLightingScreen. We have to set the DrawOrder to render them from
// back to front.
_milkyWayNode.DrawOrder = 0;
_starfieldNode.DrawOrder = 1;
_sunNode.DrawOrder = 2;
_moonNode.DrawOrder = 3;
_scatteringSkyNode.DrawOrder = 4;
if (_enableClouds)
{
_cloudLayerNode1.DrawOrder = 5;
_cloudLayerNode0.DrawOrder = 6;
}
}
public CloudQuadSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
SampleFramework.IsMouseVisible = false;
_graphicsScreen = new DeferredGraphicsScreen(Services);
_graphicsScreen.DrawReticle = true;
GraphicsService.Screens.Insert(0, _graphicsScreen);
GameObjectService.Objects.Add(new DeferredGraphicsOptionsObject(Services));
Services.Register(typeof(DebugRenderer), null, _graphicsScreen.DebugRenderer);
Services.Register(typeof(IScene), null, _graphicsScreen.Scene);
// Add gravity and damping to the physics Simulation.
Simulation.ForceEffects.Add(new Gravity());
Simulation.ForceEffects.Add(new Damping());
// Add a custom game object which controls the camera.
var cameraGameObject = new CameraObject(Services);
GameObjectService.Objects.Add(cameraGameObject);
_graphicsScreen.ActiveCameraNode = cameraGameObject.CameraNode;
GameObjectService.Objects.Add(new GrabObject(Services));
GameObjectService.Objects.Add(new GroundObject(Services));
GameObjectService.Objects.Add(new DudeObject(Services));
GameObjectService.Objects.Add(new ObjectCreatorObject(Services));
GameObjectService.Objects.Add(new LavaBallsObject(Services));
GameObjectService.Objects.Add(new FogObject(Services));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Barrier", 0.9f, new Pose(new Vector3F(0, 0, -2))));
GameObjectService.Objects.Add(new StaticObject(Services, "Barrier/Cylinder", 0.9f, new Pose(new Vector3F(3, 0, 0), QuaternionF.CreateRotationY(MathHelper.ToRadians(-20)))));
// The DynamicSkyObject creates the dynamic sky and lights but no clouds.
var dynamicSkyObject = new DynamicSkyObject(Services, false, false, false);
GameObjectService.Objects.Add(dynamicSkyObject);
// Add a few palm trees.
Random random = new Random(12345);
for (int i = 0; i < 10; i++)
{
Vector3F position = new Vector3F(random.NextFloat(-3, -8), 0, random.NextFloat(0, -5));
Matrix33F orientation = Matrix33F.CreateRotationY(random.NextFloat(0, ConstantsF.TwoPi));
float scale = random.NextFloat(0.5f, 1.2f);
GameObjectService.Objects.Add(new StaticObject(Services, "PalmTree/palm_tree", scale, new Pose(position, orientation)));
}
// The model CloudQuad.fbx consists of a textured quad with a custom effect
// "Cloud.fx". The effect uses several effect parameters. Constant effect
// parameters are set in the Cloud.drmat material file.
// The effect parameters, like "World", "WorldViewProjection", "CameraPosition",
// are automatically updated by the graphics service. But the effect
// contains 3 new effect parameters which must be set at runtime:
// "SunDirection", "SunLight" and "SkyLight".
// Therefore we add a custom effect interpreter and a custom effect binder
// which tell the graphics manager what it should do with these parameters.
// The effect interpreter and binder must be registered before the CloudQuad
// model is loaded!
_skyEffectInterpreter = GraphicsService.EffectInterpreters.OfType <SkyEffectInterpreter>().FirstOrDefault();
if (_skyEffectInterpreter == null)
{
_skyEffectInterpreter = new SkyEffectInterpreter();
GraphicsService.EffectInterpreters.Add(_skyEffectInterpreter);
}
_skyEffectBinder = GraphicsService.EffectBinders.OfType <SkyEffectBinder>().FirstOrDefault();
if (_skyEffectBinder == null)
{
_skyEffectBinder = new SkyEffectBinder();
GraphicsService.EffectBinders.Add(_skyEffectBinder);
}
// The effect binder defines several delegates which update the effect parameters
// using values which are computed by the DynamicSkyObject.
_skyEffectBinder.DynamicSkyObject = dynamicSkyObject;
// Add several CloudQuad models in the sky with random scales and poses.
for (int i = 0; i < 20; i++)
{
var scale = new Vector3F(
RandomHelper.Random.NextFloat(100, 200),
0,
RandomHelper.Random.NextFloat(100, 200));
var position = new Vector3F(
RandomHelper.Random.NextFloat(-500, 500),
RandomHelper.Random.NextFloat(100, 200),
RandomHelper.Random.NextFloat(-500, 500));
var orientation = Matrix33F.CreateRotationY(RandomHelper.Random.NextFloat(0, ConstantsF.TwoPi));
GameObjectService.Objects.Add(new StaticObject(Services, "CloudQuad/CloudQuad", scale, new Pose(position, orientation), false, false));
}
}
public void Draw(UltimaBatcher2D batcher, int x, int y)
{
bool removeEffects = false;
if (Timer < Engine.Ticks)
{
if (CurrentCount == 0)
{
return;
}
removeEffects = true;
}
else if (Type == 0xFF || Type == 0xFE)
{
return;
}
uint passed = Engine.Ticks - LastTick;
if (passed > 7000)
{
LastTick = Engine.Ticks;
passed = 25;
}
bool windChanged = false;
if (WindTimer < Engine.Ticks)
{
if (WindTimer == 0)
{
windChanged = true;
}
WindTimer = Engine.Ticks + (uint)(RandomHelper.GetValue(7, 13) * 1000);
sbyte lastWind = Wind;
Wind = (sbyte)RandomHelper.GetValue(0, 4);
if (RandomHelper.GetValue(0, 2) != 0)
{
Wind *= -1;
}
if (Wind < 0 && lastWind > 0)
{
Wind = 0;
}
else if (Wind > 0 && lastWind < 0)
{
Wind = 0;
}
if (lastWind != Wind)
{
windChanged = true;
}
}
//switch ((WEATHER_TYPE) Type)
//{
// case WEATHER_TYPE.WT_RAIN:
// case WEATHER_TYPE.WT_FIERCE_STORM:
// // TODO: set color
// break;
// case WEATHER_TYPE.WT_SNOW:
// case WEATHER_TYPE.WT_STORM:
// // TODO: set color
// break;
// default:
// break;
//}
Point winpos = Engine.Profile.Current.GameWindowPosition;
Point winsize = Engine.Profile.Current.GameWindowSize;
for (int i = 0; i < Effects.Count; i++)
{
var effect = Effects[i];
if (effect.X < x || effect.X > x + winsize.X ||
effect.Y < y || effect.Y > y + winsize.Y)
{
if (removeEffects)
{
Effects.RemoveAt(i--);
if (CurrentCount > 0)
{
CurrentCount--;
}
else
{
CurrentCount = 0;
}
continue;
}
effect.X = x + RandomHelper.GetValue(0, winsize.X);
effect.Y = y + RandomHelper.GetValue(0, winsize.Y);
}
switch ((WEATHER_TYPE)Type)
{
case WEATHER_TYPE.WT_RAIN:
float scaleRation = effect.ScaleRatio;
effect.SpeedX = -4.5f - scaleRation;
effect.SpeedY = 5.0f + scaleRation;
break;
case WEATHER_TYPE.WT_FIERCE_STORM:
effect.SpeedX = Wind;
effect.SpeedY = 6.0f;
break;
case WEATHER_TYPE.WT_SNOW:
case WEATHER_TYPE.WT_STORM:
if (Type == (byte)WEATHER_TYPE.WT_SNOW)
{
effect.SpeedX = Wind;
effect.SpeedY = 1.0f;
}
else
{
effect.SpeedX = Wind * 1.5f;
effect.SpeedY = 1.5f;
}
if (windChanged)
{
effect.SpeedAngle = MathHelper.ToDegrees((float)Math.Atan2(effect.SpeedX, effect.SpeedY));
effect.SpeedMagnitude =
(float)Math.Sqrt(Math.Pow(effect.SpeedX, 2) + Math.Pow(effect.SpeedY, 2));
}
float speed_angle = effect.SpeedAngle;
float speed_magnitude = effect.SpeedMagnitude;
speed_magnitude += effect.ScaleRatio;
speed_angle += SinOscillate(0.4f, 20, Engine.Ticks + effect.ID);
var rad = MathHelper.ToRadians(speed_angle);
effect.SpeedX = speed_magnitude * (float)Math.Sin(rad);
effect.SpeedY = speed_magnitude * (float)Math.Cos(rad);
break;
default:
break;
}
float speedOffset = passed / SimulationRation;
switch ((WEATHER_TYPE)Type)
{
case WEATHER_TYPE.WT_RAIN:
case WEATHER_TYPE.WT_FIERCE_STORM:
int oldX = (int)effect.X;
int oldY = (int)effect.Y;
float ofsx = effect.SpeedX * speedOffset;
float ofsy = effect.SpeedY * speedOffset;
effect.X += ofsx;
effect.Y += ofsy;
const float MAX_OFFSET_XY = 5.0f;
if (ofsx >= MAX_OFFSET_XY)
{
oldX = (int)(effect.X - MAX_OFFSET_XY);
}
else if (ofsx <= -MAX_OFFSET_XY)
{
oldX = (int)(effect.X + MAX_OFFSET_XY);
}
if (ofsy >= MAX_OFFSET_XY)
{
oldY = (int)(effect.Y - MAX_OFFSET_XY);
}
else if (oldY <= -MAX_OFFSET_XY)
{
oldY = (int)(effect.Y + MAX_OFFSET_XY);
}
batcher.DrawLine(Textures.GetTexture(Color.Gray), x + oldX, y + oldY,
x + (int)effect.X, y + (int)effect.Y, 0, 0);
break;
case WEATHER_TYPE.WT_SNOW:
case WEATHER_TYPE.WT_STORM:
effect.X += effect.SpeedX * speedOffset;
effect.Y += effect.SpeedY * speedOffset;
batcher.Draw2D(Textures.GetTexture(Color.White),
x + (int)effect.X, y + (int)effect.Y, 2, 2, ref _hueVector);
break;
default:
break;
}
}
LastTick = Engine.Ticks;
}
/// <summary>
/// Initializes the physics simulation.
/// </summary>
private void InitializePhysics()
{
// Add a gravity force.
_gravity = new Gravity {
Acceleration = new Vector3F(0, -GravityAcceleration, 0)
};
Simulation.ForceEffects.Add(_gravity);
// Add a damping force.
Simulation.ForceEffects.Add(new Damping());
// Add a few spheres.
Simulation.RigidBodies.Add(new RigidBody(new SphereShape(0.3f))
{
Pose = new Pose(new Vector3F(0, 1, 0)),
});
Simulation.RigidBodies.Add(new RigidBody(new SphereShape(0.2f))
{
Pose = new Pose(new Vector3F(1, 1, 0)),
});
Simulation.RigidBodies.Add(new RigidBody(new SphereShape(0.4f))
{
Pose = new Pose(new Vector3F(0, 1, 2)),
});
// Add ragdoll.
AddRagdoll(1, new Vector3F(0, 2, 0));
// The Simulation performs 2 sub-time-steps per frame because we have set
// the FixedTimeStep of the simulation to 1/60 s and the TargetElapsedTime of the game
// is 1/30 s (30 Hz). In the event SubTimeStepFinished, we call our method
// HandleBreakableJoints() to check the forces in the joints and disable constraints where
// the force is too large.
// Instead, we could also call HandleBreakableJoints() in the Update() method of the game
// but then it is only called with the 30 Hz of the game. It is more accurate to call the
// method at the end of each simulation sub-time-step (60 Hz).
Simulation.SubTimeStepFinished += (s, e) => HandleBreakableJoints();
// Add 6 planes that keep the bodies inside the visible area. The exact positions and angles
// have been determined by experimentation.
var groundPlane = new RigidBody(new PlaneShape(Vector3F.UnitY, 0))
{
Name = "GroundPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(groundPlane);
var nearPlane = new RigidBody(new PlaneShape(-Vector3F.UnitY, -8))
{
Name = "NearPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(nearPlane);
var leftPlane = new RigidBody(new PlaneShape(Matrix33F.CreateRotationZ(MathHelper.ToRadians(-22f)) * Vector3F.UnitX, -4.8f))
{
Name = "LeftPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(leftPlane);
var rightPlane = new RigidBody(new PlaneShape(Matrix33F.CreateRotationZ(MathHelper.ToRadians(22f)) * -Vector3F.UnitX, -4.8f))
{
Name = "RightPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(rightPlane);
var topPlane = new RigidBody(new PlaneShape(Matrix33F.CreateRotationX(MathHelper.ToRadians(14f)) * Vector3F.UnitZ, -3f))
{
Name = "TopPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(topPlane);
var bottomPlane = new RigidBody(new PlaneShape(Matrix33F.CreateRotationX(MathHelper.ToRadians(-14f)) * -Vector3F.UnitZ, -3f))
{
Name = "BottomPlane",
MotionType = MotionType.Static,
};
Simulation.RigidBodies.Add(bottomPlane);
}
public IntersectionSample(Microsoft.Xna.Framework.Game game)
: base(game)
{
SampleFramework.IsMouseVisible = false;
var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
{
RenderCallback = Render,
};
GraphicsService.Screens.Insert(0, delegateGraphicsScreen);
// Add a custom game object which controls the camera.
_cameraObject = new CameraObject(Services, 10);
_cameraObject.ResetPose(new Vector3(0, 0, -4), ConstantsF.Pi, 0);
GameObjectService.Objects.Add(_cameraObject);
// Create a new scene with some lights.
_scene = new Scene();
SceneSample.InitializeDefaultXnaLights(_scene);
_meshRenderer = new MeshRenderer();
_debugRenderer = new DebugRenderer(GraphicsService, null);
_intersectionRenderer = new IntersectionRenderer(GraphicsService, ContentManager)
{
DownsampleFactor = 1,
};
//_submeshA = MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new SphereShape(0.5f).GetMesh(0.001f, 5), MathHelper.ToRadians(70));
//_submeshB = MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70));
var meshNodeA = CreateMeshNode(new[]
{
MeshHelper.CreateTorus(GraphicsService.GraphicsDevice, 1, 0.3f, 30),
MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70)),
},
Color.DarkBlue);
meshNodeA.PoseWorld = new Pose(RandomHelper.Random.NextVector3(-0.5f, 0.5f),
RandomHelper.Random.NextQuaternion());
_scene.Children.Add(meshNodeA);
_debugRenderer.DrawObject(meshNodeA, Color.Green, true, false);
var shape = new TransformedShape(
new GeometricObject(new SphereShape(0.5f), new Pose(new Vector3(1, 0, 0))));
var meshNodeB = CreateMeshNode(new[]
{
MeshHelper.CreateTorus(GraphicsService.GraphicsDevice, 1, 0.3f, 30),
MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, shape.GetMesh(0.001f, 4), MathHelper.ToRadians(90)),
},
Color.Gray);
meshNodeB.PoseWorld = new Pose(RandomHelper.Random.NextVector3(-1f, 1f),
RandomHelper.Random.NextQuaternion());
_scene.Children.Add(meshNodeB);
_debugRenderer.DrawObject(meshNodeB, Color.Green, true, false);
var meshNodeC = CreateMeshNode(new[]
{
MeshHelper.CreateBox(GraphicsService.GraphicsDevice),
MeshHelper.CreateSubmesh(GraphicsService.GraphicsDevice, new BoxShape(1, 1, 2).GetMesh(0.001f, 5), MathHelper.ToRadians(70))
},
Color.DarkGreen);
meshNodeC.PoseWorld = new Pose(RandomHelper.Random.NextVector3(-1f, 1f),
RandomHelper.Random.NextQuaternion());
meshNodeC.ScaleLocal = new Vector3(0.1f, 1f, 0.5f);
_scene.Children.Add(meshNodeC);
_debugRenderer.DrawObject(meshNodeC, Color.Green, true, false);
_meshNodePairs.Add(new Pair <MeshNode>(meshNodeA, meshNodeB));
_meshNodePairs.Add(new Pair <MeshNode>(meshNodeA, meshNodeC));
_meshNodePairs.Add(new Pair <MeshNode>(meshNodeB, meshNodeC));
CreateGuiControls();
}
