Beispiel #1
0
        public void UpdateFrustum()
        {
            var drawSys   = DrawSystem.GetInstance();
            var cameraSys = CameraSystem.GetInstance();

            // frustum culling use always the ingame camera. this means that you can look down culling in editor mode
            var camera = cameraSys.IngameCamera;

            m_frustumMatrix = camera.GetCameraData().GetViewMatrix() * drawSys.GetDrawContext().GetHeadMatrix() * drawSys.ComputeProjectionTransform();
        }
Beispiel #2
0
        private void _OnLoad(object sender, EventArgs e)
        {
#if DEBUG
            m_debugDialog = new DebugDialog();
            m_debugDialog.Show();
            var debugMenu = m_debugDialog.GetSystemMenuItem();
            DrawSystem.GetInstance().CreateDebugMenu(debugMenu);
            GameSystem.GetInstance().CreateDebugMenu(debugMenu);
            CameraSystem.GetInstance().CreateDebugMenu(debugMenu);
#endif // DEBUG
        }
Beispiel #3
0
        private void _RegisterDebugEntity()
        {
            var entitySys = EntitySystem.GetInstance();

            var entity = new GameEntity("frustum");

            var layoutC = new LayoutComponent();

            layoutC.Transform = Matrix.Identity;
            entity.AddComponent(layoutC);

            var drawC = new EasyDrawComponent((IDrawContext context, Matrix layout, DrawModel lastDrawModel) =>
            {
                if (lastDrawModel != null)
                {
                    lastDrawModel.Dispose();
                }

                var cameraSys = CameraSystem.GetInstance();
                if (cameraSys.IngameCamera != cameraSys.ActiveCamera)
                {
                    // frustum is visible in editor mode
                    var drawModel = DrawModel.CreateFrustum("frustum", _GetFrustumMatrix(), Color.Cyan);
                    foreach (var node in drawModel.NodeList)
                    {
                        context.DrawDebugModel(layout, node.Mesh, DrawSystem.RenderMode.Transparency);
                    }

                    return(drawModel);
                }
                else
                {
                    return(null);
                }
            });

            entity.AddComponent(drawC);

            m_dbgModelEntity = entity;
        }
Beispiel #4
0
        /// <summary>
        /// Update component
        /// </summary>
        /// <param name="dT">spend time [sec]</param>
        public override void Update(double dT)
        {
            var cameraSys = CameraSystem.GetInstance();
            var drawSys   = DrawSystem.GetInstance();

            // Calc camera
            var viewHeadMat = cameraSys.GetCameraData().GetViewMatrix() * drawSys.GetDrawContext().GetHeadMatrix();

            viewHeadMat.Invert();
            var moveDirection = new Vector3(viewHeadMat.Backward.X, 0, viewHeadMat.Backward.Z);

            moveDirection.Normalize();

            var gameSys = GameSystem.GetInstance();

            switch (gameSys.Config.InputDevice)
            {
            case GameConfig.UserInputDevices.MouseKeyboard:
            {
                IMouseKeyboardInputSource src = InputSystem.GetInstance().MouseKeyboard;

                var v = Vector3.Zero;
                if (src.TestKeyState(Keys.W))
                {
                    v.Z += PositionFactor;
                }
                if (src.TestKeyState(Keys.A))
                {
                    v.X -= PositionFactor;
                }
                if (src.TestKeyState(Keys.D))
                {
                    v.X += PositionFactor;
                }
                if (src.TestKeyState(Keys.S))
                {
                    v.Z -= PositionFactor;
                }

                if (v.X != 0 || v.Z != 0)
                {
                    float angleY = (float)Math.Atan2(moveDirection.X, moveDirection.Z);
                    v = Vector3.Transform(v, Matrix3x3.RotationY(angleY));
                    m_behaviorC.RequestMove(v);
                    m_behaviorC.RequestTurn(v);
                }
            }
            break;

            case GameConfig.UserInputDevices.Pad:
            {
                IPadInputSource src = InputSystem.GetInstance().Pad;

                float angleY    = (float)Math.Atan2(moveDirection.X, moveDirection.Z);
                var   thumbDir  = src.LeftThumbInput.Direction;
                float magnitude = src.LeftThumbInput.NormalizedMagnitude;
                if (magnitude >= MinimumPadMagnitude)
                {
                    var v = new Vector3(thumbDir.X, 0, thumbDir.Y);
                    v = Vector3.Transform(v, Matrix3x3.RotationY(angleY));
                    v = v * magnitude;
                    m_behaviorC.RequestMove(v);
                    m_behaviorC.RequestTurn(v);
                }
            }
            break;

            default:
                Debug.Fail("unsupported input device type : " + gameSys.Config.InputDevice);
                break;
            }
        }
Beispiel #5
0
        static void Main()
        {
            bool bStereoRendering = false; // change to 'false' due to non-stereo rendering for debug
            int  multiThreadCount = 4;     // 1 is single thread

            HmdDevice hmd = null;

            try
            {
                // init oculus rift hmd system
                HmdSystem.Initialize();
                var hmdSys = HmdSystem.GetInstance();
                hmd = hmdSys.DetectHmd();
            }
            catch (Exception)
            {
                // failed to detect hmd
                hmd = null;
            }

#if !DEBUG
            var configForm = new ConfigForm(hmd);
            Application.Run(configForm);
            if (configForm.HasResult())
            {
                bStereoRendering = configForm.GetResult().UseHmd;
            }
            else
            {
                // cancel
                return;
            }
#endif
            Size resolution = new Size();
            if (!bStereoRendering)
            {
                //resolution.Width = 1920;// Full HD
                //resolution.Height = 1080;
                resolution.Width  = 1280;
                resolution.Height = 720;
            }
            else
            {
                hmd.ResetPose();
                resolution = hmd.Resolution;
            }

            var form = new MainForm();
            form.ClientSize = resolution;

            // Create Device & SwapChain
            var desc = new SwapChainDescription()
            {
                BufferCount     = 2,
                ModeDescription =
                    new ModeDescription(resolution.Width, resolution.Height, new Rational(0, 1), DrawSystem.GetRenderTargetFormat()),
                IsWindowed        = true,
                OutputHandle      = form.GetRenderTarget().Handle,
                SampleDescription = new SampleDescription(1, 0),
                SwapEffect        = SwapEffect.Sequential,
                Usage             = Usage.RenderTargetOutput,
                Flags             = SwapChainFlags.AllowModeSwitch,
            };

            FeatureLevel[] levels =
            {
                FeatureLevel.Level_11_0
            };

            Device    device;
            SwapChain swapChain;
#if DEBUG
            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, levels, desc, out device, out swapChain);
#else
            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, levels, desc, out device, out swapChain);
#endif

            // Ignore all windows events
            var factory = swapChain.GetParent <Factory>();
            factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);

            DrawSystem.Initialize(form.GetRenderTarget().Handle, device, swapChain, hmd, bStereoRendering, multiThreadCount);
            InputSystem.Initialize(form.GetRenderTarget());
            EntitySystem.Initialize();
            MapSystem.Initialize();
            ChrSystem.Initialize();
            CameraSystem.Initialize();
            CullingSystem.Initialize();
            GameSystem.Initialize();

            GameSystem.GetInstance().Config.IsUseHmd = bStereoRendering;
            var scene = new Scene(device, swapChain, form.GetRenderTarget(), hmd, bStereoRendering, multiThreadCount);
            RenderLoop.Run(form, () => { scene.RenderFrame(); });
            scene.Dispose();

            // Release
            GameSystem.Dispose();
            CullingSystem.Dispose();
            CameraSystem.Dispose();
            ChrSystem.Dispose();
            MapSystem.Dispose();
            EntitySystem.Dispose();
            InputSystem.Dispose();
            DrawSystem.Dispose();
            device.Dispose();
            swapChain.Dispose();
            HmdSystem.Dispose();
        }
Beispiel #6
0
 static public void Initialize()
 {
     s_singleton = new CameraSystem();
 }
        /// <summary>
        /// Update component
        /// </summary>
        /// <param name="dT">spend time [sec]</param>
        public override void Update(double dT)
        {
            var mapSys = MapSystem.GetInstance();

            m_coroutine.Update(dT);

            if (!m_coroutine.HasCompleted())
            {
                // wait for end of character operation
                return;
            }

            var cameraSys = CameraSystem.GetInstance();
            var drawSys   = DrawSystem.GetInstance();

            var gameSys = GameSystem.GetInstance();

            switch (gameSys.Config.InputDevice)
            {
            case GameConfig.UserInputDevices.MouseKeyboard:
            {
                IMouseKeyboardInputSource src = InputSystem.GetInstance().MouseKeyboard;

                var v = Vector3.Zero;
                if (src.TestKeyState(Keys.W))
                {
                    v.Z += PositionFactor;
                }
                if (src.TestKeyState(Keys.A))
                {
                    v.X -= PositionFactor;
                }
                if (src.TestKeyState(Keys.D))
                {
                    v.X += PositionFactor;
                }
                if (src.TestKeyState(Keys.S))
                {
                    v.Z -= PositionFactor;
                }

                if (v.X != 0 || v.Z != 0)
                {
                    // @todo
                }
            }
            break;

            case GameConfig.UserInputDevices.Pad:
            {
                IPadInputSource src = InputSystem.GetInstance().Pad;

                // update move
                {
                    _InputType inputType = _InputType.None;

                    var   thumbDir  = src.LeftThumbInput.Direction;
                    float magnitude = src.LeftThumbInput.NormalizedMagnitude;
                    if (magnitude >= MinimumPadMagnitude)
                    {
                        // use pad stick
                        if (thumbDir.Y <= -0.851)
                        {
                            inputType = _InputType.Backward;
                        }
                        else if (thumbDir.Y >= 0.851)
                        {
                            inputType = _InputType.Forward;
                        }
                        else
                        {
                            if (thumbDir.X < 0)
                            {
                                inputType = _InputType.Left;
                            }
                            else
                            {
                                inputType = _InputType.Right;
                            }
                        }
                    }
                    else
                    {
                        // use pad cross key
                        if (src.TestButtonState(InputSystem.PadButtons.Down))
                        {
                            inputType = _InputType.Backward;
                        }
                        else if (src.TestButtonState(InputSystem.PadButtons.Up))
                        {
                            inputType = _InputType.Forward;
                        }
                        else if (src.TestButtonState(InputSystem.PadButtons.Left))
                        {
                            inputType = _InputType.Left;
                        }
                        else if (src.TestButtonState(InputSystem.PadButtons.Right))
                        {
                            inputType = _InputType.Right;
                        }
                    }

#if true
                    switch (inputType)
                    {
                    case _InputType.Forward:
                    {
                        var         nextDir      = MapLocation.GetForwardDirection(m_currentLocation.Direction);
                        MapLocation?nextLocation = mapSys.Walk(m_currentLocation, nextDir);
                        if (nextLocation.HasValue)
                        {
                            m_currentLocation = nextLocation.Value;
                            var pose = mapSys.GetPose(m_currentLocation);
                            m_coroutine.Start(new _MoveToTask(this, pose.TranslationVector));                                                            // no turn
                        }
                    }
                    break;

                    case _InputType.Backward:
                    {
                        var nextDir = MapLocation.GetBackwardDirection(m_currentLocation.Direction);
                        m_currentLocation.Direction = nextDir;
                        var pose = mapSys.GetPose(m_currentLocation);
                        m_coroutine.Start(new _TurnToTask(this, pose.Forward));
                    }
                    break;

                    case _InputType.Left:
                    {
                        var nextDir = MapLocation.GetLeftDirection(m_currentLocation.Direction);
                        m_currentLocation.Direction = nextDir;
                        var pose = mapSys.GetPose(m_currentLocation);
                        m_coroutine.Start(new _TurnToTask(this, pose.Forward));
                    }
                    break;

                    case _InputType.Right:
                    {
                        var nextDir = MapLocation.GetRightDirection(m_currentLocation.Direction);
                        m_currentLocation.Direction = nextDir;
                        var pose = mapSys.GetPose(m_currentLocation);
                        m_coroutine.Start(new _TurnToTask(this, pose.Forward));
                    }
                    break;
                    }
#else
                    switch (inputType)
                    {
                    case _InputType.Forward:
                    {
                        var         nextDir      = MapLocation.GetForwardDirection(m_currentLocation.Direction);
                        MapLocation?nextLocation = mapSys.Walk(m_currentLocation, nextDir);
                        if (nextLocation.HasValue)
                        {
                            m_currentLocation = nextLocation.Value;
                            var pose = mapSys.GetPose(m_currentLocation);
                            m_coroutine.Start(new _MoveToTask(this, pose.TranslationVector));                                                            // no turn
                        }
                    }
                    break;

                    case _InputType.Backward:
                    {
                        var         nextDir      = MapLocation.GetBackwardDirection(m_currentLocation.Direction);
                        MapLocation?nextLocation = mapSys.Walk(m_currentLocation, nextDir);
                        if (nextLocation.HasValue)
                        {
                            m_currentLocation = nextLocation.Value;
                            var pose = mapSys.GetPose(m_currentLocation);
                            m_coroutine.Start(Coroutine.Join(new _TurnToTask(this, pose.Forward), new _MoveToTask(this, pose.TranslationVector)));
                        }
                    }
                    break;

                    case _InputType.Left:
                    {
                        var         nextDir      = MapLocation.GetLeftDirection(m_currentLocation.Direction);
                        MapLocation?nextLocation = mapSys.Walk(m_currentLocation, nextDir);
                        if (nextLocation.HasValue)
                        {
                            m_currentLocation = nextLocation.Value;
                            var pose = mapSys.GetPose(m_currentLocation);
                            m_coroutine.Start(Coroutine.Join(new _TurnToTask(this, pose.Forward), new _MoveToTask(this, pose.TranslationVector)));
                        }
                    }
                    break;

                    case _InputType.Right:
                    {
                        var         nextDir      = MapLocation.GetRightDirection(m_currentLocation.Direction);
                        MapLocation?nextLocation = mapSys.Walk(m_currentLocation, nextDir);
                        if (nextLocation.HasValue)
                        {
                            m_currentLocation = nextLocation.Value;
                            var pose = mapSys.GetPose(m_currentLocation);
                            m_coroutine.Start(Coroutine.Join(new _TurnToTask(this, pose.Forward), new _MoveToTask(this, pose.TranslationVector)));
                        }
                    }
                    break;
                    }
#endif
                }
            }
            break;

            default:
                Debug.Fail("unsupported input device type : " + gameSys.Config.InputDevice);
                break;
            }
        }
Beispiel #8
0
        public void RenderFrame()
        {
            double dt = m_fps.GetDeltaTime();

            var drawSys    = DrawSystem.GetInstance();
            var cameraSys  = CameraSystem.GetInstance();
            var inputSys   = InputSystem.GetInstance();
            var entitySys  = EntitySystem.GetInstance();
            var mapSys     = MapSystem.GetInstance();
            var cullingSys = CullingSystem.GetInstance();

            // update fps
            {
                double avgDT = m_fps.GetAverageDeltaTime();
                string text  = String.Format("FPS:{0:f2}, DeltaTime:{1:f2}ms", 1.0 / avgDT, avgDT * 1000.0f);
                m_numberEntity.SetNumber(1.0f / (float)avgDT);
            }

            if (m_multiThreadCount > 1)
            {
                Task.WaitAll(m_taskList.ToArray());
                var tmpTaskResult = new List <CommandList>(m_taskResultList);

                inputSys.Update(dt);
                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.Input, dt);
                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.Behavior, dt);
                cameraSys.Update(dt);
                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.PostBehavior, dt);

                DrawSystem.WorldData worldData;
                worldData.AmbientColor     = new Color3(0.4f, 0.45f, 0.55f);
                worldData.FogColor         = new Color3(0.3f, 0.5f, 0.8f);
                worldData.NearClip         = 0.01f;
                worldData.FarClip          = 100.0f;
                worldData.DirectionalLight = new DrawSystem.DirectionalLightData()
                {
                    Direction = new Vector3(0.3f, -0.2f, 0.4f),
                    Color     = new Color3(0.6f, 0.6f, 0.5f),
                };
                worldData.Camera = cameraSys.GetCameraData();

                drawSys.BeginScene(worldData);
                var context = drawSys.GetDrawContext();


                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.Posing, dt);
                mapSys.Update(dt, context);
                cullingSys.UpdateFrustum();
                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.PreDraw, dt);
                drawSys.GetDrawBuffer().Process(drawSys.GetDrawContext());
                entitySys.UpdateComponents(GameEntityComponent.UpdateLines.Draw, dt);

                // start command list generation for the next frame
                m_taskList.Clear();
                m_taskResultList.Clear();
                m_taskResultList.AddRange(Enumerable.Repeat <CommandList>(null, m_multiThreadCount));
                m_accTime += dt;
                for (int threadIndex = 0; threadIndex < m_multiThreadCount; ++threadIndex)
                {
                    int resultIndex = threadIndex;

                    var subThreadContext = drawSys.GetSubThreadContext(threadIndex);
                    m_taskList.Add(Task.Run(() =>
                    {
                        // todo : do sub-thread task
                        m_taskResultList[resultIndex] = subThreadContext.FinishCommandList();
                    }));
                }

                foreach (var result in tmpTaskResult)
                {
                    context.ExecuteCommandList(result);
                }

                m_numberEntity.SetPose(ChrSystem.GetInstance().Player.FindComponent <LayoutComponent>().Transform);
                m_numberEntity.Draw(context);
                drawSys.EndScene();
            }
            else
            {
                // not supported
            }

            m_fps.EndFrame();
            m_fps.BeginFrame();
        }
Beispiel #9
0
        public Scene(Device device, SwapChain swapChain, Panel renderTarget, HmdDevice hmd, bool bStereoRendering, int multiThreadCount)
        {
            var drawSys = DrawSystem.GetInstance();
            var mapSys  = MapSystem.GetInstance();

            // load textures
            var textures = new List <TextureView>(new[]
            {
                TextureView.FromFile("dot", drawSys.D3D, "Image/dot.png"),
                TextureView.FromFile("floor", drawSys.D3D, "Image/floor.jpg"),
            });
            var numTextures = new DrawSystem.TextureData[10];

            for (int i = 0; i < 10; ++i)
            {
                var name = String.Format("number_{0}", i);
                numTextures[i] = new DrawSystem.TextureData
                {
                    Resource = TextureView.FromFile(name, drawSys.D3D, String.Format("Image/{0}.png", name)),
                    UvScale  = Vector2.One,
                };
            }
            textures.AddRange(numTextures.Select(item => item.Resource));
            foreach (var tex in textures)
            {
                drawSys.ResourceRepository.AddResource(tex);
            }

            // create number entity
            m_fps          = new FpsCounter();
            m_numberEntity = new NumberEntity(new NumberEntity.InitParam()
            {
                Dot = new DrawSystem.TextureData
                {
                    Resource = drawSys.ResourceRepository.FindResource <TextureView>("dot"),
                    UvScale  = Vector2.One,
                },
                Numbers = numTextures,
                Layout  = Matrix.RotationYawPitchRoll(1.0f, -1.5f, MathUtil.PI) * Matrix.Translation(-1.5f, 2.5f, -4.5f)
            });

            // create map
            mapSys.LoadResource();
            mapSys.CreateMap("Level/l9000.tmx");

            // create player
            m_player = new PlayerEntity();
            ChrSystem.GetInstance().Player = m_player;

            m_multiThreadCount = multiThreadCount;
            m_taskList         = new List <Task>(m_multiThreadCount);
            m_taskResultList   = new List <CommandList>(m_multiThreadCount);

            // other settings
#if DEBUG
            CameraSystem.GetInstance().ActivateCamera(CameraSystem.FollowEntityCameraName);
            //CameraSystem.GetInstance().ActivateCamera(CameraSystem.FixedCameraName);
            //CameraSystem.GetInstance().ActivateCamera(CameraSystem.FreeCameraName);
#else
            CameraSystem.GetInstance().ActivateCamera(CameraSystem.FollowEntityCameraName);
#endif // DEBUG
        }