Esporta (0) Stampa
Espandi tutto

Procedura: utilizzare gli sprite

È possibile utilizzare sprite per disegnare immagini e testo sullo schermo. In questo esempio vengono illustrate operazioni di disegno e rendering.

Nel form per questo esempio di codice sono presenti gli oggetti seguenti:

In questo esempio di codice viene caricata una texture da un file per creare lo sprite. Sarà necessario includere una piccola bitmap nel progetto da distribuire al dispositivo o all'emulatore.

Nel costruttore del form vengono specificate le impostazioni per la proprietà PresentationParameters del dispositivo, viene creato un oggettoDevice e viene chiamato il metodo Reset del dispositivo. Viene inoltre costruito un oggetto Font.

Nella tabella seguente vengono descritti metodi di esempio per il rendering dello sprite.

NotaNota

Le applicazioni Direct3D Mobile gestite richiedono il software Windows Mobile versione 5.0 per Pocket PC e Smartphone. Per informazioni sul software Windows Mobile e sugli SDK, vedere Risorse esterne per .NET Compact Framework.

Metodo Azioni

OnDeviceReset

  • Carica una texture da un file bitmap.

OnPaint

  1. Inizia la scena.

  2. Specifica flag SpriteFlags. Per ulteriori informazioni, vedere la sezione Programmazione efficiente più avanti in questo argomento.

  3. Disegna sprite e testo sullo schermo.

  4. Termina la scena.

Esempio

Nel codice di esempio seguente è incluso un form completo per disegnare uno sprite utilizzando una bitmap specificata.


class Sprites : Form
{
    // The objects that will be used to show
    // the uses of the Sprite class
    private Device device;
    private Microsoft.WindowsMobile.DirectX.Direct3D.Font d3dFont;
    private Sprite sprite;
    private Texture texture;

    public Sprites()
    {
        PresentParameters present;
        System.Drawing.Font gdiFont;

        this.Text = "Using Sprites";

        // Give the application a way to be closed.
        // This must be done before the device is created
        // as it will cause the hwnd of the Form to change.
        this.MinimizeBox = false;

        present = new PresentParameters();
        present.Windowed = true;
        present.SwapEffect = SwapEffect.Discard;

        device = new Device(0, DeviceType.Default, this,
            CreateFlags.None, present);
        device.DeviceReset += new EventHandler(OnDeviceReset);

        // Construct a new Sprite.
        // Sprites do not need to be recreated
        // when a device is reset.
        sprite = new Sprite(device);

        gdiFont = new System.Drawing.Font
            (FontFamily.GenericSansSerif,
        10.0f, FontStyle.Regular);

        // Construct a new font. Fonts do not need
        // to be recreated when a device is reset.
        d3dFont= new Microsoft.WindowsMobile.DirectX.Direct3D.Font
            (device, gdiFont);

        OnDeviceReset(null, EventArgs.Empty);
    }

    private void OnDeviceReset(object sender, EventArgs e)
    {
        // Textures must be recreated whenever a device is reset
        // no matter what pool they are created in.
        texture = TextureLoader.FromFile(device, "image.bmp");
    }

    protected override void OnPaintBackground(PaintEventArgs e)
    {
        // Do nothing.
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        // Begin the scene and clear the back buffer to black
        device.BeginScene();
        device.Clear(ClearFlags.Target, Color.Black, 1.0f, 0);

        // When using sprites it is important to
        // specify sprite flags passed to Sprite.Begin

        sprite.Begin(SpriteFlags.SortTexture | SpriteFlags.AlphaBlend);

        // Draw an image to the screen using Sprite.Draw

        int spriteY = 5;

        sprite.Draw(texture, Vector3.Empty, new Vector3(0,
            spriteY, 0),
            Color.White.ToArgb());
        spriteY += texture.GetLevelDescription(0).Height + 5;

        // Draw a portion of an image to the screen
        // using Sprite.Draw. This shall be drawn such
        // that the image is modulated with the color green.

        sprite.Draw(texture, new Rectangle(4, 4, 24, 24),
            Vector3.Empty,
            new Vector3(0, spriteY, 0), Color.Green);

        spriteY+= 30;

        // Draw text to the screen. Using a sprite to draw text
        // to the  screen is essential for good performance.
        // Otherwise the font object will perform a
        // Sprite.Begin/Sprite.End internally for
        // each call to Font.DrawText. This can cause severe
        // performance problems.

        spriteY = 150;

        d3dFont.DrawText(sprite, "This is text.",
            5, spriteY, Color.Red);
        spriteY += d3dFont.Description.Height + 5;

        d3dFont.DrawText(sprite, "This is another line of text.",
            5, spriteY, Color.Green);
        spriteY += d3dFont.Description.Height + 5;

        d3dFont.DrawText(sprite, "Only one call to Sprite.Begin.",
            5, spriteY, Color.Blue);

        // End drawing using this sprite. This will cause the
        // sprites to be flushed to the graphics driver and will
        // reset the transformation matrices, textures states,
        // and renderstates if the SpriteFlags specified in Begin
        // call for that to happen.
        sprite.End();

        // Finish the scene and present it on the screen.
        device.EndScene();
        device.Present();
    }

    static void Main()
    {
        Application.Run(new Sprites());
    }
}

Compilazione del codice

In questo esempio sono richiesti riferimenti agli spazi dei nomi seguenti:

Programmazione efficiente

Creare sprite e caratteri nel costruttore del form in modo che non sia necessario ricrearli quando si reimposta il dispositivo.

Per prestazioni ottimali, utilizzare uno sprite per disegnare testo. In caso contrario l'oggetto Font esegue internamente i metodi Begin eEnd dello sprite per ogni chiamata a DrawText.

Se possibile, l'utilizzo di uno sprite per singoli frame dovrebbe essere contenuto in una chiamata ai metodiBegin e End per uno sprite.

Specificare i seguenti valori SpriteFlags per ottimizzare il rendering e migliorare le prestazioni:

  • SortTexture consente di ordinare immagini prima di disegnare sullo schermo in modo da consentire un passagio tra texture più veloce.

  • AlphaBlend consente di eseguire correttamente il rendering dei caratteri, specialmente per sprite con aree trasparenti o traslucide.

  • SortDepthBackToFront consente di ordinare gli sprite a partire da quello in primo piano. Risulta utile in presenza di più sprite traslucidi o trasparenti che devono essere sovrapposti.

  • DoNotSaveState consente di migliorare le prestazioni di applicazioni per le quali non è possibile utilizzare stati di rendering non specificati.

  • DoNotModifyRenderState consente di ottimizzare le prestazioni utilizzando lo stato di rendering corrente e può essere utilizzata per effetti speciali.

  • ObjectSpace e Billboard consentono di disegnare immagini con effetti speciali diversi.

Vedere anche

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft