Timer() публичный статический Метод

Performs timer opertations. Use the following commands: DirectXTimer.Reset - to reset the timer DirectXTimer.Start - to start the timer DirectXTimer.Stop - to stop (or pause) the timer DirectXTimer.Advance - to advance the timer by 0.1 seconds DirectXTimer.GetAbsoluteTime - to get the absolute system time DirectXTimer.GetApplicationTime - to get the current time DirectXTimer.GetElapsedTime - to get the time that elapsed between TIMER_GETELAPSEDTIME calls
public static Timer ( DirectXTimer command ) : float
command DirectXTimer
Результат float
Пример #1
0
        public void DrawGoo()
        {
            float CurrTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
            float fTime    = (float)(((CurrTime % 180.0f) / 180.0f) * (2 * Math.PI));

            WorldMatrix = DirectX.Matrix.RotationYawPitchRoll((float)((CurrTime % 240) / 240 * Math.PI), 0, 0) * DirectX.Matrix.Translation(0, -45, -400);

            DirectX.Matrix WorldViewMatrix     = WorldMatrix * ViewMatrix;
            DirectX.Matrix WorldViewProjMatrix = WorldMatrix * ViewMatrix * ProjectionMatrix;

            GooEffect.SetValue("fMixTime", fTime);
            GooEffect.SetValue("WorldView", WorldViewMatrix);
            GooEffect.SetValue("WorldViewProjection", WorldViewProjMatrix);

            GameDevice.RenderState.AlphaBlendEnable = false;
            int numPasses = GooEffect.Begin(0);

            for (int i = 0; i < numPasses; i++)
            {
                GooEffect.BeginPass(i);
                GooMesh.DrawSubset(0);
                GooEffect.EndPass();
            }
            GooEffect.End();

            // Restore alpha blend setting
            GameDevice.RenderState.AlphaBlendEnable = true;
        }
Пример #2
0
        //  The GameClass constructor.  Here we create, but not show, the GameSettings form.
        // The
        public GameClass(MainClass mainClass, Control owner)
        {
            gameState      = GameStates.Loading;
            this.owner     = owner;
            this.mainClass = mainClass;
            splash         = new SplashScreen(this);
            splash.ShowDialog();
            gameSettings          = new SpaceWar.GameSettings(this);
            gameSettings.Location = new Point(owner.Bounds.Right, owner.Bounds.Top);
            gravity        = gameSettings.Gravity;
            gameSpeed      = gameSettings.GameSpeed;
            bounceBack     = gameSettings.Bounce;
            inverseGravity = gameSettings.InverseGravity;
            blackHole      = gameSettings.BlackHole;

            localDevice = new Microsoft.DirectX.DirectDraw.Device();
            localDevice.SetCooperativeLevel(owner, Microsoft.DirectX.DirectDraw.CooperativeLevelFlags.Normal);

            DXUtil.Timer(DirectXTimer.Start);

            SpaceWar.RotatableShape.CreateShapes();

            input = new InputClass(this.owner);

            soundHandler = new SoundHandler(this.owner);

            try {
                netPeer = new PlayClass(this);
            }
            catch (DirectXException e) {
                MessageBox.Show(owner, e.ToString());
            }
        }
Пример #3
0
        private void Draw()
        {
            float   AppTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
            Vector3 campos  = new Vector3(80f * (float)Math.Cos(AppTime), 38, 80f * (float)Math.Sin(AppTime));

            if (camMode)
            {
                campos = new Vector3(0, 200, -30);
            }

            viewMatrix = Matrix.LookAtLH(campos, new Vector3(),
                                         new Vector3(0, 1, 0));
            Matrix worldViewProj = viewMatrix * projMatrix;

            // Update the effect's variables
            effect.SetValue(handle1, ambient);
            effect.SetValue(handle2, worldViewProj);
            effect.SetValue(handle3, new float[] { Terrain.size *0.5f *(float)Math.Sin(AppTime), 80, Terrain.size * 0.5f * (float)Math.Cos(AppTime) });

            // Begin rendering with the effect
            effect.Begin(0);
            // There's only one pass
            effect.BeginPass(0);
            t.Draw();
            effect.EndPass();
            effect.End();
        }
Пример #4
0
        public Explosion(Direct3D.Device NewDevice, DirectX.Vector3 NewPosition)
        {
            this.CurrDevice = NewDevice;

            this.ExplosionTexture = Direct3D.TextureLoader.FromFile(CurrDevice, GameConfig.Files.ExplosionPoint);
            this.LightTexture     = Direct3D.TextureLoader.FromFile(CurrDevice, GameConfig.Files.ExplosionLight);

            this.ExplosionPosition = NewPosition;

            this.Rand = new Random();

            this.UniversalGravity = .50f;
            this.ParticleCount    = 100;
            this.NeedsDelete      = false;

            this.Particles = new ArrayList();
            for (int i = 0; i < this.ParticleCount; i++)
            {
                Particles.Add(new Particle(this.UniversalGravity,
                                           ExplosionPosition,
                                           new DirectX.Vector3((float)(Rand.NextDouble() * 0.75f - 0.375f), (float)(Rand.NextDouble() * 0.5f - 0.1f), 0.0f),
                                           DXUtil.Timer(DirectXTimer.GetApplicationTime)));
            }
            ExplosionFlash      = new Flash(ExplosionPosition, DXUtil.Timer(DirectXTimer.GetApplicationTime));
            this.LastUpdateTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
        }
Пример #5
0
        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
        {
            if (device.Disposed)
            {
                return;
            }

            // Get elapsed time to calculate FPS
            ElapsedTime = DXUtil.Timer(DirectXTimer.GetElapsedTime);
            device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue, 1.0f, 0);

            device.BeginScene();

            Draw();

            // Drawing multiple lines of text on the same sprite is more efficient
            using (Sprite s = new Sprite(device))
            {
                s.Begin(SpriteFlags.AlphaBlend);
                int y = 5;
                font.DrawText(s, string.Format("FPS: {0}", ((int)(1f / ElapsedTime)).ToString()), new Rectangle(4, y, 0, 0), DrawTextFormat.NoClip, Color.FromArgb(64, 255, 255, 255));
                y += 22;
                font.DrawText(s, string.Format("Ambient light: {0}%", (int)(ambient * 100)), new Rectangle(4, y, 0, 0), DrawTextFormat.NoClip, Color.FromArgb(64, 255, 255, 255));
                s.End();
            }

            device.EndScene();

            device.Present();

            // The onPaint event must be called again
            this.Invalidate();
        }
Пример #6
0
 public SplashScreen(string filename, int nDuration)
 {
     image       = new Image(filename);
     m_StartTime = DXUtil.Timer(TIMER.GETABSOLUTETIME);
     m_EndTime   = m_StartTime + nDuration;
     m_vb        = new VertexBuffer(typeof(CustomVertex.TransformedTextured), 4,
                                    CGameEngine.Device3D, Usage.WriteOnly, CustomVertex.TransformedTextured.Format,
                                    Pool.Default);
 }
Пример #7
0
        public void Draw()
        {
            Particle tmpParticle;
            float    CurrTime;
            float    TimeDiff;

            if (this.Particles.Count < 1)
            {
                NeedsDelete = true;
            }
            CurrTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
            TimeDiff = CurrTime - LastUpdateTime;
            for (int i = 0; i < Particles.Count; i++)
            {
                tmpParticle = (Particle)Particles[i];
                tmpParticle.Velocities.Y -= tmpParticle.Gravity * TimeDiff;
                tmpParticle.Positions.X  += tmpParticle.Velocities.X * TimeDiff;
                tmpParticle.Positions.Y  += tmpParticle.Velocities.Y * TimeDiff;
                tmpParticle.Positions.Z  += tmpParticle.Velocities.Z * TimeDiff;

                if (CurrTime - tmpParticle.TimeCreated <= 1.5f)
                {
                    tmpParticle.Height = 1.5f * (1.5f - (CurrTime - tmpParticle.TimeCreated));
                    tmpParticle.Width  = 1.5f * (1.5f - (CurrTime - tmpParticle.TimeCreated));
                    tmpParticle.GenerateVerticies();
                }

                this.CurrDevice.Transform.World = DirectX.Matrix.RotationYawPitchRoll(0, 0, 0) * DirectX.Matrix.Translation(tmpParticle.Positions.X, tmpParticle.Positions.Y, tmpParticle.Positions.Z) * SpaceAndTime.ScaleStandard;
                this.CurrDevice.SetTexture(0, ExplosionTexture);
                CurrDevice.DrawUserPrimitives(Direct3D.PrimitiveType.TriangleStrip, 2, tmpParticle.Verticies);
                if (tmpParticle.Positions.Y < -2.0f)
                {
                    this.Particles.Remove(tmpParticle);
                }
            }
            if (CurrTime - ExplosionFlash.TimeCreated <= .25)
            {
                ExplosionFlash.Height = 256 * (CurrTime - ExplosionFlash.TimeCreated);
                ExplosionFlash.Width  = 256 * (CurrTime - ExplosionFlash.TimeCreated);
                ExplosionFlash.GenerateVerticies();
            }
            else
            {
                ExplosionFlash.Height = 0.0f;
                ExplosionFlash.Width  = 0.0f;
                ExplosionFlash.GenerateVerticies();
            }
            this.CurrDevice.Transform.World = DirectX.Matrix.RotationYawPitchRoll(0, 0, 0) * DirectX.Matrix.Translation(ExplosionFlash.Positions.X, ExplosionFlash.Positions.Y, ExplosionFlash.Positions.Z) * SpaceAndTime.ScaleStandard;
            this.CurrDevice.SetTexture(0, LightTexture);
            CurrDevice.DrawUserPrimitives(Direct3D.PrimitiveType.TriangleStrip, 2, ExplosionFlash.Verticies);
            this.LastUpdateTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
        }
Пример #8
0
    /// <summary>
    /// Called once per frame, the call is the entry point for 3d rendering. This
    /// function sets up render states, clears the viewport, and renders the scene.
    /// </summary>
    protected override void Render()
    {
        input.GetInputState();

        //Clear the backbuffer to a Blue color
        device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Gray, 1.0f, 0);
        //Begin the scene
        device.BeginScene();

        device.Lights[0].Enabled = true;

        // Setup the world, view, and projection matrices
        Matrix m = new Matrix();

        if (destination.Y != 0)
        {
            y += DXUtil.Timer(DirectXTimer.GetElapsedTime) * (destination.Y * 25);
        }

        if (destination.X != 0)
        {
            x += DXUtil.Timer(DirectXTimer.GetElapsedTime) * (destination.X * 25);
        }

        m  = Matrix.Translation(0.0f, 0.75f, 0.0f);
        m *= Matrix.RotationY(y);
        m *= Matrix.RotationX(x);

        device.Transform.World = m;
        // Render the teapot.
        teapot.DrawSubset(0);

        m  = new Matrix();
        m  = Matrix.Translation(0.0f, -0.75f, 0.0f);
        m *= Matrix.RotationY(y);
        m *= Matrix.RotationX(x);

        device.Transform.World = m;
        //render the box
        box.DrawSubset(0);

        device.Transform.View       = Matrix.LookAtLH(new Vector3(0.0f, 3.0f, -5.0f), new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f));
        device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, 1.0f, 1.0f, 100.0f);


        device.EndScene();
    }
Пример #9
0
        /// <summary>
        /// Do all the processing for this quadro before we render it
        /// </summary>
        private void processaProximoQuadro()
        {
            // Get the current elapsed time
            tempoDecorrido = DXUtil.Timer(DirectXTimer.GetElapsedTime);

            // Set the world matrix
            Matrix worldMatrix = Matrix.Translation(objetoCentro);

            device.Transform.World = worldMatrix;

            if (quadroRaiz.AnimationController != null)
            {
                quadroRaiz.AnimationController.AdvanceTime(tempoDecorrido, null);
            }

            quadro_AtualizarMatrizes((QuadroDerivado)quadroRaiz.FrameHierarchy, worldMatrix);
        } // processaProximoQuadro().fim
Пример #10
0
        /// <summary>
        /// Create the animation hierarchy for this file
        /// </summary>
        private void carregarModeloAnimado(string file, PresentParameters presentParams)
        {
            // Create our allocate hierarchy derived class
            HierarquiaAlojamento alloc = new HierarquiaAlojamento(this);

            // Load our file
            quadroRaiz = Mesh.LoadHierarchyFromFile(file, MeshFlags.Managed,
                                                    device, alloc, null);

            // Calculate the center and radius of a bounding sphere
            objetoRaio = Frame.CalculateBoundingSphere(quadroRaiz.FrameHierarchy,
                                                       out objetoCentro);

            // Setup the matrices for animation
            ossos_ConfigurarMatrizes((QuadroDerivado)quadroRaiz.FrameHierarchy);

            // Start the timer
            DXUtil.Timer(DirectXTimer.Start);
        } // carregarModeloAnimado().fim
Пример #11
0
        public GameWorld(MainForm _mainform)
        {
            //
            // TODO: Add constructor logic here
            //
            mainform = _mainform;

            DXUtil.Timer(DirectXTimer.Start);


            peer = new NETPlayer(this);

            if (peer.InSession)
            {
                if (peer.IsHost)
                {
                    timer.Tick    += new EventHandler(TimerEvent);
                    timer.Interval = 4500;
                    timer.Start();
                }
            }

            InitializeKeyboard();
        }
Пример #12
0
        public void DataReceived(object sender, ReceiveEventArgs rea)
        {
            int senderID = rea.Message.SenderID;

            byte        mType       = (byte)rea.Message.ReceiveData.Read(typeof(byte));
            MessageType messageType = (MessageType)mType;

            switch (messageType)
            {
            case MessageType.PlayerUpdateID:
            {
                PlayerUpdate update = (PlayerUpdate)rea.Message.ReceiveData.Read(typeof(PlayerUpdate));

                rea.Message.ReceiveData.Dispose();

                lock (otherPlayers)
                {
                    object playerObject = otherPlayers[senderID];
                    if (null == playerObject)
                    {
                        return;
                    }
                    RemotePlayer player = (RemotePlayer)playerObject;

                    player.Position   = update.position;
                    player.Velocity   = update.velocity;
                    player.UpdateTime = DateTime.Now;
                    player.Active     = true;

                    otherPlayers[senderID] = player;
                }

                break;
            }


            case MessageType.GameTime:
            {
                float stime = (float)rea.Message.ReceiveData.Read(typeof(float));

                rea.Message.ReceiveData.Dispose();

                serverTime = stime - DXUtil.Timer(DirectXTimer.GetApplicationTime);

                break;
            }

            case MessageType.GameChat:
            {
                MessageUpdate update = (MessageUpdate)rea.Message.ReceiveData.Read(typeof(MessageUpdate));

                string s = "";

                s += rea.Message.ReceiveData.ReadString();

                rea.Message.ReceiveData.Dispose();

                lock (otherPlayers)
                {
                    object playerObject = otherPlayers[senderID];
                    if (null == playerObject)
                    {
                        return;
                    }
                    RemotePlayer player = (RemotePlayer)playerObject;

                    mainform.textBox2.Text += player.ToString() + s + "\r\n";
                }

                break;
            }
            }
        }
Пример #13
0
        unsafe private void CheckTimer(object aCpuNo)
        {
            CheckResults ThreadSummary = new CheckResults();

            ThreadSummary.TimerResolution     = 0;
            ThreadSummary.StopwatchResolution = 0;

            try
            {
                try
                {
                    short currentCpu = (short)aCpuNo;
                    SetThreadAffinityMask(GetCurrentThread(), new IntPtr(1 << currentCpu));

                    float MpAccuracy = DXUtil.Timer(DirectXTimer.GetAbsoluteTime);
                    MpAccuracy = DXUtil.Timer(DirectXTimer.GetAbsoluteTime) - MpAccuracy;

                    Stopwatch TimerWatch = new Stopwatch();
                    TimerWatch.Start();
                    TimerWatch.Stop();
                    double NetAccuracyMs     = ((double)TimerWatch.ElapsedTicks / (double)Stopwatch.Frequency) * 1000;
                    string NetAccuracyResult = NetAccuracyMs.ToString("N5");

                    long TicksPerSec = 0;
                    if (!QueryPerformanceFrequency(ref TicksPerSec))
                    {
                        MessageBox.Show("This system does not support accurate timing!");
                        return;
                    }

                    long   TempTime  = 0;
                    double StartTime = 0;

                    QueryPerformanceCounter(ref TempTime);
                    // we neglect the overhead of these assignments in between..
                    StartTime = TempTime;
                    QueryPerformanceCounter(ref TempTime);

                    // The timespan between two timer results in ms
                    double SysAccuracyMs     = ((TempTime - StartTime) / TicksPerSec) * 1000;
                    string SysAccuracyResult = SysAccuracyMs.ToString("N5");

                    if (SysAccuracyMs < fMaxAccuracy)
                    {
                        fMaxAccuracy = SysAccuracyMs;
                    }

                    ThreadSummary.ResultOutput        = string.Format("CPU {0}: Ticks per second: {1} / MP accuracy: {2} / .NET accuracy: {3} / Approx. accurary in ms: {4}", currentCpu, TicksPerSec, MpAccuracy, NetAccuracyResult, SysAccuracyResult);
                    ThreadSummary.TimerResolution     = SysAccuracyMs;
                    ThreadSummary.StopwatchResolution = NetAccuracyMs;

                    Thread.Sleep(0);
                }
                catch (ThreadAbortException tae) { ThreadSummary.ResultOutput = tae.Message; }
                catch (ThreadStateException tse) { ThreadSummary.ResultOutput = tse.Message; }

                // Let the GUI thread add our result to the listbox
                Invoke(new MethodListViewItems(ThreadedListItemAdder), new object[] { ThreadSummary });
            }
            catch (Exception) { }
        }
Пример #14
0
        public void MainLoop()
        {
            float minFrameTime = gameSettings.GameSpeed * 0.005f;

            if (lastFrameTime < minFrameTime)
            {
                lastFrameTime += DXUtil.Timer(DirectXTimer.GetElapsedTime);
                return;
            }
            lastFrameTime = 0.0f;
            try {
                if (gameState == GameStates.Paused)
                {
                    Word paused = new Word("PAUSED", Constants.LetterSize * 1.5f);
                    paused.Draw(surfaceSecondary, Color.White.ToArgb(),
                                Constants.LetterSpacing * 2,
                                new Point(windowBounds.Left + 50, windowBounds.Top + 50));
                    surfacePrimary.Draw(surfaceSecondary, DrawFlags.DoNotWait);
                }
                // Clear the ship's sound flags
                ship.Sounds = (Sounds)0;

                // process input
                HandleKeys();


                if (gameState != GameStates.Running)
                {
                    return;
                }

                surfaceSecondary.ColorFill(Color.Black);
                surfaceSecondary.DrawWidth = 1;

                // update my position, and tell others about it...
                ship.UpdatePosition();

                // update my state, and draw myself...
                ship.UpdateState();

                //If there are other players, send them our ship info
                if (netPeer.InSession && otherPlayers.Count > 0)
                {
                    SendMyPlayerUpdate();
                }

                WriteScores();
                stars.Draw(surfaceSecondary);

                int shipColor = Color.White.ToArgb();
                int shotColor = Color.White.ToArgb();
                ship.Draw(surfaceSecondary, shipColor, shotColor);

                // Handle other ships
                // walk through all other players. For each player
                // 1) draw the ship
                // 2) check to see whether the other ship has killed us
                // 3) figure the score
                // 4) see if we need to time-out this ship
                int      shipIndex       = 0;
                Sounds   otherShipSounds = (Sounds)0;
                DateTime now             = DateTime.Now;
                lock (otherPlayers) {
                    foreach (RemotePlayer player in otherPlayers.Values)
                    {
                        if (!player.Active)
                        {
                            continue;
                        }

                        player.Ship.Draw(surfaceSecondary, shipColors[shipIndex].ToArgb(), shotColor);
                        shipIndex = (shipIndex + 1) % shipColors.Length;
                        ship.TestShip(player);
                        otherShipSounds |= player.Ship.Sounds;

                        // if we haven't gotten an update in a while,
                        // mark the player as inactive...
                        TimeSpan delta = now - player.UpdateTime;
                        if (delta.Seconds > Constants.RemoteTickTimeout)
                        {
                            player.Active = false;
                        }
                    }
                }

                // Draw the sun only if the "Black Hole" option isn't enabled
                if (!blackHole)
                {
                    sun.Draw(surfaceSecondary);
                }

                surfacePrimary.Draw(surfaceSecondary, DrawFlags.DoNotWait);
                PlaySounds(otherShipSounds);
            }

            catch (SurfaceLostException) {
                // The surface can be lost if power saving
                // mode kicks in, or any other number of reasons.
                CreateSurfaces();
            }
        }
Пример #15
0
 public void StartZero()
 {
     _isRunning = true;
     _startTime = (uint)(DXUtil.Timer(DirectXTimer.GetAbsoluteTime) * 1000.0);
 }
Пример #16
0
 private void TimerEvent(Object myObject, EventArgs myEventArgs)
 {
     peer.SendTimeUpdate(DXUtil.Timer(DirectXTimer.GetApplicationTime));
 }
Пример #17
0
        public void Loop()
        {
            float minFrameTime = Speed * 0.005f;

            if (lastFrameTime < minFrameTime)
            {
                lastFrameTime += DXUtil.Timer(DirectXTimer.GetElapsedTime);
                return;
            }

            // read input

            ReadKeyboard();


            if (appTime - appTimeOld > 0.1)
            {
                appTimeOld = appTime;
                if (peer.InSession && otherPlayers.Count > 0)
                {
                    SendMyPlayerUpdate();
                }
            }

            DateTime now = DateTime.Now;

            lock (otherPlayers)
            {
                foreach (RemotePlayer player in otherPlayers.Values)
                {
                    if (!player.Active)
                    {
                        continue;
                    }

                    TimeSpan delta = now - player.UpdateTime;
                    if (delta.Seconds > RemoteTickTimeout)
                    {
                        player.Active = false;
                    }
                }
            }

            // compute all
            if (peer.InSession)
            {
                if (peer.IsHost)
                {
                    appTime = DXUtil.Timer(DirectXTimer.GetApplicationTime);
                }
                else
                {
                    appTime = DXUtil.Timer(DirectXTimer.GetApplicationTime) + serverTime;
                }
            }

            mainform.Text = "" + appTime;

            Update(appTime);

            // network respond

            // render

            // me
            mainform.clear();
            mainform.setDot(position);

            // others
            lock (otherPlayers)
            {
                foreach (RemotePlayer player in otherPlayers.Values)
                {
                    if (!player.Active)
                    {
                        continue;
                    }
                    mainform.setDot(player.Position);
                }
            }
            lastFrameTime = 0.0f;
        }
Пример #18
0
        private bool _paused;        // is timer paused?


        // --------------------------------------------------------------------
        // Returns absolute system time; static; requires no timer objects
        // --------------------------------------------------------------------
        public static float Now()
        {
            return(DXUtil.Timer(DirectXTimer.GetAbsoluteTime));
        }
Пример #19
0
        public bool Render()
        {
            try
            {
                bool fog_state = CGameEngine.Device3D.RenderState.FogEnable;

                CGameEngine.Device3D.RenderState.FogEnable = false;

                CustomVertex.TransformedTextured[] data = new CustomVertex.TransformedTextured[4];
                data[0].X  = 0.0f;
                data[0].Y  = 0.0f;
                data[0].Z  = 0.0f;
                data[0].Tu = 0.0f;
                data[0].Tv = 0.0f;
                data[1].X  = CGameEngine.Device3D.Viewport.Width;
                data[1].Y  = 0.0f;
                data[1].Z  = 0.0f;
                data[1].Tu = 1.0f;
                data[1].Tv = 0.0f;
                data[2].X  = 0.0f;
                data[2].Y  = CGameEngine.Device3D.Viewport.Height;
                data[2].Z  = 0.0f;
                data[2].Tu = 0.0f;
                data[2].Tv = 1.0f;
                data[3].X  = CGameEngine.Device3D.Viewport.Width;
                data[3].Y  = CGameEngine.Device3D.Viewport.Height;
                data[3].Z  = 0.0f;
                data[3].Tu = 1.0f;
                data[3].Tv = 1.0f;

                m_vb.SetData(data, 0, 0);

                CGameEngine.Device3D.SetStreamSource(0, m_vb, 0);
                CGameEngine.Device3D.VertexFormat = CustomVertex.TransformedTextured.Format;

                // Set the texture
                CGameEngine.Device3D.SetTexture(0, image.GetTexture());

                // Render the face
                CGameEngine.Device3D.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);

                CGameEngine.Device3D.RenderState.FogEnable = fog_state;
            }
            catch (DirectXException d3de)
            {
                Console.AddLine("Unable to display SplashScreen ");
                Console.AddLine(d3de.ErrorString);
            }
            catch (Exception e)
            {
                Console.AddLine("Unable to display SplashScreen ");
                Console.AddLine(e.Message);
            }

            // check for timeout
            float fCurrentTime = DXUtil.Timer(TIMER.GETABSOLUTETIME);

            fTimeLeft = m_EndTime - fCurrentTime;

            return(fCurrentTime > m_EndTime);
        }