public RibbonSample(Microsoft.Xna.Framework.Game game) : base(game) { GraphicsScreen.DrawReticle = true; GameObjectService.Objects.Add(new GrabObject(Services)); // Load a sphere model. _modelNode = ContentManager.Load <ModelNode>("Particles/Sphere").Clone(); GraphicsScreen.Scene.Children.Add(_modelNode); // Add gravity and damping to the physics simulation. Simulation.ForceEffects.Add(new Gravity()); Simulation.ForceEffects.Add(new Damping()); // Create a rigid body for the sphere. _rigidBody = new RigidBody(new SphereShape(0.5f)) { Pose = new Pose(new Vector3F(-3, 0, 0)), LinearVelocity = new Vector3F(10, 10, -3f), }; Simulation.RigidBodies.Add(_rigidBody); _particleSystem = RibbonEffect.Create(ContentManager); ParticleSystemService.ParticleSystems.Add(_particleSystem); _particleSystemNode = new ParticleSystemNode(_particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public SmokeSample(Microsoft.Xna.Framework.Game game) : base(game) { // Create a single particle system and add it multiple times to the scene // graph ("instancing"). By default, all instances look identical. The // properties ParticleSystemNode.Color/Alpha/AngleOffset can be used to // render the particles with some variations. var particleSystem = Smoke.Create(ContentManager); ParticleSystemService.ParticleSystems.Add(particleSystem); _particleSystemNode0 = new ParticleSystemNode(particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode0); _particleSystemNode1 = new ParticleSystemNode(particleSystem); _particleSystemNode1.PoseWorld = new Pose(new Vector3(5, 0, -5)); _particleSystemNode1.Color = new Vector3(0.9f, 0.8f, 0.7f); _particleSystemNode1.Alpha = 0.8f; _particleSystemNode1.AngleOffset = 0.3f; GraphicsScreen.Scene.Children.Add(_particleSystemNode1); _particleSystemNode2 = new ParticleSystemNode(particleSystem); _particleSystemNode2.PoseWorld = new Pose(new Vector3(-10, 5, -5), Matrix.CreateRotationZ(-ConstantsF.PiOver2)); _particleSystemNode2.Color = new Vector3(0.5f, 0.5f, 0.5f); _particleSystemNode2.AngleOffset = 0.6f; GraphicsScreen.Scene.Children.Add(_particleSystemNode2); }
private void CreateParticleSystem() { // Load a sphere model. var modelNode = ContentManager.Load <ModelNode>("Particles/Sphere"); var meshNode = (MeshNode)modelNode.Children[0]; // Add gravity and damping to the physics simulation. Simulation.ForceEffects.Add(new Gravity()); Simulation.ForceEffects.Add(new Damping()); // Create two instances of the sphere model. _meshNode0 = meshNode.Clone(); GraphicsScreen.Scene.Children.Add(_meshNode0); _meshNode1 = meshNode.Clone(); GraphicsScreen.Scene.Children.Add(_meshNode1); // Create a rigid body for the left sphere. _rigidBody0 = new RigidBody(new SphereShape(0.5f)) { Pose = new Pose(new Vector3F(-3, 4, 0)), }; Simulation.RigidBodies.Add(_rigidBody0); // Create a rigid body for the right sphere. (Sharing the same shape, mass and material.) _rigidBody1 = new RigidBody(_rigidBody0.Shape, _rigidBody0.MassFrame, _rigidBody0.Material) { Pose = new Pose(new Vector3F(3, 4, 0)), }; Simulation.RigidBodies.Add(_rigidBody1); // Extract basic triangle mesh from the sphere model. var triangleMesh = meshNode.Mesh.Submeshes[0].ToTriangleMesh(); // Create a particle system for the left ball. This particle system uses // ReferenceFrame == ParticleReferenceFrame.World - which is the default for all // particle systems. Particles are all relative to world space. The particle system pose // determines the start positions and direction (when the StartPositionEffector and // StartDirectionEffector are in use). Particles do not move with the particle system. _particleSystem0 = GlowingMeshEffect.Create(triangleMesh, ContentManager); _particleSystem0.ReferenceFrame = ParticleReferenceFrame.World; ParticleSystemService.ParticleSystems.Add(_particleSystem0); _particleSystemNode0 = new ParticleSystemNode(_particleSystem0); _meshNode0.Children = new SceneNodeCollection { _particleSystemNode0 }; // Create a particle system for the right ball. This particle system uses // ReferenceFrame == ParticleReferenceFrame.Local. Particles are all relative to the // particle system pose. Particles move with the particle system. _particleSystem1 = GlowingMeshEffect.Create(triangleMesh, ContentManager); _particleSystem1.ReferenceFrame = ParticleReferenceFrame.Local; ParticleSystemService.ParticleSystems.Add(_particleSystem1); _particleSystemNode1 = new ParticleSystemNode(_particleSystem1); _meshNode1.Children = new SceneNodeCollection { _particleSystemNode1 }; }
public SuperEmitterSample(Microsoft.Xna.Framework.Game game) : base(game) { _particleSystem = new Rockets(); ParticleSystemService.ParticleSystems.Add(_particleSystem); _particleSystemNode = new ParticleSystemNode(_particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public DepthSortingSample(Microsoft.Xna.Framework.Game game) : base(game) { _brownOut = new BrownOut(ContentManager); ParticleSystemService.ParticleSystems.Add(_brownOut); _particleSystemNode = new ParticleSystemNode(_brownOut); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public RainSample(Microsoft.Xna.Framework.Game game) : base(game) { _particleSystem = Rain.Create(ContentManager); ParticleSystemService.ParticleSystems.Add(_particleSystem); _particleSystemNode = new ParticleSystemNode(_particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public WaterFallSample(Microsoft.Xna.Framework.Game game) : base(game) { _particleSystem = WaterFall.CreateWaterFall(ContentManager); _particleSystem.Pose = new Pose(new Vector3F(0, 2, 0), Matrix33F.CreateRotationY(ConstantsF.Pi)); ParticleSystemService.ParticleSystems.Add(_particleSystem); _particleSystemNode = new ParticleSystemNode(_particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
private void GenerateNode(ParticleSystemNode moduleNode) { var export = (ExportEntry)moduleNode.Entry; if (export.ClassName == "ParticleModuleSize") { GenerateParticleModuleSize(export, moduleNode); } //throw new System.NotImplementedException(); }
public BounceSample(Microsoft.Xna.Framework.Game game) : base(game) { var particleSystem = BouncingSparks.Create(ContentManager); ParticleSystemService.ParticleSystems.Add(particleSystem); _particleSystemNode = new ParticleSystemNode(particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public FlameJetSample(Microsoft.Xna.Framework.Game game) : base(game) { _flameJet = FlameJet.Create(ContentManager); _flameJet.Pose = new Pose(new Vector3(0, 2, 0), Matrix.CreateRotationY(ConstantsF.PiOver2)); ParticleSystemService.ParticleSystems.Add(_flameJet); _particleSystemNode = new ParticleSystemNode(_flameJet); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public void Initialize(ContentManager contentManager) { if (ParticleSystemNode == null) { // This is the first time this instance is used. var ps = new ParticleSystem { Name = "Teleport" + _count, ReferenceFrame = ParticleReferenceFrame.Local, Children = new ParticleSystemCollection { CreateSparkles(contentManager), CreateFastBeams(contentManager), CreateSlowBeams(contentManager), } }; // Add a uniform float particle parameter that contains the particle system time. ps.Parameters.AddUniform <float>("Time"); ps.Effectors.Add(new TimeToSingleEffector { Parameter = "Time" }); // Add a uniform GlobalAlpha parameter. This parameter controls the alpha of all // child particle systems. ps.Parameters.AddUniform <float>("GlobalAlpha"); ps.Effectors.Add(new SingleFadeEffector { ValueParameter = "GlobalAlpha", TimeParameter = "Time", FadeInStart = 0, FadeInEnd = 2, FadeOutStart = 2, FadeOutEnd = 3, }); ParticleSystemValidator.Validate(ps); ParticleSystemValidator.Validate(ps.Children[0]); ParticleSystemValidator.Validate(ps.Children[1]); ParticleSystemValidator.Validate(ps.Children[2]); ParticleSystemNode = new ParticleSystemNode(ps) { Name = "TeleportNode" + _count }; _count++; } else { ParticleSystem.Reset(); ParticleSystemNode.PoseWorld = Pose.Identity; } }
public DecalSample(Microsoft.Xna.Framework.Game game) : base(game) { GraphicsScreen.DrawReticle = true; SetCamera(new Vector3(0, 2, 6), 0, 0); _decals = Decals.Create(ContentManager); ParticleSystemService.ParticleSystems.Add(_decals); _particleSystemNode = new ParticleSystemNode(_decals); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
// OnUnload() is called when the GameObject is removed from the IGameObjectService. protected override void OnUnload() { // Clean up. _campfire.Parent.Children.Remove(_campfire); _campfire.Dispose(false); _campfire = null; _fireParticles = null; _smokeParticles = null; _light = null; _random = null; }
public bool Update(IGraphicsService graphicsService) { // The effect lasts for 3 seconds. if (ParticleSystem.Time >= TimeSpan.FromSeconds(3)) { return(false); } // Synchronize particles <-> graphics. ParticleSystemNode.Synchronize(graphicsService); return(true); }
public ExplosionSample(Microsoft.Xna.Framework.Game game) : base(game) { // Create an instance of the Explosion particle system. _explosion = new Explosion(ContentManager); _explosion.Pose = new Pose(new Vector3(0, 5, 0)); ParticleSystemService.ParticleSystems.Add(_explosion); _particleSystemNode = new ParticleSystemNode(_explosion); GraphicsScreen.Scene.Children.Add(_particleSystemNode); _explosionSound = ContentManager.Load <SoundEffect>("Particles/Explo1"); }
public VolumetricCloudSample(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)); _dynamicSkyObject = new DynamicSkyObject(Services, false, false, true); GameObjectService.Objects.Add(_dynamicSkyObject); GameObjectService.Objects.Add(new GroundObject(Services)); GameObjectService.Objects.Add(new ObjectCreatorObject(Services)); GameObjectService.Objects.Add(new LavaBallsObject(Services)); _particleCloud0 = new ParticleSystemNode(CreateParticleCloud(ContentManager)) { PoseLocal = new Pose(new Vector3(-0, 100, -400)), }; ParticleSystemService.ParticleSystems.Add(_particleCloud0.ParticleSystem); _graphicsScreen.Scene.Children.Add(_particleCloud0); _particleCloud1 = new ParticleSystemNode(CreateParticleCloud(ContentManager)) { PoseLocal = new Pose(new Vector3(-200, 100, -200)), }; ParticleSystemService.ParticleSystems.Add(_particleCloud1.ParticleSystem); _graphicsScreen.Scene.Children.Add(_particleCloud1); _particleCloud2 = new ParticleSystemNode(CreateParticleCloud(ContentManager)) { PoseLocal = new Pose(new Vector3(400, 400, -400)), }; ParticleSystemService.ParticleSystems.Add(_particleCloud2.ParticleSystem); _graphicsScreen.Scene.Children.Add(_particleCloud2); }
public AnimatedTextureSample(Microsoft.Xna.Framework.Game game) : base(game) { _beeSwarm = BeeSwarm.Create(ContentManager); _beeSwarm.Pose = new Pose(new Vector3F(0, 4, 0)); // Create 100 bees. _beeSwarm.AddParticles(100); ParticleSystemService.ParticleSystems.Add(_beeSwarm); _particleSystemNode = new ParticleSystemNode(_beeSwarm); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
private void AddJob(ParticleSystemNode node, ParticleSystemData particleSystemData, bool sortByDistance, bool backToFront) { if (particleSystemData.Particles.Count == 0) { return; } float distance = 0; if (sortByDistance) { // Position relative to ParticleSystemNode (root particle system). Vector3 position = particleSystemData.Pose.Position; // Position in world space. position = node.PoseWorld.ToWorldPosition(position); // Determine distance to camera. Vector3 cameraToNode = position - _cameraPose.Position; // Planar distance: Project vector onto look direction. distance = Vector3.Dot(cameraToNode, _cameraForward); // Use linear distance for viewpoint-oriented and world-oriented billboards. if (particleSystemData.BillboardOrientation.Normal != BillboardNormal.ViewPlaneAligned) { distance = cameraToNode.LengthSquared() * Math.Sign(distance); } if (backToFront) { distance = -distance; } } // Add draw job to list. ushort drawOrder = (ushort)particleSystemData.DrawOrder; var textureId = GetTextureId(particleSystemData.Texture); var job = new Job { SortKey = GetSortKey(distance, drawOrder, textureId), Node = node, ParticleSystemData = particleSystemData, }; _jobs.Add(ref job); }
public CampfireSample(Microsoft.Xna.Framework.Game game) : base(game) { var particleSystem = Campfire.CreateCampfire(ContentManager); // Add a smoke effect as a child to the campfire. particleSystem.Children = new ParticleSystemCollection(); particleSystem.Children.Add(CampfireSmoke.CreateCampfireSmoke(ContentManager)); // Position the campfire (including its child) in the level. // (The fire effect lies in the xy plane and shoots into the forward direction (= -z axis). // Therefore, we rotate the particle system to shoot upwards.) particleSystem.Pose = new Pose(new Vector3(0, 0.2f, 0), Matrix.CreateRotationX(ConstantsF.PiOver2)); ParticleSystemService.ParticleSystems.Add(particleSystem); _particleSystemNode = new ParticleSystemNode(particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
private void Draw(ParticleSystemNode node, ParticleSystemData particleSystemData) { // Scale and pose. Vector3 scale = Vector3.One; Pose pose = Pose.Identity; bool requiresTransformation = (particleSystemData.ReferenceFrame == ParticleReferenceFrame.Local); if (requiresTransformation) { scale = node.ScaleWorld; pose = node.PoseWorld * particleSystemData.Pose; } // Tint color and alpha. Vector3 color = node.Color; float alpha = node.Alpha; float angleOffset = node.AngleOffset; if (particleSystemData.IsRibbon) { if (particleSystemData.AxisParameter == null) { // Ribbons with automatic axis. DrawParticleRibbonsAuto(particleSystemData, requiresTransformation, ref scale, ref pose, ref color, alpha); } else { // Ribbons with fixed axis. DrawParticleRibbonsFixed(particleSystemData, requiresTransformation, ref scale, ref pose, ref color, alpha); } } else if (particleSystemData.IsDepthSorted) { // Particles sorted by depth. DrawParticlesBackToFront(particleSystemData, requiresTransformation, ref scale, ref pose, ref color, alpha, angleOffset); } else { // Particles sorted by age. DrawParticlesOldToNew(particleSystemData, requiresTransformation, ref scale, ref pose, ref color, alpha, angleOffset); } }
// Creates the draw jobs for a particle system node. private void AddJob(ParticleSystemNode node, bool sortByDistance, bool backToFront) { var renderData = node.ParticleSystem.RenderData as ParticleSystemData; if (renderData == null) { return; } // Add root particle system. AddJob(node, renderData, sortByDistance, backToFront); // Add nested particle systems. if (renderData.NestedRenderData != null) { foreach (var nestedRenderData in renderData.NestedRenderData) { AddJob(node, nestedRenderData, sortByDistance, backToFront); } } }
public RingOfFireSample(Microsoft.Xna.Framework.Game game) : base(game) { // Create a new "empty" particle system. var particleSystem = new ParticleSystem(); // Particle systems can have child particle systems. // Add a fire and a smoke effect as children. var fire = Fire.Create(ContentManager); var smoke = Smoke.Create(ContentManager); // The smoke effect from the previous sample. particleSystem.Children = new ParticleSystemCollection { fire, smoke }; // If we need to, we can modify the predefined effects. // Change the smoke particle lifetime. smoke.Parameters.Get <float>(ParticleParameterNames.Lifetime).DefaultValue = 4; // Change the smoke's start positions to a ring. smoke.Effectors.OfType <StartPositionEffector>().First().Distribution = new CircleDistribution { InnerRadius = 2, OuterRadius = 2 }; // Position the particle system (including its child) in the level. particleSystem.Pose = new Pose(new Vector3F(0, 3, 0)); // We only need to add the parent particle system to the particle system service. // The service will automatically update the parent system each frame. The parent // system will automatically update its children. ParticleSystemService.ParticleSystems.Add(particleSystem); // Add the particle system to the scene graph. _particleSystemNode = new ParticleSystemNode(particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); }
public BasicParticlesSample(Microsoft.Xna.Framework.Game game) : base(game) { // Create a new "empty" particle system. _particleSystem = new ParticleSystem(); // Names are optional, but very useful for debugging. _particleSystem.Name = "MyFirstParticleSystem"; // The particle system uses pre-allocated arrays. We should define an upper limit for // the number of particles that can be alive at the same moment. _particleSystem.MaxNumberOfParticles = 200; // The particle system's Pose defines the position and orientation of the particle system // in the world. _particleSystem.Pose = new Pose(new Vector3(0, 2, 0)); // The properties of the particles in the particle system are defined using // "particle parameters" (in the collection _particleSystem.Parameters). // Per default, there is only one parameter: "NormalizedAge" - which is managed // by the particle system itself and is the age of a particle in the range 0 - 1. // All our particles should live for 1 second after they have been created. Therefore, // we add a "uniform" parameter called "Lifetime" and set it to 1. var lifetimeParameter = _particleSystem.Parameters.AddUniform <float>("Lifetime"); lifetimeParameter.DefaultValue = 1f; // Each particle should have a position value. Therefore, we add a "varying" parameter // called "Position". "Varying" means that each particle has its own position value. // The particle system will internally allocate a Vector3 array to store all particle // positions. _particleSystem.Parameters.AddVarying <Vector3>("Position"); // When particles are created, we want them to appear at random position in a spherical // volume. We add an effector which initializes the particle "Positions" of newly created // particles. _particleSystem.Effectors.Add(new StartPositionEffector { // This effector should initialize the "Position" parameter. // Parameter = "Position", // "Position" is the default value anyway. // The start values should be chosen from this random value distribution: Distribution = new SphereDistribution { OuterRadius = 2 } }); // The particles should slowly fade in and out to avoid sudden appearance and disappearance. // We add a varying particle parameter called "Alpha" to store the alpha value per particle. _particleSystem.Parameters.AddVarying <float>("Alpha"); // The SingleFadeEffector animates a float parameter from 0 to a target value and // back to 0. _particleSystem.Effectors.Add(new SingleFadeEffector { // If TargetValueParameter is not set, then the target value is 1. //TargetValueParameter = 1, // The fade-in/out times are relative to a time parameter. // By default the "NormalizedAge" of the particles is used. //TimeParameter = "NormalizedAge", // The Alpha value should be animated. ValueParameter = "Alpha", // The fade-in/out times relative to the normalized age. FadeInStart = 0.0f, FadeInEnd = 0.3f, FadeOutStart = 0.5f, FadeOutEnd = 1.0f, }); // Next, we choose a texture for the particles. All particles use the same texture // parameter, which means the parameter is "uniform". var textureParameter = _particleSystem.Parameters.AddUniform <Texture2D>("Texture"); textureParameter.DefaultValue = ContentManager.Load <Texture2D>("Particles/LensFlare"); // The blend mode is a value between 0 and 1, where 0 means additive blending // 1 means alpha blending. Values between 0 and 1 are allowed. The particles in // this example should be drawn using additive alpha blending. var blendModeParameter = _particleSystem.Parameters.AddUniform <float>("BlendMode"); blendModeParameter.DefaultValue = 0.0f; // There is a lot to configure. Did we forget anything? - We can use an optional helper method // to validate our particle system. Uninitialized or missing parameters are printed to the // Console. Check the Visual Studio Output window for any messages. ParticleSystemValidator.Validate(_particleSystem); // Adding the particle system to a ParticleSystemService is optional but very useful // because the service will update the particle system for us in each frame. ParticleSystemService.ParticleSystems.Add(_particleSystem); // To render the particle effect, we need to create a scene node and add it to the // scene graph. _particleSystemNode = new ParticleSystemNode(_particleSystem); GraphicsScreen.Scene.Children.Add(_particleSystemNode); // A tip for the future: // The class ParticleParameterNames is a collection of strings that can be used for // common particle parameters. It is recommended to use the particle parameter names in // this class to avoid problems because of typing errors in the source code. }
// OnLoad() is called when the GameObject is added to the IGameObjectService. protected override void OnLoad() { var particleSystemService = _services.GetInstance <IParticleSystemService>(); // The campfire consists of two particle systems (fire + smoke) and a light source. // // _campfire (SceneNode) // | // +-- _fireParticles (ParticleSystemNode) // | // +-- _smokeParticles (ParticleSystemNode) // | // +-- _light (LightNode) // Use a basic scene node as the root node for the campfire. _campfire = new SceneNode { Name = "Campfire", PoseLocal = new Pose(new Vector3F(0, 0, -1)), Children = new SceneNodeCollection() }; // Add fire particles. var contentManager = _services.GetInstance <ContentManager>(); var particleSystem = CreateFire(contentManager); particleSystemService.ParticleSystems.Add(particleSystem); _fireParticles = new ParticleSystemNode(particleSystem) { // The fire effect lies in the xy plane and shoots into the forward direction (= -z axis). // Therefore we rotate the particle system to shoot upwards. PoseLocal = new Pose(new Vector3F(0, 0.2f, 0), Matrix33F.CreateRotationX(ConstantsF.PiOver2)) }; _campfire.Children.Add(_fireParticles); // Add smoke particles. particleSystem = CreateSmoke(contentManager); particleSystemService.ParticleSystems.Add(particleSystem); _smokeParticles = new ParticleSystemNode(particleSystem) { PoseLocal = new Pose(new Vector3F(0, 0.2f, 0), Matrix33F.CreateRotationX(ConstantsF.PiOver2)) }; _campfire.Children.Add(_smokeParticles); // Add a point light that illuminates the environment. var light = new PointLight { Attenuation = 0.1f, Color = new Vector3F(1, 0.2f, 0), HdrScale = 20, Range = 4 }; _light = new LightNode(light) { // Optional: We can make this light cast shadows - but this will cost performance! //Shadow = new CubeMapShadow { PreferredSize = 64, FilterRadius = 2, JitterResolution = 2048 }, PoseLocal = new Pose(new Vector3F(0, 1f, 0)) }; _campfire.Children.Add(_light); // Add campfire to scene. var scene = _services.GetInstance <IScene>(); scene.Children.Add(_campfire); // Particle effects can be added multiple times to the scene (= "instancing"). // Uncomment the following lines to add a few more instance to the scene. //for (int i = 0; i < 10; i++) //{ // var clone = _campfire.Clone(); // // Set random scale, position, orientation. // clone.ScaleLocal = _random.NextVector3F(0.5f, 1.5f); // var pose = _campfire.PoseWorld; // pose.Position.X += _random.NextFloat(-10, 10); // pose.Position.Z += _random.NextFloat(-10, 10); // pose.Orientation = Matrix33F.CreateRotationY(_random.NextFloat(-ConstantsF.PiOver2, ConstantsF.PiOver2)); // clone.PoseLocal = pose; // scene.Children.Add(clone); //} }
private void GenerateParticleModuleSize(ExportEntry export, ParticleSystemNode moduleNode) { }
public override void LoadExport(ExportEntry exportEntry) { CurrentLoadedExport = exportEntry; var props = exportEntry.GetProperties(); List <ParticleSystemNode> rootNodes = new List <ParticleSystemNode>(); var emitters = props.GetProp <ArrayProperty <ObjectProperty> >("Emitters"); foreach (var emitter in emitters) { if (emitter.Value != 0) { if (CurrentLoadedExport.FileRef.IsUExport(emitter.Value)) { var emitterExport = CurrentLoadedExport.FileRef.GetUExport(emitter.Value); var emitterName = emitterExport.GetProperty <NameProperty>("EmitterName"); string header = emitterName?.Value.Name ?? "Emitter"; ParticleSystemNode p = new ParticleSystemNode { Entry = emitterExport, Header = $"{emitterExport.UIndex} {header}" }; rootNodes.Add(p); var emitterLODs = emitterExport.GetProperty <ArrayProperty <ObjectProperty> >("LODLevels"); int lodNumber = 0; if (emitterLODs != null) { foreach (var lod in emitterLODs) { var lodExport = CurrentLoadedExport.FileRef.GetUExport(lod.Value); ParticleSystemNode psLod = new ParticleSystemNode { Entry = lodExport, Header = $"LOD {lodNumber}: {lodExport.UIndex} {lodExport.InstancedFullPath}" }; p.Children.Add(psLod); { var requiredModule = (ExportEntry)lodExport.GetProperty <ObjectProperty>("RequiredModule")?.ResolveToEntry(CurrentLoadedExport.FileRef); if (requiredModule != null) { ParticleSystemNode reqModule = new ParticleSystemNode { Entry = requiredModule, Header = $"Required Module: {requiredModule.UIndex} {requiredModule.InstancedFullPath}" }; psLod.Children.Add(reqModule); var materialEntry = requiredModule.GetProperty <ObjectProperty>("Material")?.ResolveToEntry(CurrentLoadedExport.FileRef); if (materialEntry != null) { ParticleSystemNode matNode = new ParticleSystemNode { Entry = materialEntry, Header = $"Material: {materialEntry.UIndex} {materialEntry.InstancedFullPath}" }; reqModule.Children.Add(matNode); } } } var typeDataExport = (ExportEntry)lodExport.GetProperty <ObjectProperty>("TypeDataModule")?.ResolveToEntry(CurrentLoadedExport.FileRef); if (typeDataExport != null) { ParticleSystemNode typeModuleNode = new ParticleSystemNode { Entry = typeDataExport, Header = $"Type Data Module: {typeDataExport.UIndex} {typeDataExport.InstancedFullPath}" }; psLod.Children.Add(typeModuleNode); var meshes = typeDataExport.GetProperty <ArrayProperty <ObjectProperty> >("m_Meshes"); if (meshes != null) { int meshIndex = 0; foreach (var mesh in meshes) { var meshExp = mesh.ResolveToEntry(CurrentLoadedExport.FileRef); if (meshExp != null) { ParticleSystemNode meshNode = new ParticleSystemNode { Entry = meshExp, Header = $"Mesh {meshIndex}: {meshExp.UIndex} {meshExp.InstancedFullPath}" }; typeModuleNode.Children.Add(meshNode); } meshIndex++; } } } var modules = lodExport.GetProperty <ArrayProperty <ObjectProperty> >("Modules"); if (modules != null) { int modIndex = 0; foreach (var module in modules) { var moduleExp = module.ResolveToEntry(CurrentLoadedExport.FileRef); if (moduleExp != null) { ParticleSystemNode moduleNode = new ParticleSystemNode { Entry = moduleExp, Header = $"Module {modIndex}: {moduleExp.UIndex} {moduleExp.InstancedFullPath}" }; psLod.Children.Add(moduleNode); GenerateNode(moduleNode); } modIndex++; } } lodNumber++; } } } } } ParticleNodes.ReplaceAll(rootNodes); }
public DistortionSample(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 StaticSkyObject(Services)); // Skybox + some lights. //GameObjectService.Objects.Add(new GroundObject(Services)); // Add a ground plane with some detail to see the water refractions. Simulation.RigidBodies.Add(new RigidBody(new PlaneShape(new Vector3F(0, 1, 0), 0))); GameObjectService.Objects.Add(new StaticObject(Services, "Gravel/Gravel", 1, new Pose(new Vector3F(0, 0.001f, 0)))); GameObjectService.Objects.Add(new DudeObject(Services)); GameObjectService.Objects.Add(new DynamicObject(Services, 1)); GameObjectService.Objects.Add(new DynamicObject(Services, 2)); GameObjectService.Objects.Add(new DynamicObject(Services, 3)); GameObjectService.Objects.Add(new DynamicObject(Services, 5)); GameObjectService.Objects.Add(new DynamicObject(Services, 6)); GameObjectService.Objects.Add(new DynamicObject(Services, 7)); GameObjectService.Objects.Add(new ObjectCreatorObject(Services)); GameObjectService.Objects.Add(new FogObject(Services)); GameObjectService.Objects.Add(new CampfireObject(Services)); GameObjectService.Objects.Add(new LavaBallsObject(Services)); // 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))); } // Add DistortionFilter to post-processors. _distortionFilter = new DistortionFilter(GraphicsService, ContentManager); _graphicsScreen.PostProcessors.Add(_distortionFilter); // Add 3 particle systems. // The ParticleSystems are added to the IParticleSystemService. // The ParticleSystemNodes are added to the Scene of the DistortionFilter - not the usual Scene! _fireDistortionParticleSystemNode = new ParticleSystemNode(CreateFireDistortionParticleSystem()) { PoseLocal = new Pose(new Vector3F(0, 0f, -1), Matrix33F.CreateRotationX(ConstantsF.PiOver2)), }; ParticleSystemService.ParticleSystems.Add(_fireDistortionParticleSystemNode.ParticleSystem); _distortionFilter.Scene.Children.Add(_fireDistortionParticleSystemNode); _explosionDistortionParticleSystemNode = new ParticleSystemNode(CreateExplosionDistortionParticleSystem()) { PoseLocal = new Pose(new Vector3F(0, 0, -1)), }; ParticleSystemService.ParticleSystems.Add(_explosionDistortionParticleSystemNode.ParticleSystem); _distortionFilter.Scene.Children.Add(_explosionDistortionParticleSystemNode); _novaDistortionParticleSystemNode = new ParticleSystemNode(CreateNovaDistortionParticleSystem()) { PoseLocal = new Pose(new Vector3F(0, 0.5f, -1), Matrix33F.CreateRotationX(ConstantsF.PiOver2)), }; ParticleSystemService.ParticleSystems.Add(_novaDistortionParticleSystemNode.ParticleSystem); _distortionFilter.Scene.Children.Add(_novaDistortionParticleSystemNode); }