Archief - [PROG][C#] Managed Directx Depth buffer.

Het archief is een bevroren moment uit een vorige versie van dit forum, met andere regels en andere bazen. Deze posts weerspiegelen op geen enkele manier onze huidige ideeën, waarden of wereldbeelden en zijn op sommige plaatsen gecensureerd wegens ontoelaatbaar. Veel zijn in een andere tijdsgeest gemaakt, al dan niet ironisch - zoals in het ironische subforum Off-Topic - en zouden op dit moment niet meer gepost (mogen) worden. Toch bieden we dit archief nog graag aan als informatiedatabank en naslagwerk. Lees er hier meer over of start een gesprek met anderen.

MacK

Legacy Member
Hoi,
ik heb dus een prob met m'n terrein-weergave-applicatie (kortom ik probeer een beetje een 3d terrein weer te geven).

Nu, alles lukt, ik kan terreindata inlezen (hoogte), en in wireframe geeft hij een heel mooi beeld. Maar wanneer ik alles solid weergeef (dus ook textured) , dan is er iets 'mis' .. Je ziet het gebergte enzo, maar hij tekent dingen dingen die 'achter' de berg staan en daardoor lijkt het alsof een berg veel kleiner is..

Nu het eerste idee dat wrsch bij jullie opkomt is natuurlijk een zbuffer gebruiken, maar die gebruik ik reeds.. ik zit er echt al dagen op te zoeken, maar ik vind het probleem maar niet..

Hier is m'n code van de belangrijkste stukken (m'n render functie, alsook m'n initializeGraphics() en initializeResources() ==> m'n vertices en vertexbuffer en indexbuffer enzo).

IK heb ook de exe van m'n 'applicatie' online gezet
http://users.pandora.be/CrackNuT/terrein
Hier vind je de Terrain.exe met de bijhorende test.txt en test.bmp (een heightmap die ingelezen wordt en een texture)
Die heb je zeker nodig, dus moeten in de zelfde map van de exe staan.
Mocht directx moeilijk doen. Ik heb de dll's ook online gezet, dus plaats ze eventueel ook in een zelfde map.

PS: Weet iemand of dat mag, die dll's online zetten (legaal dan hé) anders haal ik ze er meteen weer af. Ik wil namelijk geen problemen.
PS2: die texture is gewoon een random bmp snel gemaakt met paint. Ik wou gewoon even iets waar bij je een 'verschil' zag tussen verschillende punten.
Ik weet dat het op niets trekt :)
PS3 (de laatste): ik gebruik DirectX SDK Update Summer 2003 (momenteel de enigst beschikbare voor mezelf)

*edit* 't kan zijn dat ik pas morgenavond m'n thread weer bekijk. De examens komen eraan :'( en ben dus aan het leren ("normaal gezien").
*edit2* Controls: linkermuisknop = uitzoomen (denk ik)
rechtermuisknop = inzoomen (of omgekeerd)

Code:
protected virtual void SetupCamera()
{
       device.Transform.View = Matrix.LookAtLH(new Vector3(xcamera + straal, ycamera + straal, zcamera + straal), new Vector3(xcamera, ycamera, zcamera), new Vector3(0, 1, 0));
       device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, this.Width / this.Height, 0, 100);
}

protected virtual void Render()
{

	if (device != null) 
        {
		device.Clear(ClearFlags.Target |ClearFlags.ZBuffer , Color.CornflowerBlue, 1.0f, 0);
                
		device.BeginScene();
				
		// TODO : Scene rendering
                device.VertexFormat = CustomVertex.PositionColoredTextured.Format;
                device.Transform.World =  Matrix.RotationY(angle);
                SetupCamera();
                device.SetTexture(0, myTexture);
                device.SetStreamSource(0, vbuffer, 0);
                device.Indices = ibuffer;
                device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, WIDTH * HEIGHT, 0, (HEIGHT - 1) * (WIDTH - 1) * 2);

    
		device.EndScene();
		device.Present();
                float time = DXUtil.Timer(DirectXTimer.GetElapsedTime);
                this.Text = (1 / time).ToString() + " fps        " + ((HEIGHT - 1) * (WIDTH - 1) * 2) + " Vertices";
	}
}

Code:
public bool InitializeResources()
{
       try
       {
                //read stream
                FileStream myFile = new FileStream("test.txt", FileMode.Open);
                BinaryReader reader = new BinaryReader(myFile);
                
                int fieldwidth = reader.ReadInt32();
                int fieldheight = reader.ReadInt32();
                WIDTH = fieldwidth;
                HEIGHT = fieldheight;

                vertices = new CustomVertex.PositionColoredTextured[fieldheight * fieldwidth];
                int[] indices = new int[(fieldheight - 1) * (fieldwidth - 1) * 2 * 3]; //(fieldheight-1) * (fieldwidth-1) * 2 tris/square * 3 points/triangle
                
                Random rnd = new Random();
                

                for (int h = 0; h < fieldheight; h++)
                {
                    for (int w = 0; w < fieldwidth; w++)
                    {
                        float temp = reader.ReadInt32()/20;
                        vertices[w + fieldwidth * h].Position = new Vector3(w-fieldwidth/2,temp, h-fieldheight/2);
                        vertices[w + fieldwidth * h].Color = Color.Transparent.ToArgb();
                        vertices[w + fieldwidth * h].Tu = h / (float)(fieldheight - 1);
                        vertices[w + fieldwidth * h].Tv = w / (float)(fieldwidth - 1);

                    }
                }

                vbuffer = new VertexBuffer(typeof(CustomVertex.PositionColoredTextured), vertices.Length, device, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionColoredTextured.Format, Pool.Default);
                vbuffer.SetData(vertices, 0, LockFlags.None);
                indices = new int[(fieldwidth - 1) * (fieldheight - 1) * 6];
                for (int x = 0; x < fieldwidth - 1; x++)
                {
                    for (int y = 0; y < fieldheight - 1; y++)
                    {
                        indices[(x + y * (fieldwidth - 1)) * 6] = (x + 1) + (y + 1) * fieldwidth; //upper right
                        indices[(x + y * (fieldwidth - 1)) * 6 + 1] = (x + 1) + y * fieldwidth;   //bottom right
                        indices[(x + y * (fieldwidth - 1)) * 6 + 2] = x + y * fieldwidth;         //bottom left

                        indices[(x + y * (fieldwidth - 1)) * 6 + 3] = (x + 1) + (y + 1) * fieldwidth;//upper right
                        indices[(x + y * (fieldwidth - 1)) * 6 + 4] = x + y * fieldwidth;            //bottom left
                        indices[(x + y * (fieldwidth - 1)) * 6 + 5] = x + (y + 1) * fieldwidth;      //upper left

                    }
                }
                ibuffer = new IndexBuffer(typeof(int), indices.Length, device, Usage.WriteOnly, Pool.Default);
                ibuffer.SetData(indices, 0, LockFlags.None);

                //setup texture
                myTexture = TextureLoader.FromFile(device, "test.bmp");

                //succesfull
                return true;
       }
       catch (Exception e)
       {
              //failed
              return false;
       }

}

Code:
public bool InitializeGraphics()
{
	try {
		        // Now let's setup the Direct3D stuff
			PresentParameters presentParams = new PresentParameters();
			presentParams.Windowed   = true;
			presentParams.SwapEffect = SwapEffect.Discard;
                        presentParams.PresentationInterval = PresentInterval.Immediate;
                        presentParams.EnableAutoDepthStencil = true;
                        presentParams.AutoDepthStencilFormat = DepthFormat.D16;
                
				
			// Create the device
                       device = new Device(0, DeviceType.Hardware, this.Handle, CreateFlags.HardwareVertexProcessing, presentParams);
				
			// Setup the event handlers for the device
			device.DeviceLost     += new EventHandler(this.InvalidateDeviceObjects);
			device.DeviceReset    += new EventHandler(this.RestoreDeviceObjects);
			device.Disposing      += new EventHandler(this.DeleteDeviceObjects);


                        //Setup device
                	device.RenderState.CullMode = Cull.CounterClockwise;
                	device.RenderState.Clipping = false;
                	device.RenderState.FillMode = FillMode.Solid;
                	device.RenderState.PointSize = 3.0f;
                	device.RenderState.Lighting = false;
                	device.RenderState.ZBufferEnable = true;
               	 	device.RenderState.ZBufferWriteEnable = true;

			return true;
		} 
		catch (DirectXException) 
		{
			return false;
		}
	}

Aetemon

Legacy Member
protected virtual void SetupCamera()
{
device.Transform.View = Matrix.LookAtLH(new Vector3(xcamera + straal, ycamera + straal, zcamera + straal), new Vector3(xcamera, ycamera, zcamera), new Vector3(0, 1, 0));
device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, this.Width / this.Height, 0, 100);
}

dat laatste getal voor die honderd moet groter zijn dan 0 ;)
normaalgezien gaat het werken als die op 1 staat.

MacK

Legacy Member
ontzettend bedankt! Hier zit ik echt al dagen op te zoeken! (maw... hoe dom van me : :help: )..
Het archief is een bevroren moment uit een vorige versie van dit forum, met andere regels en andere bazen. Deze posts weerspiegelen op geen enkele manier onze huidige ideeën, waarden of wereldbeelden en zijn op sommige plaatsen gecensureerd wegens ontoelaatbaar. Veel zijn in een andere tijdsgeest gemaakt, al dan niet ironisch - zoals in het ironische subforum Off-Topic - en zouden op dit moment niet meer gepost (mogen) worden. Toch bieden we dit archief nog graag aan als informatiedatabank en naslagwerk. Lees er hier meer over of start een gesprek met anderen.
Terug
Bovenaan