private void LoadGame()
{
var viweportSize = new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height);
var scaleviweport = (viweportSize / _aspect);
var grid = new Grid(_spriteBatch, new Size(8, 8));
grid.Position = scaleviweport * 0.5f;
grid.EventFinished += OnGameFinished; //Event to gameover
_root.AddChild(grid);
}
private RootNode TestCase(AIMember aiMember)
{
RootNode root = new RootNode();
root
.AddChild(new Selector()
.AddChild(new Condition(() => _timer > 3 && aiMember.Index < 1)
.AddChild(new Sequeter()
.AddChild(new PrintAction("[1]State In"))
.AddChild(new SetValAction(() => aiMember.Index = 1))
.AddChild(new DelayAction(5f))
.AddChild(new PrintAction("[1]State Out"))))
.AddChild(new Condition(() => _timer > 10 && aiMember.Index < 2)
.AddChild(new Sequeter()
.AddChild(new PrintAction("[2]State In"))
.AddChild(new SetValAction(() => aiMember.Index = 2))
.AddChild(new DelayAction(5f))
.AddChild(new PrintAction("[2]State Out"))))
.AddChild(new Condition(() => _timer > 20f)
.AddChild(new Sequeter()
.AddChild(new SetValAction(() => _timer = 0))
.AddChild(new SetValAction(() => aiMember.Index = 0))))
.AddChild(new PrintAction("[3] Default Case")));
return(root);
}
public void Node_ShouldAddChildren()
{
// Arrange
Node root = new RootNode();
Node child1 = Argument("foo", new IntegerArgument(), true, null);
Node child2 = Argument("bar", new IntegerArgument(), true, null);
Node child3 = Argument("baz", new IntegerArgument(), true, null);
// Act
root.AddChild(child1);
root.AddChild(child2);
root.AddChild(child3);
// Assert
Assert.AreEqual(root.Children.Count, 3);
}
/// <summary>
/// Handles changes to the references items in the project and updates the project tree.
/// </summary>
/// <param name="e">A description of the changes made to the project.</param>
private void ProjectSubscriptionService_Changed(IProjectVersionedValue <
Tuple <IProjectSubscriptionUpdate,
IProjectCatalogSnapshot,
IProjectSharedFoldersSnapshot> > e)
{
DependenciesChange dependenciesChange;
lock (_rootNodeSync)
{
dependenciesChange = ProcessDependenciesChanges(e.Value.Item1, e.Value.Item2);
// process separatelly shared projects changes
ProcessSharedProjectImportNodes(e.Value.Item3, dependenciesChange);
// Apply dependencies changes to actual RootNode children collection
// remove first nodes from actual RootNode
dependenciesChange.RemovedNodes.ForEach(RootNode.RemoveChild);
ProcessDuplicatedNodes(dependenciesChange);
dependenciesChange.UpdatedNodes.ForEach((topLevelNode) =>
{
var oldNode = RootNode.Children.FirstOrDefault(x => x.Id.Equals(topLevelNode.Id));
if (oldNode != null)
{
RootNode.RemoveChild(oldNode);
RootNode.AddChild(topLevelNode);
}
});
dependenciesChange.AddedNodes.ForEach(RootNode.AddChild);
}
OnDependenciesChanged(dependenciesChange.GetDiff(), e);
}
protected override void LoadContent()
{
Window.Title = "Thick Wireframes";
Mesh teapot = new Teapot("Utah Teapot");
teapot.SetScale(30f);
teapot.Translation = new Vector3(0, -50, 0);
teapot.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
teapot.Material.SetRenderState(RasterizerState.CullNone);
Mesh wireframe = CreateWireframeData("Utah Wireframe", teapot.MeshData);
wireframe.RenderBucketType = RenderBucketType.PostBucket;
wireframe.Transform.Set(teapot.Transform);
Material wireMat = new Material("WireMaterial");
wireMat.LoadEffect(ContentManager.Load <Effect>("Shaders//WireframeEffect.fx").Clone());
wireMat.SetEngineParameter("WVP", EngineValue.WorldViewProjection);
wireMat.SetParameter("WinScale", new Vector2(Renderer.CurrentCamera.Viewport.Width / 2, Renderer.CurrentCamera.Viewport.Height / 2));
wireMat.SetParameter("WireColor", new Vector3(.8f, .1f, .1f));
wireMat.SetParameter("FillColor", new Vector4(.7f, .8f, .9f, .5f));
wireMat.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
wireMat.SetRenderState(RasterizerState.CullNone);
wireframe.SetMaterial(wireMat);
RootNode.AddChild(teapot);
RootNode.AddChild(wireframe);
RootNode.AddController(new RotateController(Vector3.Up, 25));
}
protected override void LoadContent()
{
Window.Title = "Render Target Sample";
//Create the box we'll render off screen
_offscreenCube = new Box("Offscreen box", 10, 10, 10);
_offscreenCube.Material = ContentManager.Load <Material>("LitBasicTexture.tem");
_offscreenCube.Material.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//rock_diff.dds"));
_offscreenCube.AddController(new RotateController(Vector3.Normalize(Vector3.Add(Vector3.Up, Vector3.Right)), 45.0f));
PointLight pl = new PointLight();
pl.Diffuse = Color.CornflowerBlue;
pl.Position = new Vector3(0, 25, 25);
pl.Ambient = Color.LightBlue;
_offscreenCube.AddLight(pl);
_offscreenCube.SceneHints.LightCombineHint = LightCombineHint.Local;
_offscreenCube.RenderBucketType = RenderBucketType.Skip;
//Create a render target that also has a depth stencil.
_renderTarget = new RenderTarget2D(512, 512, true, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
//Camera we'll use for the off screen rendering
_targetCamera = new Camera(new Viewport(0, 0, 512, 512));
_targetCamera.Position = new Vector3(0, 0, 50);
_targetCamera.SetProjection(45.0f, 0.1f, 5000.0f);
_targetCamera.Update();
//Create a box that we'll attach to the scene graph and render as normal.
_box = new Box("OnScreen box", 50, 50, 50);
_box.Material = ContentManager.Load <Material>("BasicTexture.tem");
//Since render target is a texture, we can set it to the material's effect.
_box.Material.SetParameter("DiffuseMap", _renderTarget);
RootNode.AddChild(_box);
}
public void TestNodeParent()
{
var root = new RootNode("Root");
var trunk = new TrunkNode("Trunk");
root.AddChild(trunk);
Assert.AreEqual(root, trunk.GetParent());
}
public void Node_ShouldGetArgumentChildren_AsRelevantNodes()
{
// Arrange
RootNode root = new RootNode();
Node child1 = Literal("foo", true, null);
Node child2 = Literal("bar", true, null);
Node child3 = Argument("baz", new IntegerArgument(), true, null);
Node child4 = Argument("qux", new BooleanArgument(), true, null);
root.AddChild(child1);
root.AddChild(child2);
root.AddChild(child3);
root.AddChild(child4);
IStringReader reader = new StringReader("123");
// Act
List <Node> relevantNodes = new List <Node>(root.GetRelevantNodes(reader));
// Assert
Assert.AreEqual(relevantNodes.Count, 2);
}
protected override void Context()
{
_repository1 = A.Fake <DataRepository>();
_repository2 = A.Fake <DataRepository>();
var rootNode = new RootNode(new RootNodeType("ObservedDataFolder", ApplicationIcons.ObservedDataFolder, ClassificationType.ObservedData));
var classificationNode = new ClassificationNode(new Classification());
classificationNode.AddChild(new ObservedDataNode(new ClassifiableObservedData {
Subject = _repository1
}));
rootNode.AddChild(classificationNode);
rootNode.AddChild(new ObservedDataNode(new ClassifiableObservedData {
Subject = _repository2
}));
_data = new DragDropInfo(
new List <ITreeNode>
{
rootNode
});
base.Context();
}
protected override void LoadContent()
{
Window.Title = "Spatial Controller Sample";
//Create a box with a simple color material
Box box = new Box("MyBox", 20, 20, 20);
box.Material = ContentManager.Load <Material>("LitBasicColor.tem");
box.Material.SetParameter("MatDiffuse", Color.Crimson.ToVector3());
//Set the custom controller to the box, this will get updated everytime the scene graph is updated.
box.AddController(new RotateScaleController(.5f, new Vector2(.2f, 3), 45, Vector3.Up));
RootNode.AddChild(box);
}
protected override void LoadContent()
{
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.SwapWindingOrder = true;
mlp.NormalGeneration = NormalGeneration.Face;
mlp.PreferLitMaterials = true;
mlp.GenerateTangentBasis = false;
ship = ContentManager.Load <Spatial>("Models\\station.dxs", mlp);
ship.AddController(new Tesla.Scene.Extension.RotateController(new Vector3(0, 1, 0), 5));
ship.SetRenderState(SamplerState.AnisotropicWrap);
engineMat = ContentManager.Load <Material>("BasicTexture.tem");
Material mat = new Material();
mat.LoadEffect(ContentManager.Load <Effect>("Shaders//TextureGlowEffect.fx"));
mat.SetActiveTechnique("TextureGlow");
mat.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//station_diff.dds"));
mat.SetParameter("EmissiveMap", ContentManager.Load <Texture2D>("Textures//station_glow.dds"));
mat.SetParameter("MatEmissive", new Vector3(.5f, .5f, .5f));
mat.SetEngineParameter("WVP", Tesla.Core.EngineValue.WorldViewProjection);
mat.SetEngineParameter("World", Tesla.Core.EngineValue.WorldMatrix);
mat.SetEngineParameter("WorldIT", Tesla.Core.EngineValue.WorldInverseTranspose);
mat.SetEngineParameter("EyePos", Tesla.Core.EngineValue.CameraPosition);
ship.SetMaterial(mat);
engineMat.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//station_glow.dds"));
width = Renderer.CurrentCamera.Viewport.Width;
height = Renderer.CurrentCamera.Viewport.Height;
bool test = Renderer.Adapter.QueryRenderTargetFormat(SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 4);
sceneRT = new RenderTarget2D(width, height, false, Window.SwapChain.PresentationParameters.BackBufferFormat, Window.SwapChain.PresentationParameters.DepthStencilFormat, Window.SwapChain.PresentationParameters.MultiSampleCount, RenderTargetUsage.DiscardContents);
rt1 = new RenderTarget2D(width, height, true, sceneRT.Format, DepthFormat.None);
rt2 = new RenderTarget2D(width, height, true, sceneRT.Format, DepthFormat.None);
rt3 = new RenderTarget2D(width, height, true, sceneRT.Format, DepthFormat.None);
blurEffect = ContentManager.Load <Effect>("Shaders//GaussianBlur.fx");
batch = new SpriteBatch();
RootNode.AddChild(ship);
sky = new Box("Space", Vector3.Zero, 100, 100, 100);
sky.SceneHints.RenderBucketType = RenderBucketType.Skip;
sky.Material = ContentManager.Load <Material>("Materials//SpaceSkybox.tem");
RootNode.SetModelBound(new Tesla.Bounding.BoundingBox());
}
private void CreatePicks(PickQuery query)
{
if (query.Count == 0)
{
return;
}
query.Sort();
//Lazily create the mesh that holds the pick visuals, for this example we're only doing the closest picked
//triangle
if (picks == null)
{
picks = new Mesh("Picks");
picks.Material = ContentManager.Load <Material>("Materials//BasicColor.tem").Clone();
picks.Material.SetParameter("DiffuseColor", Color.Yellow);
picks.SetRenderState(RasterizerState.CullNoneWireframe);
picks.SetRenderState(DepthStencilState.None);
picks.MeshData.Positions = new DataBuffer <Vector3>(3);
picks.MeshData.UseIndexedPrimitives = false;
picks.MeshData.Reconstruct();
picks.SceneHints.RenderBucketType = RenderBucketType.PostBucket;
picks.SceneHints.PickingHint = PickingHint.None;
RootNode.AddChild(picks);
pickRay = new Line("PickRay");
pickRay.Material = ContentManager.Load <Material>("Materials//BasicVertColor.tem").Clone();
RootNode.AddChild(pickRay);
}
DataBuffer <Vector3> db = picks.MeshData.Positions;
db.Position = 0;
PickResult results = query.ClosestPick.Value;
Ray ray = results.SourceRay;
//Get the closest primitive intersection record, and the closest intersection triangle (a ray may pass through many
//triangles, we want the one closest to the ray's origin). These should exist, if we have results.
IntersectionRecord record = results.PrimitiveIntersectionRecord.Value.ClosestIntersection.Value;
Triangle tri = record.Triangle.Value;
db.Set(tri.PointA);
db.Set(tri.PointB);
db.Set(tri.PointC);
//Set the pick ray so we can see it on the screen
pickRay.SetLine(ray.Origin, ray.Origin + ray.Direction * (record.Distance + 100), Color.Orange, Color.Orange);
//Update the pick result with the triangle data
picks.MeshData.UpdateVertexData <Vector3>(VertexSemantic.Position, db);
}
void RecieveCode(IAsyncResult rs)
{
HttpListenerContext ls = listener.EndGetContext(rs);
HttpListenerRequest request = ls.Request;
string cloudname = request.QueryString.Get("cloudname");
string id = request.QueryString.Get("id");
string path = request.QueryString.Get("path");
string email = request.QueryString.Get("email");
string range = request.Headers.Get("Range");
CloudType type = CloudType.Folder;
Stream stream;
long start_range = -1;
long end_range = -1;
IItemNode filenode = null;
if (range != null)
{
string[] range_arr = range.Split('-');
long.TryParse(range_arr[0], out start_range);
long.TryParse(range_arr[1], out end_range);
}
if (cloudname != null && id != null && Enum.TryParse <CloudType>(cloudname, out type) && type != CloudType.LocalDisk && type != CloudType.Folder)
{
if (email == null)
{
email = AppSetting.settings.GetDefaultCloud(type);
}
RootNode rootnode = AppSetting.settings.GetCloudRootNode(email, type);
filenode = new ItemNode(new NodeInfo()
{
ID = id
});
rootnode.AddChild(filenode);
}
else if (path != null && File.Exists(path))
{
type = CloudType.LocalDisk;
filenode = ItemNode.GetNodeFromDiskPath(path);
}
else//return 404 not found
{
}
stream = AppSetting.ManageCloud.GetFileStream(filenode, start_range, end_range, false);//mega need cal chunk and size file
HttpListenerResponse response = ls.Response;
}
protected override void LoadContent()
{
Window.Title = "Ray Picking Sample";
//Load a model that we'll use to pick
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.SwapWindingOrder = true;
mlp.NormalGeneration = NormalGeneration.Crease;
mlp.PreferLitMaterials = true;
Spatial jeep = ContentManager.Load <Spatial>("Models//Jeep.dxs", mlp);
//jeep.Translation = new Vector3(0, -50, 0);
jeep.Rotation = Quaternion.FromAngleAxis(MathHelper.ToRadians(140), Vector3.UnitY);
jeep.SetModelBound(new BoundingBox());
RootNode.AddChild(jeep);
//Adjust the default camera a tad
Renderer.CurrentCamera.Position = new Vector3(0, 100, 100);
Renderer.CurrentCamera.LookAt(jeep.Translation, Vector3.Up);
Renderer.CurrentCamera.Update();
//Set the mouse visible so we can see the cursor
Window.IsMouseVisible = true;
//Create our query
query = new PickQuery();
//We want to enable primitive picking to get triangle accurate results, when we do the intersection tests,
//the utility will first do a board bounding volume test, and if that succeeds then a finer primitive test.
query.EnablePrimitivePicking = true;
//Setup out input - whenever we left click, we'll cast a ray into the scene
InputLayer.RegisterTrigger(new InputTrigger(new InputCondition(delegate(GameTime time) {
MouseState ms = Mouse.GetMouseState();
if (ms.LeftButton == ButtonState.Pressed)
{
return(true);
}
return(false);
}), new InputAction(delegate(GameTime time) {
MouseState ms = Mouse.GetMouseState();
query.Clear();
//The camera class has easy-built in functionality to quickly create a pick ray where the origin
//of the ray is on the near-plane of the view frustum
PickingUtil.FindPick(RootNode, Renderer.CurrentCamera.CreatePickRay(ms.Position), query);
CreatePicks(query);
})));
}
public virtual void StopAt(long ticks, string segmentName, bool assertStarted = true, bool stopChildren = false)
{
var normalized_name = ProfilingNode.NormalizeNodeName(segmentName);
if (stopChildren)
{
var topmost = VisibleCallstack.First((n) => n.SegmentName == normalized_name);
if (topmost != null)
{
var children = VisibleCallstack.TakeWhile((n) => n.SegmentName != normalized_name).ToArray();
children.Select((n) => { StopAt(ticks, n.SegmentName, true, false); return(n); });
StopAt(ticks, segmentName, assertStarted, false);
}
else if (assertStarted)
{
throw new InvalidOperationException(string.Format("The given profiling segment {0} is not running anywhere in the callstack; it cannot be stopped.", normalized_name));
}
}
else
{
if (callstack.Peek().SegmentName == normalized_name)
{
var n = callstack.Pop();
n.StopAt(ticks);
if (n.Drop)
{
return;
}
if (callstack.Count > 0)
{
callstack.Peek().AddChild(n);
}
else if (RootNode.SegmentName == n.SegmentName && !RootNode.HasChildren)
{
RootNode = n; //Replace the root node on the very first call, *if* the segment name matches.
}
else
{
RootNode.AddChild(n);
}
}
else if (assertStarted)
{
throw new InvalidOperationException(string.Format("The given profiling segment {0} is not running at the top of the callstack; it cannot be stopped.", normalized_name));
}
}
}
protected override void LoadContent()
{
ClearColor = Color.Black;
MemoryStream ms = new MemoryStream();
BinaryExporter exporter = new BinaryExporter();
BinaryLoader loader = new BinaryLoader();
Window.Title = "Normal Mapping Sample";
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.SwapWindingOrder = true;
mlp.PreferLitMaterials = false;
mlp.GenerateTangentBasis = true;
mlp.NormalGeneration = NormalGeneration.Crease;
Spatial model = ContentManager.Load <Spatial>("Models//starship.dxs", mlp);
model.SetScale(.15f);
//model.Material = ContentManager.Load<Material>("NormalMap.tem");
// model.Material.SetParameter("DiffuseMap", ContentManager.Load<Texture2D>("Textures//rock_diff.dds"));
// model.Material.SetParameter("NormalMap", ContentManager.Load<Texture2D>("Textures//rock_norm.dds"));
// model.Material.SetParameter("MatSpecular", Color.Gray.ToVector3());
// model.AddController(new RotateController(new Vector3(.5f, .5f, 0), 25f));
//model.ComputeTangentBasis();
// RootNode.AddChild(model);
RootNode.SetModelBound(new Tesla.Bounding.BoundingBox());
model = ContentManager.Load <Spatial>("Models//statue.tebo");
Material mat = ContentManager.Load <Material>("NormalMap.tem").Clone();
mat.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//statue_diff.dds"));
mat.SetParameter("NormalMap", ContentManager.Load <Texture2D>("Textures//statue_norm.dds"));
mat.SetParameter("MatSpecular", new Vector3(.3f, .3f, .3f));
model.SetMaterial(mat);
model.Rotation = Quaternion.FromAngleAxis(MathHelper.ToRadians(-90), Vector3.Up);
model.SetModelBound(new Tesla.Bounding.BoundingBox());
RootNode.AddChild(model);
/*
* model = ContentManager.Load<Spatial>("Models//statue.dxs", mlp);
* model.Rotation = Quaternion.FromAngleAxis(MathHelper.ToRadians(-90), Vector3.Up);
* FileStream fs = File.OpenWrite("C:\\Users\\Nicholas Woodfield\\Desktop\\D3D10\\statue2.tebo");
* exporter.Save(model, fs);
* fs.Close();*/
}
protected override void LoadContent()
{
Window.Title = "DXS Model Loading Sample";
Renderer.CurrentCamera.Position = new Vector3(-70, 90, 120);
Renderer.CurrentCamera.LookAt(new Vector3(0, 0, 0), Vector3.Up);
Renderer.CurrentCamera.Update();
//When calling ContentManager.Load<T>(), an optional loader parameter can be passed that tells the content importer
//how to process the content. Model loaders take ModelLoaderParameters and image loaders take ImageLoaderParameters. They
//can be re-used.
//
//In this case, we have to tell the model loader that we want to swap the winding order of polygons so we do not get
//incorrect rendering. Other options include the angle at which to rotate the model about the XYZ axes, how normals should
//be generated (if any), if a tangent basis should be generated, where to find textures, or overload material creation by
//supplying a material to load and use as a template.
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.SwapWindingOrder = true;
mlp.PreferLitMaterials = false;
//In BasicApp, we registered a DXSModelLoader to the content manager, if we didn't this will throw
//an exception that we do not have a means to handle the requested content. Loaders are designated by
//both the runtime type and the content file extension.
//
//Notice with loading this model, we use Spatial rather than Mesh, because a model may be in fact a
//scene graph with multiple parts. We can either have a Node or Mesh returned. In this case,
//we should have a mesh returned since the model is a single mesh in the file. If the model
//used two different materials, it would have to be split up into two different meshes
//and then attached to a Node that would be returned, for example.
Spatial model = ContentManager.Load <Spatial>("Models//station.dxs", mlp);
model.AddController(new RotateController(Vector3.Up, 5));
model.SetModelBound(new BoundingBox());
RootNode.AddChild(model);
Box sky = new Box("Space", Vector3.Zero, 100, 100, 100);
sky.SceneHints.RenderBucketType = RenderBucketType.PreBucket;
sky.Material = ContentManager.Load <Material>("Materials//SpaceSkybox.tem");
RootNode.AddChild(sky);
}
protected virtual void ProcessDuplicatedNodes(DependenciesChange dependenciesChange)
{
// Now add new nodes and dedupe any nodes that might have same caption.
// For dedupping we apply aliases to all nodes with similar Caption. Alias
// is a "Caption (ItemSpec)" and is unique. We try to find existing node with
// with the same caption, if found we apply alias to both nodes. If not found
// we also check if there are nodes with alias already applied earlier and having
// same caption. If yes, we just need to apply alias to our current node only.
foreach (var nodeToAdd in dependenciesChange.AddedNodes)
{
var rootNodeChildren = RootNode.Children;
var shouldApplyAlias = false;
var matchingChild = rootNodeChildren.FirstOrDefault(
x => x.Caption.Equals(nodeToAdd.Caption, StringComparison.OrdinalIgnoreCase));
if (matchingChild == null)
{
shouldApplyAlias = rootNodeChildren.Any(
x => x.Caption.Equals(
string.Format(CultureInfo.CurrentCulture, "{0} ({1})", nodeToAdd.Caption, x.Id.ItemSpec),
StringComparison.OrdinalIgnoreCase));
}
else
{
shouldApplyAlias = true;
}
if (shouldApplyAlias)
{
if (matchingChild != null)
{
matchingChild.SetProperties(caption: matchingChild.Alias);
dependenciesChange.UpdatedNodes.Add(matchingChild);
}
nodeToAdd.SetProperties(caption: nodeToAdd.Alias);
}
RootNode.AddChild(nodeToAdd);
}
}
protected override void LoadContent()
{
Window.Title = "Many Lights Sample";
ClearColor = Color.Black;
Node lightNode = new Node("LightNode");
lightNode.SceneHints.LightCombineHint = LightCombineHint.Off;
for (int i = 0; i < 30; i++)
{
CreateRandomLight(i, lightNode);
}
RootNode.AddChild(lightNode);
for (int i = 0; i < 60; i++)
{
CreateRandomSphere(i, RootNode);
}
RootNode.SetModelBound(new BoundingBox());
}
protected override void LoadContent()
{
Window.Title = "Planet Sample";
Renderer.CurrentCamera.Position = new Vector3(0, 0, 750);
Sphere planet = new Sphere("Earth", 100, 100, 200);
planet.Material = ContentManager.Load <Material>("Materials//PlanetMaterial.tem");
planet.Material.AddLogic(new PlanetLogic());
planet.Rotation = Quaternion.FromAngleAxis(MathHelper.ToRadians(-90.0f), Vector3.UnitX);
planet.SceneHints.RenderBucketType = RenderBucketType.Transparent;
planet.ComputeTangentBasis();
planet.SetModelBound(new BoundingSphere());
material = planet.Material;
Node orbit = new Node("Orbit");
orbit.AddChild(planet);
orbit.AddController(new RotateController(Vector3.UnitY, .75f));
RootNode.AddChild(orbit);
orbit.Rotation = Quaternion.FromAngleAxis(MathHelper.DegreesToRadians * 45, Vector3.UnitY);
DirectionalLight dl = new DirectionalLight();
dl.Direction = new Vector3(-.755f, -.755f, -.755f);
planet.AddLight(dl);
//TODO: The planet only renders properly if it's centered at the origin
//orbit.Translation = new Vector3(0, -500, 0);
Box sky = new Box("Space", Vector3.Zero, 100, 100, 100);
sky.SceneHints.RenderBucketType = RenderBucketType.PreBucket;
sky.Material = ContentManager.Load <Material>("Materials//SpaceSkybox.tem");
RootNode.AddChild(sky);
}
protected override void LoadContent()
{
Window.Title = "Different Lights Sample";
Type sp = typeof(Spatial);
Type me = typeof(Mesh);
bool ishash = sp.GetHashCode() == sp.GetHashCode();
bool ishash2 = sp.GetHashCode() == me.GetHashCode();
bool iseq = sp.Equals(sp);
pl = new PointLight();
pl.Specular = Color.DarkGray; //Cut down on the specular so we don't get blinded
sl = new SpotLight();
//Spot light angles - inner angle is where the light is most intense. The intensity smoothly
//fades from this angle to the outer angle, so we don't have an abrupt cutoff. Essentially spot lights
//are similar to point lights, except for this restricting cone.
sl.OuterAngle = 45;
sl.InnerAngle = 20;
sl.Direction = new Vector3(-.577f, -.577f, -.577f);
//Simple directional light - simulates a light source infinitely away like the Sun.
dl = new DirectionalLight();
dl.Direction = new Vector3(-.577f, -.577f, -.577f);
activeLight = pl;
//Create an inverted cube
Box b = new Box("InsideOut", Vector3.Zero, 100, 100, 100, true);
b.Material = ContentManager.Load <Material>("LitBasicColor.tem");
b.RenderBucketType = RenderBucketType.Skip;
//These are object material properties (built-in shaders also include Emissive, shininess factor, and an alpha factor)
b.Material.SetParameter("MatDiffuse", Color.Crimson.ToVector3());
b.Material.SetParameter("MatAmbient", new Color(.4f, .2f, .2f).ToVector3());
b.Material.SetParameter("MatSpecular", new Color(.3f, .3f, .3f).ToVector3());
b.SetModelBound(new BoundingBox());
RootNode.AddChild(b);
RootNode.RemoveAllLights();
RootNode.AddLight(activeLight);
text = "Active Light: Point";
//Input response to set the active light
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.D1, false), new InputAction(
delegate(GameTime time) {
activeLight = pl;
RootNode.RemoveAllLights();
RootNode.AddLight(activeLight);
text = "Active Light: Point";
}
)));
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.D2, false), new InputAction(
delegate(GameTime time) {
activeLight = sl;
RootNode.RemoveAllLights();
RootNode.AddLight(activeLight);
text = "Active Light: Spot";
}
)));
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.D3, false), new InputAction(
delegate(GameTime time) {
activeLight = dl;
RootNode.RemoveAllLights();
RootNode.AddLight(activeLight);
text = "Active Light: Directional";
}
)));
//Set up some text rendering
batch = new SpriteBatch();
font = ContentManager.Load <SpriteFont>("Fonts//comicsans.fnt");
}
protected override void LoadContent()
{
Window.Title = "Render Queue Sample";
toggleRenderQueue = false;
toggleTwoPass = false;
transpNode = new Node("TransparentNode");
transpNode.SceneHints.TransparencyType = TransparencyType.OneSided;
RootNode.AddChild(transpNode);
orthos = new Node("OrthoNode");
orthoCam = new Camera(new Viewport());
orthoCam.SetFrame(new Vector3(-.5f, -.5f, 0), Matrix.Identity);
quad1 = new Quad("Quad1", 100, 70);
quad1.Material = ContentManager.Load <Material>("BasicColor.tem").Clone();
quad1.Material.SetParameter("DiffuseColor", Color.Blue);
quad1.Translation = new Vector3(Window.ClientBounds.Width / 2, Window.ClientBounds.Height / 2, 0);
quad1.RenderBucketType = RenderBucketType.Skip;
quad1.SceneHints.CullHint = CullHint.Never;
quad1.OrthoOrder = 5;
quad1.SetRenderState(DepthStencilState.None);
quad1.SetRenderState(RasterizerState.CullNone);
orthos.AddChild(quad1);
quad2 = new Quad("Quad2", 50, 70);
quad2.Material = ContentManager.Load <Material>("BasicColor.tem").Clone();
quad2.Material.SetParameter("DiffuseColor", Color.Red);
quad2.Translation = new Vector3(Window.ClientBounds.Width / 2 + 50, Window.ClientBounds.Height / 2 + 50, 0);
quad2.RenderBucketType = RenderBucketType.Skip;
quad2.SceneHints.CullHint = CullHint.Never;
quad2.OrthoOrder = 1; //Setting the ortho order less than quad1 means this will be drawn first when in the ortho render bucket
quad2.SetRenderState(DepthStencilState.None);
quad2.SetRenderState(RasterizerState.CullNone);
orthos.AddChild(quad2);
transparentTorus = new Torus("TransparentSphere", 30, 30, 8, 16);
transparentTorus.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
transparentTorus.Material.SetParameter("MatDiffuse", Color.Green.ToVector3());
transparentTorus.Material.SetParameter("Alpha", .75f);
transparentTorus.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
transparentTorus.RenderBucketType = RenderBucketType.Skip;
transparentTorus.Translation = new Vector3(30, 10, 80);
transpNode.AddChild(transparentTorus);
transparentBox = new Box("TransparentBox", 10, 10, 10);
transparentBox.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
transparentBox.Material.SetParameter("MatDiffuse", Color.DarkRed.ToVector3());
transparentBox.Material.SetParameter("Alpha", .5f);
transparentBox.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
transparentBox.RenderBucketType = RenderBucketType.Skip;
transparentBox.Translation = new Vector3(0, 10, 50);
transpNode.AddChild(transparentBox);
transparentTeapot = new Teapot("TransparentTeapot");
transparentTeapot.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
transparentTeapot.Material.SetParameter("MatDiffuse", Color.LightGreen.ToVector3());
transparentTeapot.Material.SetParameter("Alpha", .35f);
transparentTeapot.SetRenderState(BlendState.AlphaBlendNonPremultiplied);
transparentTeapot.RenderBucketType = RenderBucketType.Skip;
transparentTeapot.Translation = new Vector3(-10, 40, 40);
transparentTeapot.SetScale(7.0f);
transpNode.AddChild(transparentTeapot);
opaqueBox1 = new Box("OpaqueBox", 10, 10, 10);
opaqueBox1.Material = ContentManager.Load <Material>("LitBasicTexture.tem").Clone();
opaqueBox1.Material.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//bricks_diff.dds"));
opaqueBox1.RenderBucketType = RenderBucketType.Skip;
opaqueBox1.Translation = new Vector3(0, -10, -20);
RootNode.AddChild(opaqueBox1);
opaqueBox2 = new Box("OpaqueBox", 10, 10, 10);
opaqueBox2.Material = ContentManager.Load <Material>("LitBasicTexture.tem").Clone();
opaqueBox2.Material.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//bricks_diff.dds"));
opaqueBox2.RenderBucketType = RenderBucketType.Skip;
opaqueBox2.Translation = new Vector3(0, 20, -20);
RootNode.AddChild(opaqueBox2);
opaqueBox3 = new Box("OpaqueBox", 10, 10, 10);
opaqueBox3.Material = ContentManager.Load <Material>("LitBasicTexture.tem").Clone();
opaqueBox3.Material.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//bricks_diff.dds"));
opaqueBox3.RenderBucketType = RenderBucketType.Skip;
opaqueBox3.Translation = new Vector3(0, 50, -20);
RootNode.AddChild(opaqueBox3);
RootNode.SetModelBound(new BoundingBox());
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.R, false), new InputAction(
delegate(GameTime time) {
toggleRenderQueue = !toggleRenderQueue;
Toggle(toggleRenderQueue, toggleTwoPass);
}
)));
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.T, false), new InputAction(
delegate(GameTime time) {
toggleTwoPass = !toggleTwoPass;
Toggle(toggleRenderQueue, toggleTwoPass);
}
)));
//Set up some text rendering
batch = new SpriteBatch();
font = ContentManager.Load <SpriteFont>("Fonts//comicsans.fnt");
}
public void Register(LiteralNode contents)
{
Root.AddChild(contents);
}
protected override void LoadContent()
{
Window.Title = "Instancing Sample";
ClearColor = Color.Black;
//Let's create a mesh that will serve as our data. We're technically not using the scene graph here, this is just a convience.
//Maybe at some point the engine's scene graph will have a mesh structure that supports instancing, for now we have to do it ourselves.
mesh = new Box("Box", 2, 2, 5);
mesh.SetRandomColors();
//We use the default lights from the root node, so all our instances will be lit.
mesh.Lights.Set(RootNode.Lights);
mesh.UpdateWorldLights(false);
//Create a target object that all our instances will "look at"
sphere = new Sphere("Sphere", 30, 30, 10);
sphere.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
sphere.Material.SetParameter("MatDiffuse", Color.Yellow.ToVector3());
RootNode.AddChild(sphere);
// The mesh will have a vertex buffer that goes something like so:
//
//Position0 - Vector3
//Normal0 - Vector3
//Color0 - Color
//TexCoord0 - Vector2
//
// Meanwhile, our second vertex buffer that contains the world transforms will look like this, since we're passing a 4x4 matrix:
//
//TexCoord0 - Vector4
//TexCoord1 - Vector4
//TexCoord2 - Vector4
//TexCoord3 - Vector4
//
// When we set these two buffers at the same time (first to slot 0, second to slot 1), the engine automatically
//merges the declarations and resolves conflicts such as duplicate semantic indices - in the order the
//vertex buffers are set to the device, so in this example the semantic indices of the second buffer are all incremented
//by one.
VertexDeclaration decl = new VertexDeclaration(new VertexElement[] {
new VertexElement(VertexSemantic.TextureCoordinate, 0, VertexFormat.Vector4, 0),
new VertexElement(VertexSemantic.TextureCoordinate, 1, VertexFormat.Vector4, 16),
new VertexElement(VertexSemantic.TextureCoordinate, 2, VertexFormat.Vector4, 32),
new VertexElement(VertexSemantic.TextureCoordinate, 3, VertexFormat.Vector4, 48)
});
//We want a dynamic vertex buffer for the world transforms since we'll be updating each instance's
//rotation to "look at" the sphere.
worldTransforms = new VertexBuffer(decl, numInstances, ResourceUsage.Dynamic);
transformArray = new Matrix[numInstances];
int index = 0;
//Set the instances into a 2D grid on the XY plane.
for (int x = 0; x < 16; x++)
{
for (int y = 0; y < 16; y++)
{
Matrix transform = Matrix.FromTranslation(new Vector3((x - 7.5f) * 15.0f, (y - 7.5f) * 15.0f, 0.0f));
transformArray[index++] = transform;
}
}
worldTransforms.SetData <Matrix>(transformArray);
//Setup our vertex buffer bindings - the world transforms are set to an instance frequency of one, so for each
//instance we'll use one "vertex" from that buffer (which is the world transform)
buffers = new VertexBufferBinding[] { mesh.MeshData.VertexBuffer, new VertexBufferBinding(worldTransforms, 0, 1) };
//Load a material we've created
material = ContentManager.Load <Material>("Materials//InstancedMaterial.tem");
material.SetParameter("DiffuseMap", ContentManager.Load <Texture>("Textures//rock_diff.dds"));
}
protected override void LoadContent()
{
ClearColor = Color.Black;
shadowMap = new RenderTarget2D(1024, 1024, false, SurfaceFormat.Single, DepthFormat.Depth24Stencil8);
blurRT = new RenderTarget2D(1024, 1024, false, SurfaceFormat.Single, DepthFormat.None);
blurEffect = ContentManager.Load <Effect>("Shaders//GaussianBlur.fx");
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.NormalGeneration = NormalGeneration.Smooth;
mlp.SwapWindingOrder = true;
mlp.PreferLitMaterials = true;
rs = new RasterizerState();
rs.Cull = CullMode.Front;
rs.BindRenderState();
// mesh = new Sphere("Sphere", 50, 50, 20);
mesh = ContentManager.Load <Mesh>("Models//statue.tebo");
mesh.ComputeTangentBasis();
Material mat = ContentManager.Load <Material>("LitBasicTexture.tem").Clone();
mat.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//statue_diff.dds"));
mat.SetParameter("NormalMap", ContentManager.Load <Texture2D>("Textures//statue_norm.dds"));
mat.SetParameter("MatSpecular", new Vector3(.3f, .3f, .3f));
mesh.SetMaterial(mat);
Quad q = new Quad("Floor", 800, 800);
q.Rotation = Quaternion.FromAngleAxis(MathHelper.ToRadians(-90), Vector3.UnitX);
q.Translation = new Vector3(0, -70, 0);
q.Material = ContentManager.Load <Material>("Materials//LitBasicTextureShadow.tem").Clone();
q.Material.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//statue_diff.dds"));
receiverMat = q.Material;
receiverMat.SetParameter("MatSpecular", new Vector3(.3f, .3f, .3f));
// mesh.SetMaterial(receiverMat);
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.Enter, false), new InputAction(delegate(GameTime time) {
receive = !receive;
if (receive)
{
mesh.SetMaterial(receiverMat);
}
else
{
mesh.SetMaterial(mat);
}
})));
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.C, false), new InputAction(delegate(GameTime time) {
cullFront = !cullFront;
})));
DataBuffer <Vector2> texCoords = q.MeshData.TextureCoordinates;
texCoords.Position = 0;
texCoords.Set(new Vector2(0, 0));
texCoords.Set(new Vector2(4, 0));
texCoords.Set(new Vector2(4, 4));
texCoords.Set(new Vector2(0, 4));
q.MeshData.UpdateVertexData <Vector2>(VertexSemantic.TextureCoordinate, texCoords);
RootNode.AddChild(q);
sl = new SpotLight(new Vector3(100, 200, 10), new Vector3(-100, -200, -10), 5, 15);
RootNode.RemoveAllLights();
RootNode.AddLight(sl);
RootNode.AddChild(mesh);
shadowMat = new Material("ShadowMat");
shadowMat.LoadEffect(ContentManager.Load <Effect>("Shaders//ShadowMapEffect.fx"));
shadowMat.SetEngineParameter("LightWVP", Tesla.Core.EngineValue.WorldViewProjection);
lightCam = new Camera();
batch = new SpriteBatch();
dss = new DepthStencilState();
dss.DepthFunction = ComparisonFunction.LessEqual;
dss.BindRenderState();
float texOffsets = 0.5f + (0.5f / (float)shadowMap.Width);
texMat = new Matrix(0.5f, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
texOffsets, texOffsets, 0.0f, 1.0f);
rtnode = new Node("Node");
rtnode.Translation = sl.Position;
Node parent = new Node("Parent");
parent.AddChild(rtnode);
RootNode.AddChild(parent);
parent.AddController(new Tesla.Scene.Extension.RotateController(Vector3.UnitY, 25));
}
protected override void LoadContent()
{
Window.Title = "Input Handling Sample";
rotateSpeed = 2.5f;
speed = 105.0f;
Renderer.CurrentCamera.Position = new Vector3(0, 800, 100);
Renderer.CurrentCamera.LookAt(Vector3.Zero, Vector3.Up);
Renderer.CurrentCamera.Update();
//Load our fancy pants racecar
ModelLoaderParameters mlp = new ModelLoaderParameters();
mlp.SwapWindingOrder = true;
mlp.NormalGeneration = NormalGeneration.Crease;
mlp.PreferLitMaterials = true;
Spatial car = ContentManager.Load <Spatial>("Models//Jeep.dxs", mlp);
car.SetModelBound(new BoundingBox());
RootNode.AddChild(car);
//Create an input layer, this layer will hold all of our controls and input response to the arrow keys, moving the car
input = new InputLayer();
//Input layers can be disabled or enabled, so you're able to logically group your inputs together and treat them as one unit.
//E.g. if you have a screen menu and want the mouse enabled, but for gameplay do not want the mouse enabled.
//Rather than disabling the whole layer, we'll just disable the first 5 triggers - which are the
//FPS controls set in BasicApp.
InputLayer.EnableTrigger(0, false);
InputLayer.EnableTrigger(1, false);
InputLayer.EnableTrigger(2, false);
InputLayer.EnableTrigger(3, false);
InputLayer.EnableTrigger(4, false);
//Since we disabled the basicApp's input alyer, lets make sure we can get out of the app
input.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.Escape, false),
new InputAction(delegate(GameTime time) {
Exit();
})));
input.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.A, true), new InputAction(
delegate(GameTime time) {
car.Rotation *= Quaternion.FromAngleAxis(rotateSpeed * (float)time.ElapsedTimeInSeconds, Vector3.Up);
}
)));
input.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.D, true), new InputAction(
delegate(GameTime time) {
car.Rotation *= Quaternion.FromAngleAxis(-rotateSpeed * (float)time.ElapsedTimeInSeconds, Vector3.Up);
}
)));
input.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.W, true), new InputAction(
delegate(GameTime time) {
//Usually a good idea to use the world properties, since this may be attached to a node that is moving also
car.Translation -= car.WorldTransform.GetRotationVector(2) * speed * (float)time.ElapsedTimeInSeconds;
}
)));
input.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.S, true), new InputAction(
delegate(GameTime time) {
car.Translation += car.WorldTransform.GetRotationVector(2) * speed * (float)time.ElapsedTimeInSeconds;
}
)));
//Add another point light to the scene
PointLight pl = new PointLight();
pl.Attenuate = false;
pl.Position = new Vector3(0, 0, 50);
car.AddLight(pl);
}
protected override void LoadContent()
{
Window.Title = "Materials Sample";
//Materials are a high level construct that are used to render objects. They contain the following:
//
//1. An effect shader that contains a set of techniques, where each techniques have a number of passes.
//2. Render states for each pass.
//3. Collection of uniform parameters.
//4. Collection of engine parameters.
//5. Material logic.
//
//The first three are simply an extension of using an Effect object directly (and for managing render states at the app level, opposed
//to setting them in an effect file).
//
//Engine parameters are simply a binding between an uniform variable and an engine-defined value such as a World-View-Projection matrix,
//camera position, time variables, etc. This binding allows this data to be served to the shader automatically per-frame.
//
//Material logic are similar to Spatial controllers as they allow the user to add pieces of logic that are executed when the material is
//applied. This allows for the concept of "Pre-Shaders", where you compute values on the CPU and send that data to the GPU. This is useful
//for computations that only should be done once, rather than for every vertex or pixel fragment (saving instructions and time). An
//example of logic usage is how lighting is implemented in the engine - it's nothing more than a material logic that operates on the collection
//of lights a renderable contains.
//
//
//There are two ways to create a material - programmatically or via the engine's scripting functionality. Material scripts allow for the user
//to device a material in a text file that can be used as a template for other scripts and changed without having to write any C# code.
//Create a basic texture material
Material myMaterial = new Material("MyMaterial");
myMaterial.LoadEffect(ContentManager.Load <Effect>("BasicEffect.tebo").Clone());
myMaterial.SetActiveTechnique("BasicTexture");
myMaterial.SetParameter("DiffuseMap", ContentManager.Load <Texture2D>("Textures//rock_diff.dds"));
myMaterial.SetParameter("DiffuseColor", Color.White);
myMaterial.SetEngineParameter("WVP", EngineValue.WorldViewProjection);
/* The above would look like this as a script:
*
* Material MyMaterial {
* Effect {
* File : BasicEffect.tebo
* Technique : BasicTexture
* }
*
* MaterialParameters {
* Vector4 DiffuseColor : 1.0 1.0 1.0 1.0
* Texture2D DiffuseMap : Textures/rock_diff.dds
* }
*
* EngineParameters {
* WorldViewProjection : WVP
* }
* }*/
/* Additionally, you can use an existing script as a template. The BasicTexture.tem is
* a script already present in the engine's shader library and looks like the above script,
* minus the texture2d. So we use the script, and simply add a new parameter.
*
* Material MyMaterial : BasicTexture.tem {
*
* MaterialParameters {
* Texture2D DiffuseMap : Textures/rock_diff.dds
* }
* }*/
Material scriptMaterial = ContentManager.Load <Material>("Materials//SampleMaterial.tem").Clone();
//To differentiate the two, lets set the scripted material's diffuse color to light blue
scriptMaterial.SetParameter("DiffuseColor", Color.LightBlue);
//Set our procedural material to the left.
Box b1 = new Box("B1", 20, 20, 20);
b1.Material = myMaterial;
b1.Translation = new Vector3(-50, 0, 0);
RootNode.AddChild(b1);
//Set our scripted material to the right.
Box b2 = new Box("B2", 20, 20, 20);
b2.Material = scriptMaterial;
b2.Translation = new Vector3(50, 0, 0);
RootNode.AddChild(b2);
RootNode.SetModelBound(new BoundingBox());
}
/// <summary>
/// Please see the SceneGraph.rtf description for scene graph organization.
/// </summary>
protected override void LoadContent()
{
ClearColor = Color.CornflowerBlue;
Window.Title = "Scene Graph Sample";
//Create the teapot sub-tree, we're also creating a small box showing the position of
//the node in world space
Node teapotParent = new Node("TeapotParent");
Box teapotParentVisual = new Box("TeapotParentVisual", 1f, 1f, 1f);
teapotParentVisual.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
teapotParent.AddChild(teapotParentVisual);
//Set a rotate controller onto the teapot parent, so it'll rotate every frame
teapotParent.AddController(new RotateController(Vector3.UnitY, 25));
//Create the teapot mesh
Teapot teapot = new Teapot("Teapot");
//Load up a default lit color material
teapot.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
//Create another rotate controller that will rotate the teapot about its X-Axis
//45 degrees per second. This shows how we can -easily- concatenate transforms
//using the hierarchy of the scene graph.
teapot.AddController(new RotateController(Vector3.UnitX, 45f));
//Set a red color to the material.
teapot.Material.SetParameter("MatDiffuse", Color.Crimson.ToVector3());
teapot.Scale = new Vector3(5f, 5f, 5f);
//Position and add to parent
teapot.Translation = new Vector3(-50, 0, 0);
teapotParent.AddChild(teapot);
//Add the teapot sub tree to the root.
RootNode.AddChild(teapotParent);
//Add a white light to the root node
RootNode.RemoveAllLights();
PointLight pl = new PointLight();
pl.Attenuate = false;
pl.Position = new Vector3(-100, 50, 100);
RootNode.AddLight(pl);
//Create the box
Box box = new Box("Box", 10, 10, 10);
box.Translation = new Vector3(50, -50, 0);
box.Material = ContentManager.Load <Material>("LitBasicColor.tem").Clone();
box.Material.SetParameter("MatDiffuse", Color.Gray.ToVector3());
//Set the box to only use lights that are attached to it
box.SceneHints.LightCombineHint = LightCombineHint.Local;
//Create a green point light
PointLight pl2 = new PointLight();
pl2.Attenuate = false;
pl2.Diffuse = Color.Green;
pl2.Position = new Vector3(100, 50, 100);
box.AddLight(pl2);
//Add the box to the root
RootNode.AddChild(box);
//Set a bounding box to be used as the volume for each node/mesh in the scene graph.
RootNode.SetModelBound(new BoundingBox());
//Create some input handling to show how you can apply
//a scaling value to a parent node (this case the scene Root),
//and see it be applied to all children.
InputLayer.RegisterTrigger(new InputTrigger(new KeyPressedCondition(Keys.J, false), new InputAction(delegate(GameTime time) {
if (RootNode.Controllers.Count > 0)
{
RootNode.RemoveAllControllers();
RootNode.SetScale(1.0f);
scaleOn = false;
}
else
{
RootNode.AddController(new ScaleController(1.0f, .1f, 2.0f));
scaleOn = true;
}
})));
batch = new SpriteBatch();
font = ContentManager.Load <SpriteFont>("Fonts//comicsans.fnt");
}
private void ParseUntil(RootNode baseNode, TokenKind?stopToken = null)
{
while (_enumerator.MoveNext())
{
var token = _enumerator.Current;
if (token.Kind == stopToken)
{
break;
}
switch (token.Kind)
{
case TokenKind.DEF:
{
DefStatement temp = null;
switch (baseNode)
{
case IVariableTableContainer tableContainer:
{
temp = ParseDef(new Dictionary <string, int>(tableContainer.varTable));
break;
}
default:
{
temp = ParseDef(new Dictionary <string, int>(_base.varTable));
break;
}
}
baseNode.AddChild(temp);
break;
}
case TokenKind.NAME: {
//Console.WriteLine(_enumerator.Current.data);
if (_enumerator.MoveNext())
{
if (_enumerator.Current.Kind == TokenKind.EQUAL)
{
_enumerator.MovePrevious();
var name = _enumerator.Current.data;
_enumerator.MoveNext();
_enumerator.MoveNext();
var expr = ParseExpr();
baseNode.AddChild(new AssignStatement(
_enumerator.Current.row,
_enumerator.Current.column,
name, expr));
switch (baseNode)
{
case IVariableTableContainer tableContainer:
{
tableContainer.AddVar(name);
break;
}
default:
{
_currentNameSpace.AddVar(name);
break;
}
}
}
else if (_enumerator.Current.Kind == TokenKind.PLUSEQUAL ||
_enumerator.Current.Kind == TokenKind.MINEQUAL ||
_enumerator.Current.Kind == TokenKind.STAREQUAL ||
_enumerator.Current.Kind == TokenKind.SLASHEQUAL)
{
_enumerator.MovePrevious();
var name = _enumerator.Current.data;
var row = _enumerator.Current.row;
var col = _enumerator.Current.column;
switch (baseNode)
{
case IVariableTableContainer tableContainer:
{
if (!tableContainer.HaveVariable(name))
{
throw new CompilerException(
$"Name {name} is not defined at {_enumerator.Current.row}:{_enumerator.Current.column}",
_enumerator.Current.row, _enumerator.Current.column);
}
break;
}
default:
{
if (!_currentNameSpace.HaveVariable(name))
{
throw new CompilerException(
$"Name {name} is not defined at {_enumerator.Current.row}:{_enumerator.Current.column}",
_enumerator.Current.row, _enumerator.Current.column);
}
break;
}
}
_enumerator.MoveNext();
//var op = _enumerator.Current.Kind;
var op = _enumerator.Current.Kind switch
{
TokenKind.PLUSEQUAL => TokenKind.PLUS,
TokenKind.MINEQUAL => TokenKind.MINUS,
TokenKind.STAREQUAL => TokenKind.STAR,
TokenKind.SLASHEQUAL => TokenKind.SLASH
};
if (_enumerator.MoveNext())
{
baseNode.AddChild(new AssignStatement(
_enumerator.Current.row,
_enumerator.Current.column,
name,
new BinOp(_enumerator.Current.row,
_enumerator.Current.column,
op,
new VarExpression(row,
col,
name),
ParseExpr()
)));
}
}
else if (_enumerator.Current.Kind == TokenKind.LPAR)
{
_enumerator.MovePrevious();
var tempEx = ParseExpr();
var temp = new ExprStatement(tempEx.Row, tempEx.Column, tempEx);
//var temp = ParseName();
baseNode.AddChild(temp);
// if (!_base.root.GetChildren()
// .Any(def =>
// def is DefStatement d &&
// d.Name == temp.Name))
// {
// throw new SyntaxException(
// $"Name {temp.Name} is not defined at {temp.Row + 1}:{temp.Column}",
// temp.Row, temp.Column);
// }
this.MatchIndentation();
break;
}
else
{
_enumerator.MovePrevious();
baseNode.AddChild(new ExprStatement(
_enumerator.Current.row,
_enumerator.Current.column,
ParseExpr()));
;
}
}
break;
}
case TokenKind.IF:
{
var temp = ParseConditional();
baseNode.AddChild(temp);
//_enumerator.MovePrevious();
break;
}
case TokenKind.INT:
case TokenKind.MINUS:
case TokenKind.TILDE:
case TokenKind.EXCLAMINATION:
case TokenKind.LPAR:
{
var temp = new ExprStatement(_enumerator.Current.row,
_enumerator.Current.column,
ParseExpr());
//Console.WriteLine(temp.ToString());
baseNode.AddChild(temp);
MatchIndentationCurrent();
break;
}
case TokenKind.WHILE:
{
var temp = ParseWhileLoop();
baseNode.AddChild(temp);
break;
}
case TokenKind.BREAK:
{
if (_currentLoop == null)
{
throw new CompilerException($"Break is outside of loop at {_enumerator.Current.row}:" +
$"{_enumerator.Current.column}",
_enumerator.Current.row,
_enumerator.Current.column);
}
baseNode.AddChild(new BreakStatement(_enumerator.Current.row,
_enumerator.Current.column));
break;
}
case TokenKind.CONTINUE:
{
if (_currentLoop == null)
{
throw new CompilerException($"Continue is outside of loop at {_enumerator.Current.row}:" +
$"{_enumerator.Current.column}",
_enumerator.Current.row,
_enumerator.Current.column);
}
baseNode.AddChild(new ContinueStatement(_enumerator.Current.row,
_enumerator.Current.column));
break;
}
case TokenKind.PRINT:
{
var temp = new Print(_enumerator.Current.row, _enumerator.Current.column);
Match(TokenKind.LPAR);
temp.expr = ParseExpr();
_enumerator.MovePrevious();
MatchCurrent(TokenKind.RPAR);
baseNode.AddChild(temp);
break;
}
case TokenKind.RETURN:
{
if (_currentNameSpace.GetType() != typeof(DefStatement))
{
throw new CompilerException($"Return outside of function at {_enumerator.Current.row}:" +
$"{_enumerator.Current.column}",
_enumerator.Current.row,
_enumerator.Current.column);
}
var t = _enumerator.Current;
_enumerator.MovePrevious();
baseNode.AddChild(new ReturnStatement(t.row, t.column, MatchReturn()));
break;
}
default:
{
break;
}
}
}
}
