public XnaModelSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            _delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _delegateGraphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            // Load XNA model.
            _model = ContentManager.Load <Model>("Saucer3/saucer");

            // Enable default lighting.
            var basicEffects = _model.Meshes
                               .SelectMany(m => m.MeshParts)
                               .Select(mp => mp.Effect)
                               .OfType <BasicEffect>();

            foreach (var effect in basicEffects)
            {
                effect.EnableDefaultLighting();
            }
        }
        public WindowsPhoneSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Disable mouse centering and show the mouse cursor.
            EnableMouseCentering = false;

            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            _graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _graphicsScreen);

            // Load a UI theme, which defines the appearance and default values of UI controls.
            _uiContentManager = new ContentManager(Services, "WindowsPhone7Theme");
            Theme theme = _uiContentManager.Load <Theme>("ThemeDark");

            // Create a UI renderer, which uses the theme info to renderer UI controls.
            UIRenderer renderer = new UIRenderer(Game, theme);

            // Create a UIScreen and add it to the UI service. The screen is the root of the
            // tree of UI controls. Each screen can have its own renderer.
            _uiScreen = new UIScreen("SampleUIScreen", renderer)
            {
                // Make the screen transparent.
                Background = new Color(0, 0, 0, 0),
            };
            UIService.Screens.Add(_uiScreen);

            // Open a window.
            var window = new WpWindow(Game);

            window.Show(_uiScreen);
        }
        public CustomCommandSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            var graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render
            };

            GraphicsService.Screens.Insert(0, graphicsScreen);

            _spriteBatch = GraphicsService.GetSpriteBatch();

            // Load a few SpriteFonts for rendering.
            _textFont   = UIContentManager.Load <SpriteFont>("UI Themes/WindowsPhone7/Segoe15");
            _buttonFont = ContentManager.Load <SpriteFont>("ButtonImages/xboxControllerSpriteFont");

            // Add custom commands to input service.
            _buttonHoldCommand = new ButtonHoldCommand(Buttons.A, 1.0f)
            {
                Name = "Hold A"
            };
            _buttonTapCommand = new ButtonTapCommand(Buttons.A, 0.2f, 1.0f)
            {
                Name = "Tap A"
            };
            _buttonSequenceCommand = new ButtonSequenceCommand(new [] { Buttons.A, Buttons.B, Buttons.A, Buttons.B }, 2.0f)
            {
                Name = "A-B-A-B"
            };
            InputService.Commands.Add(_buttonHoldCommand);
            InputService.Commands.Add(_buttonTapCommand);
            InputService.Commands.Add(_buttonSequenceCommand);
        }
Example #4
0
        public SubmeshSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            _delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _delegateGraphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            var graphicsDevice = GraphicsService.GraphicsDevice;

            // The MeshHelper class can create submeshes for several basic shapes:
            _sphere = MeshHelper.CreateUVSphere(graphicsDevice, 20);
            _torus  = MeshHelper.CreateTorus(graphicsDevice, 0.5f, 0.667f, 16);
            _teapot = MeshHelper.CreateTeapot(graphicsDevice, 1, 8);

            // MeshHelper.CreateBox() returns a new submesh for a box. Instead we can call
            // MeshHelper.GetBox(), which returns a shared submesh. - GetBox() will always
            // return the same instance.
            _box = MeshHelper.GetBox(GraphicsService);

            // We can also create a submesh that uses line primitives.
            _cone = MeshHelper.GetConeLines(GraphicsService);

            // We use a normal XNA BasicEffect to render the submeshes.
            _effect = new BasicEffect(graphicsDevice)
            {
                PreferPerPixelLighting = true
            };
            _effect.EnableDefaultLighting();
        }
Example #5
0
        public ManualMeshRenderSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            _scene = new Scene();
            SceneSample.InitializeDefaultXnaLights(_scene);

            // For advanced users: Set this flag if you want to analyze the imported opaque data of
            // effect bindings.
            EffectBinding.KeepOpaqueData = true;

            _model = ContentManager.Load <ModelNode>("Dude/Dude").Clone();
            var meshNode = _model.GetSubtree().OfType <MeshNode>().First();

            meshNode.ScaleLocal = new Vector3(1, 2, 1);
            var mesh     = meshNode.Mesh;
            var timeline = new TimelineClip(mesh.Animations.Values.First())
            {
                Duration     = TimeSpan.MaxValue,
                LoopBehavior = LoopBehavior.Cycle,
            };

            AnimationService.StartAnimation(timeline, (IAnimatableProperty)meshNode.SkeletonPose);
        }
Example #6
0
        public Editor2D(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Create a simple delegate graphics screen to handle figure rendering
            var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };

            // TODO - make sure we don't just want to put this under the controls screen?
            // make sure to insert it on top?
            GraphicsService.Screens.Insert(0, delegateGraphicsScreen);

            _cameraObject = new Editor2DCameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            CreateGrid();
            CreateGate();

            // Add a game object which handles the picking:
            GameObjectService.Objects.Add(new FigurePickerObject(GraphicsService, Scene, _cameraObject, DebugRenderer));

            var test = new GridSettingsWindow();

            UIScreen.Children.Add(test);
        }
        public ScreenInScreenSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // The first screen.
            _screen1 = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = RenderScreen1,
            };
            GraphicsService.Screens.Insert(0, _screen1);

            // The second screen.
            _screen2 = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = RenderScreen2,

                // A graphics screen should let the graphics service know if it renders
                // to the whole screen, thereby hiding any graphics screens in the background.
                Coverage = GraphicsScreenCoverage.Full,

                // Tell the graphics service to render the previous screens into a render
                // target with a custom format.
                RenderPreviousScreensToTexture = true,
                SourceTextureFormat            = new RenderTargetFormat(800, 600, false, SurfaceFormat.Color, DepthFormat.Depth24),
            };
            GraphicsService.Screens.Insert(1, _screen2);



            // Create a sprite batch.
            _spriteBatch = new SpriteBatch(GraphicsService.GraphicsDevice);

            // Load a sprite font.
            _spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");
        }
Example #8
0
    public GameStatesSample(Microsoft.Xna.Framework.Game game)
      : base(game)
    {
      // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
      // service. This lets us do the rendering in the Render method of this class.
      var graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
      {
        RenderCallback = Render,
      };
      GraphicsService.Screens.Insert(0, graphicsScreen);

      // Load a UI theme, which defines the appearance and default values of UI controls.
      Theme theme = ContentManager.Load<Theme>("UI Themes/GameStatesSample/Theme");

      // Create a UI renderer, which uses the theme info to renderer UI controls.
      UIRenderer renderer = new UIRenderer(Game, theme);

      // Create a UIScreen and add it to the UI service. The screen is the root of the 
      // tree of UI controls. Each screen can have its own renderer.
      _uiScreen = new UIScreen("SampleUIScreen", renderer)
      {
        // Make the screen transparent.
        Background = new Color(0, 0, 0, 0),
      };
      UIService.Screens.Add(_uiScreen);

      CreateStateMachine();
    }
Example #9
0
        public MyGameComponent(Microsoft.Xna.Framework.Game game, IServiceLocator services)
            : base(game)
        {
            // Get the services that this component needs regularly.
            _services          = services;
            _inputService      = services.GetInstance <IInputService>();
            _simulation        = services.GetInstance <Simulation>();
            _graphicsService   = services.GetInstance <IGraphicsService>();
            _gameObjectService = services.GetInstance <IGameObjectService>();
            _uiService         = services.GetInstance <IUIService>();

            // Add gravity and damping to the physics simulation.
            _simulation.ForceEffects.Add(new Gravity());
            _simulation.ForceEffects.Add(new Damping());

            // Create the DeferredGraphicsScreen and some 3D objects.
            _deferredGraphicsScreen             = new DeferredGraphicsScreen(services);
            _deferredGraphicsScreen.DrawReticle = true;
            _graphicsService.Screens.Insert(0, _deferredGraphicsScreen);

            // The GameObjects below expect try to retrieve DebugRenderer and Scene via
            // service container.
            var serviceContainer = (ServiceContainer)services;

            serviceContainer.Register(typeof(DebugRenderer), null, _deferredGraphicsScreen.DebugRenderer);
            serviceContainer.Register(typeof(IScene), null, _deferredGraphicsScreen.Scene);

            _cameraGameObject = new CameraObject(services);
            _gameObjectService.Objects.Add(_cameraGameObject);
            _deferredGraphicsScreen.ActiveCameraNode = _cameraGameObject.CameraNode;
            _gameObjectService.Objects.Add(new GrabObject(services));
            _gameObjectService.Objects.Add(new StaticSkyObject(services));
            _gameObjectService.Objects.Add(new GroundObject(services));
            for (int i = 0; i < 10; i++)
            {
                _gameObjectService.Objects.Add(new DynamicObject(services, 1));
            }

            // Get the "SampleUI" screen that was created by the StartScreenComponent.
            _uiScreen = _uiService.Screens["SampleUI"];

            // Add a second GraphicsScreen. This time it is a DelegateGraphicsScreen that
            // draws the UI over DeferredGraphicsScreen.
            _delegateGraphicsScreen = new DelegateGraphicsScreen(_graphicsService)
            {
                RenderCallback = context => _uiScreen.Draw(context.DeltaTime)
            };
            _graphicsService.Screens.Insert(1, _delegateGraphicsScreen);

            // Create the game menu window. But do not display it yet.
            _gameMenuWindow = new GameMenuWindow
            {
                // If the menu is opened and closed a lot, it is more efficient when _gameMenuWindow.Close()
                // makes the window invisible but does not remove it from the screen.
                HideOnClose = true,
            };
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _graphicsService.Screens.Remove(_graphicsScreen);
                _graphicsScreen = null;
            }

            base.Dispose(disposing);
        }
Example #11
0
        public TilingSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Disable mouse centering and show the mouse cursor.
            EnableMouseCentering = false;

            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            _graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _graphicsScreen);

            // Load a UI theme, which defines the appearance and default values of UI controls.
            _uiContentManager = new ContentManager(Services, "TilingSampleTheme");
            Theme theme = _uiContentManager.Load <Theme>("Theme");

            // Create a UI renderer, which uses the theme info to renderer UI controls.
            UIRenderer renderer = new UIRenderer(Game, theme);

            // Create a UIScreen and add it to the UI service. The screen is the root of the
            // tree of UI controls. Each screen can have its own renderer.
            _uiScreen = new UIScreen("SampleUIScreen", renderer);
            UIService.Screens.Add(_uiScreen);

            // Create a window using the default style "Window".
            var stretchedWindow = new Window
            {
                X         = 100,
                Y         = 100,
                Width     = 480,
                Height    = 320,
                CanResize = true,
            };

            _uiScreen.Children.Add(stretchedWindow);

            // Create a window using the style "TiledWindow".
            var tiledWindow = new Window
            {
                X         = 200,
                Y         = 200,
                Width     = 480,
                Height    = 320,
                CanResize = true,
                Style     = "TiledWindow",
            };

            _uiScreen.Children.Add(tiledWindow);

            // Check file TilingSampleContent/Theme.xml to see how the styles are defined.
        }
Example #12
0
        public DebugRendererSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            // Load a sprite font.
            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            // Create a new debug renderer.
            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont)
            {
                DefaultColor = Color.White,
            };

            // A normal XNA model.
            _xnaModel = ContentManager.Load <Model>("Saucer3/saucer");

            // A DigitalRune model.
            _modelNode           = ContentManager.Load <ModelNode>("Dude/Dude").Clone();
            _modelNode.PoseLocal = new Pose(new Vector3F(6, 0, -7));

            // Create a geometric object with a height field shape.
            var numberOfSamplesX = 20;
            var numberOfSamplesZ = 20;
            var samples          = new float[numberOfSamplesX * numberOfSamplesZ];

            for (int z = 0; z < numberOfSamplesZ; z++)
            {
                for (int x = 0; x < numberOfSamplesX; x++)
                {
                    samples[z * numberOfSamplesX + x] = 1.0f + (float)(Math.Cos(z / 2f) * Math.Sin(x / 2f) * 1.0f);
                }
            }
            HeightField heightField = new HeightField(0, 0, 120, 120, samples, numberOfSamplesX, numberOfSamplesZ);

            _geometricObject = new GeometricObject(heightField, new Pose(new Vector3F(5, 0, -5)))
            {
                Scale = new Vector3F(0.01f, 0.05f, 0.02f),
            };
        }
Example #13
0
        public ControlsSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            var graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };

            GraphicsService.Screens.Insert(0, graphicsScreen);

            CreateGui();
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_uiScreen != null) // This check is necessary because Dispose() might be called more than once.
                {
                    _uiService.Screens.Remove(_uiScreen);
                    _uiScreen = null;

                    _graphicsService.Screens.Remove(_graphicsScreen);
                    _graphicsScreen = null;
                }
            }
            base.Dispose(disposing);
        }
Example #15
0
        public ControlsSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Disable mouse centering and show the mouse cursor.
            EnableMouseCentering = false;

            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            _graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _graphicsScreen);

            CreateGui();
        }
        public DebugRendererSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            _delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _delegateGraphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            // Load a sprite font.
            var spriteFont = UIContentManager.Load <SpriteFont>("Default");

            // Create a new debug renderer.
            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont)
            {
                DefaultColor = Color.White,
            };

            // A normal XNA model.
            _xnaModel = ContentManager.Load <Model>("Saucer3/saucer");

            // A DigitalRune model.
            _modelNode           = ContentManager.Load <ModelNode>("Dude/Dude").Clone();
            _modelNode.PoseLocal = new Pose(new Vector3F(6, 0, -7));

            // Create a geometric object with a height field shape.
            HeightField heightField = new HeightField {
                WidthX = 120, WidthZ = 120, Array = new float[20, 20]
            };

            for (int row = 0; row < heightField.Array.GetLength(0); row++)
            {
                for (int column = 0; column < heightField.Array.GetLength(1); column++)
                {
                    heightField.Array[row, column] = 1.0f + (float)(Math.Cos(column / 2f) * Math.Sin(row / 2f) * 1.0f);
                }
            }

            _geometricObject = new GeometricObject(heightField, new Pose(new Vector3F(5, 0, -5)))
            {
                Scale = new Vector3F(0.01f, 0.05f, 0.02f),
            };
        }
Example #17
0
        public FigureSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            _delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _delegateGraphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            var spriteFont  = UIContentManager.Load <SpriteFont>("Default");
            var spriteBatch = new SpriteBatch(GraphicsService.GraphicsDevice);

            _figureRenderer = new FigureRenderer(GraphicsService, 2048);
            _spriteRenderer = new SpriteRenderer(GraphicsService, spriteBatch, spriteFont);
            _debugRenderer  = new DebugRenderer(GraphicsService, spriteBatch, spriteFont)
            {
                DefaultColor        = Color.Black,
                DefaultTextPosition = new Vector2F(20, 40)
            };

            _scene = new Scene();

            // To draw figures, they are flattened (= converted to line segments)
            // internally. Figure.Tolerance defines the allowed error between the
            // smooth and the flattened curve.
            Figure.Tolerance = 0.0001f;

            // Add some FigureNodes to the scene.
            CreateGrid();
            CreateGridClone();
            CreateRandomPath();
            CreateRectangles();
            CreateEllipses();
            CreateAlphaBlendedFigures();
            CreateChain();
            CreateGizmo(spriteFont);
            CreateFlower();

            // Add a game object which handles the picking:
            _figurePickerObject = new FigurePickerObject(GraphicsService, _scene, _cameraObject, _debugRenderer);
            GameObjectService.Objects.Add(_figurePickerObject);
        }
        public override void Initialize()
        {
            base.Initialize();

            // Add a DelegateGraphicsScreen as the first graphics screen to the graphics
            // service. This lets us do the rendering in the Render method of this class.
            _graphicsScreen = new DelegateGraphicsScreen(_graphicsService)
            {
                RenderCallback = Render,
            };
            _graphicsService.Screens.Insert(0, _graphicsScreen);

            // Get the "SampleUI" screen that was created by the StartScreenComponent.
            _uiScreen = _uiService.Screens["SampleUI"];

            // Show the main menu window.
            _mainMenuWindow = new MainMenuWindow();
            _mainMenuWindow.Show(_uiScreen);
        }
Example #19
0
        public CustomSceneNodeSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            // Create a new empty scene.
            _scene = new Scene();

            // Add the camera node to the scene.
            _scene.Children.Add(_cameraObject.CameraNode);

            // Add a few TextNodes. Position them along a circle.
            for (int i = 0; i < 36; i++)
            {
                Vector3F position = Matrix33F.CreateRotationZ(MathHelper.ToRadians((float)i * 10)) * new Vector3F(1, 0, 0);
                var      textNode = new TextNode
                {
                    PoseLocal = new Pose(position),
                    Color     = Color.Yellow,
                    Text      = i.ToString()
                };
                _scene.Children.Add(textNode);
            }

            // Initialize the TextRenderer.
            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            _textRenderer = new TextRenderer(GraphicsService, spriteFont);

            // For debugging:
            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);
        }
Example #20
0
        public InstancingSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            _scene = new Scene();
            _scene.Children.Add(_cameraObject.CameraNode);

            // Add a lot of instances of one model to the scene. This model uses a custom
            // shader which supports instancing. See the *.drmdl, *.drmat and *.fx files
            // in the directory of the FBX file.
            var model = ContentManager.Load <ModelNode>("InstancedModel/InstancedModel");

            for (int x = 1; x < 50; x++)
            {
                for (int z = 1; z < 20; z++)
                {
                    var  clone = model.Clone();
                    Pose pose  = clone.PoseLocal;
                    pose.Position.X -= x;
                    pose.Position.Z -= z;
                    clone.PoseLocal  = pose;
                    clone.ScaleLocal = new Vector3(0.7f);
                    SetRandomColorAndAlpha(clone);
                    _scene.Children.Add(clone);
                }
            }

            SceneSample.InitializeDefaultXnaLights(_scene);

            _meshRenderer = new MeshRenderer();
        }
Example #21
0
        protected AnimationSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Add a DelegateGraphicsScreen and use the OnRender method of this class to
            // do the rendering.
            _graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = OnRender,
            };
            // The order of the graphics screens is back-to-front. Add the screen at index 0,
            // i.e. behind all other screens. The screen should be rendered first and all other
            // screens (menu, GUI, help, ...) should be on top.
            GraphicsService.Screens.Insert(0, _graphicsScreen);

            // Provide a SpriteBatch, SpriteFont and images for rendering.
            SpriteBatch = new SpriteBatch(GraphicsService.GraphicsDevice);
            SpriteFont  = UIContentManager.Load <SpriteFont>("Default");
            Logo        = ContentManager.Load <Texture2D>("Logo");
            Reticle     = ContentManager.Load <Texture2D>("Reticle");
        }
Example #22
0
        public ObliqueFrustumSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            SampleFramework.IsMouseVisible = false;
            var graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };

            GraphicsService.Screens.Insert(0, graphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);

            TestClippedProjection();
        }
        public DelegateGraphicsScreenSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            // Create the DelegateGraphicsService and add it to the graphics service.
            var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                UpdateCallback = Update,
                RenderCallback = Render,
            };

            // Graphics screens are rendered in the order in which they appear in the
            // IGraphicsService.Screens collection. We insert our screen at the beginning
            // of the collection to render our screen before the other screens (e.g. menu,
            // help text, profiling).
            GraphicsService.Screens.Insert(0, delegateGraphicsScreen);

            // Create a sprite batch.
            _spriteBatch = new SpriteBatch(GraphicsService.GraphicsDevice);

            // Load a sprite font.
            _spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");
        }
Example #24
0
        public SceneSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            _delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };
            GraphicsService.Screens.Insert(0, _delegateGraphicsScreen);

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            // Create a new empty scene.
            _scene = new Scene();

            // Add the camera node to the scene.
            _scene.Children.Add(_cameraObject.CameraNode);

            // Load a model. This model uses the DigitalRune Model Processor. Several XML
            // files (*.drmdl and *.drmat) in the folder of dude.fbx define the materials and other properties.
            // The DigitalRune Model Processor also imports the animations of the dude model.
            var model = ContentManager.Load <ModelNode>("Dude/Dude");

            // Add two clones of the model to the scene.
            _model0 = model.Clone();
            _model1 = model.Clone();
            _scene.Children.Add(_model0);
            _scene.Children.Add(_model1);

            // The dude model contains a single mesh node.
            var meshNode0 = (MeshNode)_model0.Children[0];
            var meshNode1 = (MeshNode)_model1.Children[0];

            // The imported animation data (skeleton and animations) is stored with the mesh.
            var animations = meshNode0.Mesh.Animations;

            // The MeshNodes of skinned models has a SkeletonPose which can be animated.
            // Let's start the first animation.
            var timeline0 = new TimelineClip(animations.Values.First())
            {
                LoopBehavior = LoopBehavior.Cycle, // Loop animation...
                Duration     = TimeSpan.MaxValue,  // ...forever.
            };

            _animationController0 = AnimationService.StartAnimation(timeline0, (IAnimatableProperty)meshNode0.SkeletonPose);
            _animationController0.UpdateAndApply();

            var timeline1 = new TimelineClip(animations.Values.First())
            {
                LoopBehavior = LoopBehavior.Cycle,
                Duration     = TimeSpan.MaxValue,

                // Start second animation at a different animation time to add some variety.
                Delay = TimeSpan.FromSeconds(-1),
            };

            _animationController1 = AnimationService.StartAnimation(timeline1, (IAnimatableProperty)meshNode1.SkeletonPose);
            _animationController1.UpdateAndApply();

            // Add some lights to the scene which have the same properties as the lights
            // of BasicEffect.EnableDefaultLighting().
            InitializeDefaultXnaLights(_scene);

            _meshRenderer = new MeshRenderer();

            var spriteFont = UIContentManager.Load <SpriteFont>("Default");

            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);
        }
        public DebuggingComponent(Microsoft.Xna.Framework.Game game, IServiceLocator services)
            : base(game)
        {
            _inputService    = services.GetInstance <IInputService>();
            _graphicsService = services.GetInstance <IGraphicsService>();
            _uiService       = services.GetInstance <IUIService>();

            // Get graphics service and add a DelegateGraphicsScreen as the first
            // graphics screen. This lets us do the rendering in the Render method of
            // this class.

            _graphicsScreen = new DelegateGraphicsScreen(_graphicsService)
            {
                RenderCallback = Render,
            };
            _graphicsService.Screens.Insert(0, _graphicsScreen);

            // Load a UI theme and create a renderer.
            // We could use the same renderer as the "Default" screen (see StartScreenComponent.cs).
            // But usually, the debug screen will use a more efficient theme (smaller fonts, no
            // fancy graphics). Here, we simply use the Neoforce theme again.
            _uiContentManager = new ContentManager(services, "NeoforceTheme");
            var        theme    = _uiContentManager.Load <Theme>("ThemeRed");
            UIRenderer renderer = new UIRenderer(Game, theme);

            // Create a UIScreen and add it to the UI service.
            _uiScreen = new UIScreen("Debug", renderer)
            {
                // A transparent background.
                Background = new Color(0, 0, 0, 0),

                // The z-index is equal to the draw order. The z-index defines in which order the
                // screens are updated. This screen with the debug console should be updated before
                // the actual game under this screen.
                ZIndex = 10,

                // Hide the screen. The user has to press a button to make the debug screen visible.
                IsVisible = false,
            };

            // Optional:
            // The debug screen handles gamepad input first, then the other screens and game components
            // can handle input. We do not want that the game is controllable when the debug screen is
            // visible, therefore we set the IsHandled flags when the screen is finished with the input.
            _uiScreen.InputProcessed += (s, e) => _inputService.SetGamePadHandled(LogicalPlayerIndex.Any, true);

            // Add a console control on the left.
            _console = new Console
            {
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment   = VerticalAlignment.Stretch,
                Width  = 500,
                Margin = new Vector4F(20),
            };
            _uiScreen.Children.Add(_console);

            // Print a few info messages in the console.
            _console.WriteLine("Press TAB or ChatPadGreen to display/hide console.");
            _console.WriteLine("Enter 'help' to view console commands.");

            // Add a custom command:
            _console.Interpreter.Commands.Add(new ConsoleCommand("greet", "greet [<name>] ... Prints a greeting message.", Greet));

            // Add the screen to the UI service.
            _uiService.Screens.Add(_uiScreen);
        }
        private readonly LensFlareRenderer _lensFlareRenderer; // Handles LensFlareNodes.


        public LensFlareSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            // Create a new empty scene.
            _scene = new Scene();

            // Add the camera node to the scene.
            _scene.Children.Add(_cameraObject.CameraNode);

            // Add a few models to the scene.
            var ground = ContentManager.Load <ModelNode>("Ground/Ground").Clone();

            _scene.Children.Add(ground);

            var box = ContentManager.Load <ModelNode>("MetalGrateBox/MetalGrateBox").Clone();

            box.PoseLocal = new Pose(new Vector3(0.5f, 0.5f, 0.5f), Matrix.CreateRotationY(0.1f));
            _scene.Children.Add(box);

            // Add some lights to the scene which have the same properties as the lights
            // of BasicEffect.EnableDefaultLighting().
            SceneSample.InitializeDefaultXnaLights(_scene);

            // Add a lens flare for the sun light.
            var lensFlare = new LensFlare(true); // The sun is a directional light source.

            lensFlare.Name = "Sun Flare";

            // The Size determines the screen size of the lens flare elements. The value
            // is relative to the viewport height.
            lensFlare.Size = 0.28f; // 0.28 * viewport height

            // The QuerySize of a directional light is the estimated size relative to the
            // viewport. This value is used in the hardware occlusion query, which determines
            // whether the lens flare is visible.
            lensFlare.QuerySize = 0.18f; // 0.18 * viewport height

            // All lens flare elements are packed into one texture ("texture atlas").
            // The PackedTexture identifies an element within the texture atlas.
            // See file Media/LensFlare/LensFlares.png.
            // (Credits: The sun lens flare was copied from the XNA racing game - http://exdream.com/XnaRacingGame/.)
            var lensFlareTexture = ContentManager.Load <Texture2D>("LensFlare/LensFlares");
            var circleTexture    = new PackedTexture("Circle", lensFlareTexture, new Vector2F(0, 0), new Vector2F(0.25f, 0.5f));
            var glowTexture      = new PackedTexture("Glow", lensFlareTexture, new Vector2F(0.25f, 0), new Vector2F(0.25f, 0.5f));
            var ringTexture      = new PackedTexture("Ring", lensFlareTexture, new Vector2F(0.5f, 0), new Vector2F(0.25f, 0.5f));
            var haloTexture      = new PackedTexture("Halo", lensFlareTexture, new Vector2F(0.75f, 0), new Vector2F(0.25f, 0.5f));
            var sunTexture       = new PackedTexture("Sun", lensFlareTexture, new Vector2F(0, 0.5f), new Vector2F(0.25f, 0.5f));
            var streaksTexture   = new PackedTexture("Streaks", lensFlareTexture, new Vector2F(0.25f, 0.5f), new Vector2F(0.25f, 0.5f));
            var flareTexture     = new PackedTexture("Flare", lensFlareTexture, new Vector2F(0.5f, 0.5f), new Vector2F(0.25f, 0.5f));

            // Add a few elements (circles, glow, rings, halos, streaks, ...) to the lens flare.
            lensFlare.Elements.Add(new LensFlareElement(-0.2f, 0.55f, 0.0f, new Color(175, 175, 255, 20), new Vector2F(0.5f, 0.5f), circleTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.0f, 0.9f, 0.0f, new Color(255, 255, 255, 255), new Vector2F(0.5f, 0.5f), sunTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.0f, 1.8f, 0.0f, new Color(255, 255, 255, 128), new Vector2F(0.5f, 0.5f), streaksTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.0f, 2.6f, 0.0f, new Color(255, 255, 200, 64), new Vector2F(0.5f, 0.5f), glowTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.5f, 0.12f, 0.0f, new Color(60, 60, 180, 35), new Vector2F(0.5f, 0.5f), circleTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.55f, 0.46f, 0.0f, new Color(100, 100, 200, 60), new Vector2F(0.5f, 0.5f), circleTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.6f, 0.17f, 0.0f, new Color(120, 120, 220, 40), new Vector2F(0.5f, 0.5f), circleTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.85f, 0.2f, 0.0f, new Color(60, 60, 255, 100), new Vector2F(0.5f, 0.5f), ringTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.5f, 0.2f, 0.0f, new Color(255, 60, 60, 130), new Vector2F(0.5f, 0.5f), flareTexture));
            lensFlare.Elements.Add(new LensFlareElement(0.15f, 0.15f, 0.0f, new Color(255, 60, 60, 90), new Vector2F(0.5f, 0.5f), flareTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.3f, 0.6f, 0.0f, new Color(60, 60, 255, 180), new Vector2F(0.5f, 0.5f), haloTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.4f, 0.2f, 0.0f, new Color(220, 80, 80, 98), new Vector2F(0.5f, 0.5f), haloTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.5f, 0.1f, 0.0f, new Color(220, 80, 80, 85), new Vector2F(0.5f, 0.5f), circleTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.6f, 0.5f, 0.0f, new Color(60, 60, 255, 80), new Vector2F(0.5f, 0.5f), haloTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.8f, 0.3f, 0.0f, new Color(90, 60, 255, 110), new Vector2F(0.5f, 0.5f), ringTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.95f, 0.5f, 0.0f, new Color(60, 60, 255, 120), new Vector2F(0.5f, 0.5f), haloTexture));
            lensFlare.Elements.Add(new LensFlareElement(2.0f, 0.15f, 0.0f, new Color(60, 60, 255, 85), new Vector2F(0.5f, 0.5f), circleTexture));

            // The scene node "KeyLight" (defined in SceneSample.InitializeDefaultXnaLights())
            // is the main directional light source.
            var keyLightNode = _scene.GetDescendants().First(n => n.Name == "KeyLight");

            // Let's attach the lens flare to the "KeyLight" node.
            // (Note: It is not necessary to attach a lens flare to a light node. Lens flares
            // can be added anywhere within the scene. But attaching the lens flare to the
            // light node ensures that the lens flare always has the same position and direction
            // as the light source.)
            var lensFlareNode = new LensFlareNode(lensFlare);

            keyLightNode.Children = new SceneNodeCollection();
            keyLightNode.Children.Add(lensFlareNode);

            // Add a second lens flare.
            // The previous lens flare was a caused by a directional light source (distance = infinite).
            // This time we add a local lens flare.
            lensFlare      = new LensFlare(false);
            lensFlare.Name = "Anamorphic Flare";
            lensFlare.Size = 0.3f; // 0.3 * viewport height

            // The QuerySize of a local lens flare is estimated size of the light source
            // in world space.
            lensFlare.QuerySize = 0.2f; // 0.2 meters

            // Add some elements (glow, horizontal streaks, ...) to the lens flare effect.
            var anamorphicFlareTexture = ContentManager.Load <Texture2D>("LensFlare/AnamorphicFlare");

            flareTexture = new PackedTexture("AnamorphicFlare", anamorphicFlareTexture, new Vector2F(0, 0), new Vector2F(1.0f, 87f / 256f));
            var flare1Texture = new PackedTexture("Flare0", anamorphicFlareTexture, new Vector2F(227f / 512f, 88f / 256f), new Vector2F(285f / 512f, 15f / 256f));
            var flare2Texture = new PackedTexture("Flare1", anamorphicFlareTexture, new Vector2F(0, 87f / 256f), new Vector2F(226f / 512f, 168f / 256f));

            lensFlare.Elements.Add(new LensFlareElement(0.0f, 0.8f, 0.0f, new Color(255, 255, 255, 255), new Vector2F(0.5f, 0.5f), flareTexture));
            lensFlare.Elements.Add(new LensFlareElement(1.0f, new Vector2F(0.6f, 0.5f), 0.0f, new Color(172, 172, 255, 32), new Vector2F(0.5f, 0.5f), flare1Texture));
            lensFlare.Elements.Add(new LensFlareElement(1.5f, 1.2f, float.NaN, new Color(200, 200, 255, 24), new Vector2F(0.5f, 0.2f), flare2Texture));
            lensFlare.Elements.Add(new LensFlareElement(2.0f, 2.0f, float.NaN, new Color(172, 172, 255, 48), new Vector2F(0.5f, 0.2f), flare2Texture));

            // Position the lens flare near the origin.
            lensFlareNode           = new LensFlareNode(lensFlare);
            lensFlareNode.PoseWorld = new Pose(new Vector3(-0.5f, 1, 0));
            _scene.Children.Add(lensFlareNode);

            // In this example we need two renderers:
            // The MeshRenderer handles MeshNodes.
            _meshRenderer = new MeshRenderer();

            // The LensFlareRenderer handles LensFlareNodes.
            _lensFlareRenderer = new LensFlareRenderer(GraphicsService);
        }
Example #27
0
        public ProxyNodeSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            SampleFramework.IsMouseVisible = false;
            var delegateGraphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };

            GraphicsService.Screens.Insert(0, delegateGraphicsScreen);

            _renderer = new MeshRenderer();

            // Add a custom game object which controls the camera.
            _cameraObject = new CameraObject(Services);
            GameObjectService.Objects.Add(_cameraObject);

            _scene = new Scene();
            SceneSample.InitializeDefaultXnaLights(_scene);

            // For advanced users: Set this flag if you want to analyze the imported opaque data of
            // effect bindings.
            EffectBinding.KeepOpaqueData = true;

            // Original model in scene graph.
            var modelNode = ContentManager.Load <ModelNode>("Dude/Dude").Clone();

            modelNode.PoseLocal = new Pose(new Vector3(-2, 0, 0));
            var meshNode = modelNode.GetSubtree().OfType <MeshNode>().First();

            _scene.Children.Add(modelNode);

            // Clone referenced by proxy node.
            var modelNode2 = modelNode.Clone();
            var meshNode2  = modelNode2.GetSubtree().OfType <MeshNode>().First();

            meshNode2.SkeletonPose = meshNode.SkeletonPose;
            _proxyNode             = new ProxyNode(null)
            {
                Name       = "Proxy",
                PoseLocal  = new Pose(new Vector3(2, 0, 0), Matrix.CreateRotationY(ConstantsF.Pi)),
                ScaleLocal = new Vector3(0.5f),
            };
            _scene.Children.Add(_proxyNode);
            _proxyNode.Node = modelNode2;

            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);

            var mesh = meshNode.Mesh;

            foreach (var m in mesh.Materials)
            {
                //((ConstParameterBinding<Vector3>)m["Default"].ParameterBindings["SpecularColor"]).Value = new Vector3();
                ((SkinnedEffectBinding)m["Default"]).PreferPerPixelLighting = true;
            }

            var timeline = new TimelineClip(mesh.Animations.Values.First())
            {
                Duration     = TimeSpan.MaxValue,
                LoopBehavior = LoopBehavior.Cycle,
            };

            AnimationService.StartAnimation(timeline, (IAnimatableProperty)meshNode.SkeletonPose);
        }
        public BillboardSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            // In this example we need three renderers:
            // The MeshRenderer handles MeshNodes.
            _meshRenderer = new MeshRenderer();

            // The BillboardRenderer handles BillboardNodes and ParticleSystemNodes.
            _billboardRenderer = new BillboardRenderer(GraphicsService, 2048);

            // The DebugRenderer is used to draw text.
            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);

            // Create a new empty scene.
            _scene = new Scene();

            // Add the camera node to the scene.
            _scene.Children.Add(_cameraObject.CameraNode);

            // Add a few models to the scene.
            var sandbox = ContentManager.Load <ModelNode>("Sandbox/Sandbox").Clone();

            _scene.Children.Add(sandbox);

            // Add some lights to the scene which have the same properties as the lights
            // of BasicEffect.EnableDefaultLighting().
            SceneSample.InitializeDefaultXnaLights(_scene);

            var texture = new PackedTexture(ContentManager.Load <Texture2D>("Billboard/BillboardReference"));

            // ----- View plane-aligned billboards with variations.
            // View plane-aligned billboards are rendered parallel to the screen.
            // The up-axis of the BillboardNode determines the up direction of the
            // billboard.
            var pose0         = new Pose(new Vector3(-9, 1.0f, 1.5f));
            var pose1         = pose0;
            var billboard     = new ImageBillboard(texture);
            var billboardNode = new BillboardNode(billboard);

            billboardNode.Name      = "View plane-aligned\nVarying color\nVarying alpha";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            billboardNode.Color     = new Vector3(1, 0, 0);
            billboardNode.Alpha     = 0.9f;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            billboardNode.Color     = new Vector3(0, 1, 0);
            billboardNode.Alpha     = 0.7f;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            billboardNode.Color     = new Vector3(0, 0, 1);
            billboardNode.Alpha     = 0.3f;
            _scene.Children.Add(billboardNode);

            // ----- View plane-aligned billboards with different blend modes
            // blend mode = 0 ... additive blend
            // blend mode = 1 ... alpha blend
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.BlendMode     = 0.0f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "View plane-aligned\nVarying blend mode";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.BlendMode     = 0.333f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.BlendMode     = 0.667f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.BlendMode     = 1.0f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- View plane-aligned billboards with alpha test
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.AlphaTest     = 0.9f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "View plane-aligned\nVarying reference alpha";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.AlphaTest     = 0.667f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.AlphaTest     = 0.333f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboard               = new ImageBillboard(texture);
            billboard.AlphaTest     = 0.0f;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- View plane-aligned billboards with different scale and rotation
            pose0.Position.X        += 2;
            pose1                    = pose0;
            billboard                = new ImageBillboard(texture);
            billboard.Orientation    = BillboardOrientation.ViewPlaneAligned;
            billboardNode            = new BillboardNode(billboard);
            billboardNode.Name       = "View plane-aligned\nVarying scale\nVarying rotation";
            billboardNode.PoseWorld  = pose1;
            billboardNode.ScaleLocal = new Vector3(0.4f);
            _scene.Children.Add(billboardNode);

            pose1.Position.Z        -= 1;
            billboardNode            = billboardNode.Clone();
            billboardNode.Name       = null;
            billboardNode.PoseWorld  = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(-15)));
            billboardNode.ScaleLocal = new Vector3(0.6f);
            _scene.Children.Add(billboardNode);

            pose1.Position.Z        -= 1;
            billboardNode            = billboardNode.Clone();
            billboardNode.Name       = null;
            billboardNode.PoseWorld  = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(-30)));
            billboardNode.ScaleLocal = new Vector3(0.8f);
            _scene.Children.Add(billboardNode);

            pose1.Position.Z        -= 1;
            billboardNode            = billboardNode.Clone();
            billboardNode.Name       = null;
            billboardNode.PoseWorld  = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(-45)));
            billboardNode.ScaleLocal = new Vector3(1.0f);
            _scene.Children.Add(billboardNode);

            // ----- Viewpoint-oriented billboards
            // Viewpoint-orientated billboards always face the player. (The face normal
            // points directly to the camera.)
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.Orientation   = BillboardOrientation.ViewpointOriented;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "Viewpoint-oriented";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- Screen-aligned billboards
            // View plane-aligned billboards and screen-aligned billboards are similar. The
            // billboards are rendered parallel to the screen. The orientation can be changed
            // by rotating the BillboardNode. The difference is that the orientation of view
            // plane-aligned billboards is relative to world space and the orientation of
            // screen-aligned billboards is relative to view space.
            // Screen-aligned billboards are, for example, used for text label.
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.Orientation   = BillboardOrientation.ScreenAligned;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "Screen-aligned";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- Axial, view plane-aligned billboards
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.Orientation   = BillboardOrientation.AxialViewPlaneAligned;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "Axial, view plane-aligned";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = billboardNode.Clone();
            billboardNode.Name      = null;
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- Axial, viewpoint-oriented billboards
            pose0.Position.X       += 2;
            pose1                   = pose0;
            billboard               = new ImageBillboard(texture);
            billboard.Orientation   = BillboardOrientation.AxialViewpointOriented;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "Axial, viewpoint-oriented";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // ----- World-oriented billboards
            // World-oriented billboards have a fixed orientation in world space. The
            // orientation is determine by the BillboardNode.
            pose0.Position.X       += 2;
            pose1                   = pose0;
            pose1.Orientation      *= Matrix.CreateRotationY(0.2f);
            billboard               = new ImageBillboard(texture);
            billboard.Orientation   = BillboardOrientation.WorldOriented;
            billboardNode           = new BillboardNode(billboard);
            billboardNode.Name      = "World-oriented";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            pose1.Orientation      *= Matrix.CreateRotationY(0.2f);
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(15)));
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            pose1.Orientation      *= Matrix.CreateRotationY(0.2f);
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(30)));
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            pose1.Orientation      *= Matrix.CreateRotationY(0.2f);
            billboardNode           = new BillboardNode(billboard);
            billboardNode.PoseWorld = pose1 * new Pose(Matrix.CreateRotationZ(MathHelper.ToRadians(45)));
            _scene.Children.Add(billboardNode);

            // ----- Animated billboards
            // DigitalRune Graphics supports "texture atlases". I.e. textures can be packed
            // together into a single, larger texture file. A PackedTexture can describe a
            // single texture packed into a texture atlas or a tile set packed into a
            // texture atlas. In this example the "beeWingFlap" is a set of three tiles.
            // Tile sets can be used for sprite animations. (The animation is set below in
            // Update().)
            pose0.Position.X       += 2;
            pose1                   = pose0;
            texture                 = new PackedTexture("Bee", ContentManager.Load <Texture2D>("Particles/beeWingFlap"), Vector2F.Zero, Vector2F.One, 3, 1);
            _animatedBillboard      = new ImageBillboard(texture);
            billboardNode           = new BillboardNode(_animatedBillboard);
            billboardNode.Name      = "Animated billboards";
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(_animatedBillboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            pose1.Position.Z       -= 1;
            billboardNode           = new BillboardNode(_animatedBillboard);
            billboardNode.PoseWorld = pose1;
            _scene.Children.Add(billboardNode);

            // Use DebugRenderer to draw node names above billboard nodes.
            foreach (var node in _scene.GetDescendants().OfType <BillboardNode>())
            {
                _debugRenderer.DrawText(node.Name, node.PoseWorld.Position + new Vector3(0, 1, 0), new Vector2F(0.5f), Color.Yellow, false);
            }
        }
        public MeshNodeSample(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);
            GameObjectService.Objects.Add(_cameraObject);

            // For advanced users: Set this flag if you want to analyze the imported opaque data of
            // effect bindings.
            //EffectBinding.KeepOpaqueData = true;

            // Load a model. The model is processed using the DigitalRune Model Processor - not
            // the default XNA model processor!
            // In the folder that contains tank.fbx, there is an XML file tank.drmdl which defines
            // properties of the model. These XML files are automatically processed by the
            // DigitalRune Model Processor.
            // Each model itself is a tree of scene nodes. The grid model contains one mesh
            // node. The tank model contains several mesh nodes (turret, cannon, hatch,
            // wheels, ...).
            _model = ContentManager.Load <ModelNode>("Tank/tank");

            // The XNA ContentManager manages a single instance of each model. We clone
            // the model, to get a copy that we can modify without changing the original
            // instance. Cloning is fast because it only duplicates the scene nodes - but
            // not the mesh and material information.
            _model = _model.Clone();

            // _model is the root of a tree of scene nodes. The mesh nodes are the child
            // nodes. When we scale or move the _model, we automatically scale and move
            // all child nodes.
            _model.ScaleLocal = new Vector3F(0.8f);
            _model.PoseWorld  = new Pose(new Vector3F(0, 0, -2), Matrix33F.CreateRotationY(-0.3f));

            // Let's loop through the mesh nodes of the model:
            foreach (var meshNode in _model.GetSubtree().OfType <MeshNode>())
            {
                // Each MeshNode references a Mesh.
                Mesh mesh = meshNode.Mesh;

                // The mesh consists of several submeshes and several materials - usually
                // one material per submesh, but several submeshes could reference the same
                // materials.

                // Let's loop through the materials of this mesh.
                foreach (var material in mesh.Materials)
                {
                    // A material is a collection of EffectBindings - one EffectBinding for each
                    // render pass. For example, a complex game uses several render passes, like
                    // a pre-Z pass, a G-buffer pass, a shadow map pass, a deferred material pass,
                    // etc.In simple games there is only one pass which is called "Default".
                    var effectBinding = material["Default"];

                    // An EffectBinding references an Effect (the XNA Effect class) and it has
                    // "parameter bindings" and "technique bindings". These bindings select the
                    // values for the shader parameters when the mesh node is rendered.

                    // Let's change the binding for the DiffuseColor of the shader to give tank
                    // a red color.
                    effectBinding.Set("DiffuseColor", new Vector4(1, 0.7f, 0.7f, 1));

                    // The tank uses the default effect binding which is a BasicEffectBinding - this
                    // effect binding uses the XNA BasicEffect.
                    // In this sample we do not define any lights, therefore we disable the lighting
                    // in the shader.
                    ((BasicEffectBinding)effectBinding).LightingEnabled = false;
                }
            }

            _meshRenderer = new MeshRenderer();

            var spriteFont = UIContentManager.Load <SpriteFont>("UI Themes/BlendBlue/Default");

            _debugRenderer = new DebugRenderer(GraphicsService, spriteFont);
        }
Example #30
0
        public HealthBarSample(Microsoft.Xna.Framework.Game game)
            : base(game)
        {
            SampleFramework.IsMouseVisible = false;

            // The base class has created the graphics screen for the 3D objects.
            GraphicsScreen.ClearBackground = true;
            GraphicsScreen.BackgroundColor = Color.CornflowerBlue;
            SetCamera(new Vector3(0, 1, 3), 0, 0);
            _cameraObject = GameObjectService.Objects.OfType <CameraObject>().First();

            // We add another graphics screen on top which renders the GUI.
            var graphicsScreen = new DelegateGraphicsScreen(GraphicsService)
            {
                RenderCallback = Render,
            };

            GraphicsService.Screens.Insert(1, graphicsScreen);

            // Create a UIScreen.
            Theme      theme    = ContentManager.Load <Theme>("UI Themes/BlendBlue/Theme");
            UIRenderer renderer = new UIRenderer(Game, theme);

            _uiScreen = new UIScreen("HealthBarScreen", renderer)
            {
                Background = Color.Transparent, // Background must not hide the 3D graphics screen.
            };
            UIService.Screens.Add(_uiScreen);

            // Standard force effects.
            Simulation.ForceEffects.Add(new Gravity());
            Simulation.ForceEffects.Add(new Damping());

            // Standard game objects.
            GameObjectService.Objects.Add(new GroundObject(Services));

            // Create a new game object property. This allows to attach a z value to all UIControls.
            _zPropertyId = UIControl.CreateProperty <float>(
                typeof(UIControl),
                "Z",
                GamePropertyCategories.Appearance,
                "The layer depth. Objects with lower depth value are in front.",
                0.0f,
                UIPropertyOptions.AffectsRender);

            // Create 3D objects and a progress bar for each object.
            for (int i = 0; i < 10; i++)
            {
                var dynamicObject = new DynamicObject(Services, 1);
                GameObjectService.Objects.Add(dynamicObject);

                var progressBar = new ProgressBar
                {
                    Value   = RandomHelper.Random.NextFloat(0, 100),
                    Maximum = 100,
                    X       = 100,
                    Y       = 100,
                    Width   = 100,
                    Height  = 20,
                    Margin  = new Vector4(-50, -10, 0, 0), // Use a margin to center the control.
                };
                _uiScreen.Children.Add(progressBar);

                _objects.Add(new Pair <DynamicObject, ProgressBar>(dynamicObject, progressBar));
            }
        }