Laden...

Bitmap in die DirectX laden

Erstellt von DSS vor 4 Jahren Letzter Beitrag vor 4 Jahren 2.152 Views
D
DSS Themenstarter:in
11 Beiträge seit 2012
vor 4 Jahren
Bitmap in die DirectX laden

Bei der Ausführung dieses Beispiel, fehlt mir das passende Bitmap. http://www.riemers.net/eng/Tutorials/DirectX/Csharp/Series1/tut10.php
Welches Format muss das Bitmap haben, ich selbst habe ein 64x64 Pixel Bitmap erstellt und dies mit der Software geladen. Nun ergibt sich ein > Fehlermeldung:

Über das Ende des Streams hinaus kann nicht gelesen werden .
Der Fehler befindet sich im "LoadHeightData"
Wie gross muss das Bitmap sein? Oder doch was im Code falsch?
Vielen Dank für die Hilfe.

Der Code:


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using System.IO;
using Microsoft.DirectX.DirectInput;

namespace TestDirectXTerrain3
{
    public partial class Form1 : Form
    {
        private int WIDTH = 64;
        private int HEIGHT = 64;
        private Microsoft.DirectX.Direct3D.Device device;
        //private System.ComponentModel.Container components = null;        
        private float angle = 0f;
        private CustomVertex.PositionColored[] vertices;
        private int[,] heightData;
        private int[] indices;
        private IndexBuffer ib;
        private VertexBuffer vb;

        private Microsoft.DirectX.DirectInput.Device keyb;

        public Form1()
        {
            InitializeComponent();
            InitializeComponent();
            LoadHeightData();
            InitializeDevice();
            CameraPositioning();
            VertexDeclaration();
            IndicesDeclaration();
            InitializeKeyboard();

            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
        }

        public void InitializeDevice()
        {
            PresentParameters presentParams = new PresentParameters();
            presentParams.Windowed = true;
            presentParams.SwapEffect = SwapEffect.Discard;
            device = new Microsoft.DirectX.Direct3D.Device(0, Microsoft.DirectX.Direct3D.DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
            device.RenderState.FillMode = FillMode.WireFrame;
            device.RenderState.CullMode = Cull.None;
        }

        private void CameraPositioning()
        {
            device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, this.Width / this.Height, 1f, 150f);
            device.Transform.View = Matrix.LookAtLH(new Vector3(0, -40, 50), new Vector3(0, -5, 0), new Vector3(0, 1, 0));

            //device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, this.Width / this.Height, 1f, 50f);
            //device.Transform.View = Matrix.LookAtLH(new Vector3(0, 0, 15), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
            device.RenderState.Lighting = false;
            device.RenderState.CullMode = Cull.None;
        }

        private void VertexDeclaration()
        {
            vb = new VertexBuffer(typeof(CustomVertex.PositionColored), WIDTH * HEIGHT, device, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColored.Format, Pool.Default);
            vertices = new CustomVertex.PositionColored[WIDTH * HEIGHT];

            for (int x = 0; x < WIDTH; x++)
            {

                for (int y = 0; y < HEIGHT; y++)
                {
                    vertices[x + y * WIDTH].Position = new Vector3(x, y, heightData[x, y]);
                    vertices[x + y * WIDTH].Color = Color.White.ToArgb();
                }
            }

            vb.SetData(vertices, 0, LockFlags.None);
        }

        private void IndicesDeclaration()
        {
            ib = new IndexBuffer(typeof(int), (WIDTH - 1) * (HEIGHT - 1) * 6, device, Usage.WriteOnly, Pool.Default);
            indices = new int[(WIDTH - 1) * (HEIGHT - 1) * 6];

            for (int x = 0; x < WIDTH - 1; x++)
            {

                for (int y = 0; y < HEIGHT - 1; y++)
                {
                    indices[(x + y * (WIDTH - 1)) * 6] = (x + 1) + (y + 1) * WIDTH;
                    indices[(x + y * (WIDTH - 1)) * 6 + 1] = (x + 1) + y * WIDTH;
                    indices[(x + y * (WIDTH - 1)) * 6 + 2] = x + y * WIDTH;

                    indices[(x + y * (WIDTH - 1)) * 6 + 3] = (x + 1) + (y + 1) * WIDTH;
                    indices[(x + y * (WIDTH - 1)) * 6 + 4] = x + y * WIDTH;
                    indices[(x + y * (WIDTH - 1)) * 6 + 5] = x + (y + 1) * WIDTH;
                }
            }
            ib.SetData(indices, 0, LockFlags.None);
        }

        private void LoadHeightData()
        {
            int offset;
            byte dummy;

            FileStream fs = new FileStream("dss1.bmp", FileMode.Open, FileAccess.Read);
            BinaryReader r = new BinaryReader(fs);

            for (int i = 0; i < 10; i++)
            {
                dummy = r.ReadByte();
            }

            offset = r.ReadByte();
            offset += r.ReadByte() * 256;
            offset += r.ReadByte() * 256 * 256;
            offset += r.ReadByte() * 256 * 256 * 256;

            for (int i = 0; i < 4; i++)
            {
                dummy = r.ReadByte();
            }

            WIDTH = r.ReadByte();
            WIDTH += r.ReadByte() * 256;
            WIDTH += r.ReadByte() * 256 * 256;
            WIDTH += r.ReadByte() * 256 * 256 * 256;

            HEIGHT = r.ReadByte();
            HEIGHT += r.ReadByte() * 256;
            HEIGHT += r.ReadByte() * 256 * 256;
            HEIGHT += r.ReadByte() * 256 * 256 * 256;

            heightData = new int[WIDTH, HEIGHT];
            for (int i = 0; i < (offset - 26); i++)
            {
                dummy = r.ReadByte();
            }

            for (int i = 0; i < HEIGHT; i++)
            {
                for (int y = 0; y < WIDTH; y++)
                {
                    int height = (int)(r.ReadByte());
                    height += (int)(r.ReadByte());
                    height += (int)(r.ReadByte());
                    height /= 8;
                    heightData[WIDTH - 1 - y, HEIGHT - 1 - i] = height;
                }
            }

        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            device.Clear(ClearFlags.Target, Color.DarkSlateBlue, 1.0f, 0);

            device.BeginScene();
            device.VertexFormat = CustomVertex.PositionColored.Format;
            device.SetStreamSource(0, vb, 0);
            device.Indices = ib;

            //device.Transform.World = Matrix.Translation(-HEIGHT / 2, -WIDTH / 2, 0);
            device.Transform.World = Matrix.Translation(-HEIGHT / 2, -WIDTH / 2, 0) * Matrix.RotationZ(angle);            
            device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, WIDTH * HEIGHT, 0, indices.Length / 3);
            device.EndScene();

            device.Present();

            this.Invalidate();
            //angle += 0.05f;
            ReadKeyboard();
        }

        public void InitializeKeyboard()
        {
            keyb = new Microsoft.DirectX.DirectInput.Device(SystemGuid.Keyboard);
            keyb.SetCooperativeLevel(this, CooperativeLevelFlags.Background | CooperativeLevelFlags.NonExclusive);
            keyb.Acquire();
        }

        private void ReadKeyboard()
        {
            KeyboardState keys = keyb.GetCurrentKeyboardState();
            if (keys[Key.Delete])
            {
                angle += 0.03f;
            }
            if (keys[Key.Next])
            {
                angle -= 0.03f;
            }
        }
    }
}

W
955 Beiträge seit 2010
vor 4 Jahren

Hi,
in dem von dir verlinkten Beitrag befinden sich mehrere Kommentare die auf denselben Fehler hinweisen. Möglicherweise ist der Code inkorrekt. Benutze also den Debugger oder verwende ein anderes Beispiel um das Bitmap auszulesen.

T
2.219 Beiträge seit 2008
vor 4 Jahren

Eine mögliche Alternative wäre es auch, dass du die Grafik direkt als Image einlädst und dann direkt über die Properties die Height/Width ausliest.
Wäre vermutlich sinnvoller als die Lösung selbst basteln zu wollen.

Link:
https://docs.microsoft.com/de-de/dotnet/api/system.drawing.image?view=netframework-4.8

Nachtrag:
Du rufst im Konstruktur auch gleich zweimal InitializeComponent auf.
Das müsstest du einmal korrigieren, hier reicht ein aufruf.

T-Virus

Developer, Developer, Developer, Developer....

99 little bugs in the code, 99 little bugs. Take one down, patch it around, 117 little bugs in the code.

5.657 Beiträge seit 2006
vor 4 Jahren

.NET bietet dir Funktionen, um Bitmaps in ein Array zu laden. Hier gibt es ein Beispiel: Bitmap.LockBits. Du muß also nicht eine BMP-Datei Byte für Byte einlesen.

Wenn du es doch machst, dann mußt du sicherstellen, daß die Datei im richtigen Format gespeichert wurde, also hier RGB.

Du kannst auch den Debugger verwenden, um sehen zu können, was da genau passiert, und woher der Fehler kommt: [Artikel] Debugger: Wie verwende ich den von Visual Studio?

Weeks of programming can save you hours of planning