XNA for C#
DirectX 9 for C#
DirectX 9 for C++
DirectX 9 for VB
Forum
   
My XNA Book
      
       Go to section on this site

Additional info


Latest Forum posts

 Account settings
  Posted by: Anonymous
  When: 07/05/2014 at 09:48:39

 forced subtitle
  Posted by: Applefly
  When: 07/05/2014 at 06:00:48

 convert DVD into PMS
  Posted by: Applefly
  When: 07/05/2014 at 05:55:25

 DVD to Digital Copy easily
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:52:29

 DVD on Xbox 360/Xbox One Console
  Posted by: VIKIVannessa
  When: 05/05/2014 at 06:51:47

 Extract .Srt Subtitles
  Posted by: Applefly
  When: 04/05/2014 at 03:54:38

 Encode Movie collection
  Posted by: Applefly
  When: 04/05/2014 at 03:52:41

 Convert DVD to WMV
  Posted by: Applefly
  When: 29/04/2014 at 05:53:50

 rip DVDs into digital files
  Posted by: Applefly
  When: 29/04/2014 at 05:51:20

 iTunes movies/music to Kindle Fire
  Posted by: ciciyu80
  When: 29/04/2014 at 05:10:20


Ads

Alpha blending

As a difficult audience, the result of last chapter probably didnít fully please you. My guess is the black borders around our fireballs didnít seem too normal to you. And youíre completely right, the borders should be blended with whatever is behind them. Welcome to this chapter on alpha blending.

Up till now, if 2 objects shared the same pixel, the pixel takes the color of the object closest to the viewer. In the simplest form of alpha blending, the colors of both objects are added together, and the pixel takes this Ďsumí as color.

For example. Imagine having a completely blue background. Adding a red triangle in front of it would now simply display a red triangle. With alpha blending on, the pixel of the triangle would contain blue+red, thus the whole triangle would be purple.

Black is a special case. In terms of DirectX, itís not a color. Itís nothing. So black+blue gives simply blue. In general, black + a color results in this color. This is why Iíve drawn the borders of the fireball black, because the more black the image gets, the more of the background will be let through.

To enable this simples form of alpha blending, add these lines below your DirectX device creation:

 device.RenderState.SourceBlend = Blend.One;
 device.RenderState.DestinationBlend = Blend.One;

In short, when 2 objects compete for one pixel, their colors will simply be summed, as both of their weights will be One:

    FinalColor = Color1*SourceBlend + Color2*DestinationBlend

Which gives in our case:

    FinalColor = Color1*1 + Color2*1
    FinalColor = Color1 + Color2

Told you, itís simply the sum. To actually enable this alpha blending, add these lines around the line that draws the sprites:

 device.RenderState.AlphaBlendEnable = true;
 device.DrawUserPrimitives(PrimitiveType.PointList, spritelist.Count, spritecoordsarray);                
 device.RenderState.AlphaBlendEnable = false;

This means you ONLY enable alpha blending for your fireballs, otherwise you would get a completely transparent 3D city. Running this should give you a MUCH nicer effect on your bullets!

Running at slow gamespeeds, or having a supercomputer results in shooting 100 bullets every second when you hold the spacebar. Find the lines where you process keyboard input. Weíre going to build in a check to make sure thereís a minimal distance between 2 bullets:

 if (keys[Key.Space])
 {
      double distance = 0;
      if (spritelist.Count > 0)
      {
      spritestruct lastsprite = (spritestruct)spritelist[spritelist.Count-1];
      distance = Math.Sqrt(Math.Pow(lastsprite.position.X - spacemeshposition.X, 2) + Math.Pow(lastsprite.position.Y - spacemeshposition.Y, 2) + Math.Pow(lastsprite.position.Z - spacemeshposition.Z, 2));
 }
      if ((distance > 0.4) || (spritelist.Count == 0))
      {
      spritestruct newsprite = new spritestruct();
      newsprite.position = spacemeshposition;
      newsprite.angles = spacemeshangles;
      spritelist.Add(newsprite);                    
      if (score >= 10) score -= 10;
      }
 }

The first lines calculate the distance between the current position of the plane and the position of the last bullet. The remainder of the code is only executed if this distance is at least 0.4, of if there are no bullets yet. As a small extra, 10 points will be subtracted for each bullet fired!

Try running this code. Youíll notice the firing mechanism has become a bit more realistic, and it no longer depends on the speed of your computer!

We have nice bullets, but what good are bullets if they donít destroy our targets? Luckily, we already have a method that can check if 2 objects collide. So go to your DrawSprites method, and find the part where you cycle through your spritelist. Add this code to that for loop:

 int collisionkind = CheckCollision(currentsprite.position, 0.05f);
 if (collisionkind > 0)
 {
      spritelist.RemoveAt(i);
      i--;
                                         
      if (collisionkind == 3)
      {
      score += 200;
      gamespeed *= 1.02f;
      AddTargets();
      }
 }

First the program checks if the given bullet collides with an object in the scene. If this is not the case, a 0 will be stored in collisionkind. If there is a collision, a number indicating the kind of collision will be stored in that variable. So if there is a collision, the bullet is removed from the spritelist, making sure DirectX never draws this bullet anymore. More important, if collisionkind contains 3, this would indicate a collision between our bullet and a target. The CheckCollision method will already take care of the removal of the target, all we have to do is add some points to the score and replace the deleted target by a new one. As a small extra, the gamespeed will be slightly increased.




DirectX Tutorial 14 - Alpha blending

If you appreciate the amount of time I spend creating and updating
these pages, feel free to donate -- any amount is welcome !



Click here to go to the forum on this chapter!

Or click on one of the topics on this chapter to go there:
  • Alpha Blending of my model's hair
          I have created a model in 3DS Max. It had a body ...
  • Alpha blending working only in sometimes
          Hello there. I have a small problem with alpha bl...
  • Alpha blending
          Hi, I've been following your C# tutorial and i...


    That will be all! With a 3D scene, our plane and some targets we can aim at and destroy, this is starting to look as a game. Adding sound to the whole will improve our game a lot.

     using System;
     using System.Drawing;
     using System.Collections;
     using System.ComponentModel;
     using System.Windows.Forms;
     using System.Data;
     using Microsoft.DirectX;
     using Microsoft.DirectX.Direct3D;
     using D3D = Microsoft.DirectX.Direct3D;
     using Microsoft.DirectX.DirectInput;
     using DI = Microsoft.DirectX.DirectInput;
     
     namespace DirectX_Tutorial
     {
         public class WinForm : System.Windows.Forms.Form
         {
             private int[,] int_Floorplan;
             private int WIDTH;
             private int HEIGHT;
             private int differentbuildings = 5;
             private float gamespeed = 0.02f;
             private int[] buildingheights = new int[] { 0, 10, 1, 3, 2, 5 };
             private int maxtargets = 80;
     
             private System.ComponentModel.Container components = null;
             private D3D.Device device;
             private Texture scenerytexture;
             private Material material;
             private CustomVertex.PositionNormalTextured[] verticesarray;
             ArrayList verticeslist = new ArrayList();
             private Mesh spacemesh;
             private Material[] spacemeshmaterials;
             private Texture[] spacemeshtextures;
             private float spacemeshradius;
             private float scaling = 0.0005f;
             private Vector3 spacemeshposition = new Vector3(8, 2, 1);
             private Vector3 spacemeshangles = new Vector3(0, 0, 0);
             private DI.Device keyb;
             private double score = 0;
             private Mesh skyboxmesh;
             private Material[] skyboxmaterials;
             private Texture[] skyboxtextures;
             private ArrayList targetlist = new ArrayList();
             private Mesh targetmesh;
             private Texture bullettexture;
             private ArrayList spritelist = new ArrayList();
     
             struct targetstruct
             {
                 public Vector3 position;
                 public float radius;
                 public Material material;
             }
     
             struct spritestruct
             {
                 public Vector3 position;
                 public Vector3 angles;
             }
     
             struct myownvertexformat
             {
                 public float xval;
                 public float yval;
                 public float zval;
                 public float PointSize;
                 public int color;
     
                 public myownvertexformat(float fxval, float fyval, float fzval, float psize, int icolor)
                 {
                     xval = fxval;
                     yval = fyval;
                     zval = fzval;
                     PointSize = psize;
                     color = icolor;
                 }
             }
     
             public WinForm()
             {
                 InitializeComponent();
                 this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
             }
     
             public void InitializeDevice()
             {
                 PresentParameters presentParams = new PresentParameters();
                 presentParams.Windowed = true;
                 presentParams.SwapEffect = SwapEffect.Discard;
                 presentParams.AutoDepthStencilFormat = DepthFormat.D16;
                 presentParams.EnableAutoDepthStencil = true;
                 device = new D3D.Device(0, D3D.DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
     
                 device.RenderState.Lighting = true;
     
                 device.Lights[0].Type = LightType.Directional;
                 device.Lights[0].Diffuse = Color.White;
                 device.Lights[0].Direction = new Vector3(1, 1, -1);
                 device.Lights[0].Update();
                 device.Lights[0].Enabled = true;
     
                 device.Lights[1].Type = LightType.Directional;
                 device.Lights[1].Diffuse = Color.White;
                 device.Lights[1].Direction = new Vector3(-1, -1, -1);
                 device.Lights[1].Update();
                 device.Lights[1].Enabled = true;
     
                 device.SamplerState[0].MinFilter = TextureFilter.Anisotropic;
                 device.SamplerState[0].MagFilter = TextureFilter.Anisotropic;
     
                 device.SamplerState[0].AddressU = TextureAddress.Mirror;
                 device.SamplerState[0].AddressV = TextureAddress.Mirror;
     
                 device.RenderState.PointSpriteEnable = true;
                 device.RenderState.PointScaleEnable = true;
                 device.RenderState.PointScaleA = 0f;
                 device.RenderState.PointScaleB = 0f;
                 device.RenderState.PointScaleC = 100f;        
     
     
                 device.RenderState.SourceBlend = Blend.One;
                 device.RenderState.DestinationBlend = Blend.One;
             }
     
             protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
             {
                 ReadUserInput(gamespeed);
                 UpdatePosition(ref spacemeshposition, spacemeshangles, gamespeed);
                 if (CheckCollision(spacemeshposition, spacemeshradius) > 0)
                 {                
                     spacemeshposition = new Vector3(8, 2, 1);
                     spacemeshangles = new Vector3(0, 0, 0);
                     gamespeed /= 1.1f;
                     score /= 2;                
                 }
     
                 device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.DarkSlateBlue, 1.0f, 0);
                 device.BeginScene();
     
                 device.RenderState.Ambient = Color.DarkGray;
                 device.Transform.World = Matrix.Translation(-(float)spacemeshposition.X, -(float)spacemeshposition.Y, -(float)spacemeshposition.Z) * Matrix.RotationYawPitchRoll((float)spacemeshangles.X, (float)spacemeshangles.Y, (float)spacemeshangles.Z);            
                 device.VertexFormat = CustomVertex.PositionNormalTextured.Format;
                 device.Material = material;
                 device.SetTexture(0, scenerytexture);
                 device.DrawUserPrimitives(PrimitiveType.TriangleList, verticeslist.Count / 3, verticesarray);
     
                 device.Transform.World = Matrix.Scaling(scaling, scaling, scaling) * Matrix.RotationX((float)Math.PI / 2);
                 DrawMesh(spacemesh, spacemeshmaterials, spacemeshtextures);
     
                 DrawTargets();
     
                 device.RenderState.Ambient = Color.White;
                 device.Transform.World = Matrix.RotationX((float)Math.PI/2) *Matrix.RotationYawPitchRoll((float)spacemeshangles.X, (float)spacemeshangles.Y, (float)spacemeshangles.Z);
                 DrawMesh(skyboxmesh, skyboxmaterials, skyboxtextures);
     
                 DrawSprites();
     
                 device.EndScene();
                 device.Present();
                 this.Invalidate();            
             }
     
             private void SetUpCamera()
             {
                 device.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4, (float)this.Width / (float)this.Height, 0.3f, 500f);
                 device.Transform.View = Matrix.LookAtLH(new Vector3(0, -1f, 0.2f), new Vector3(0, 0, 0), new Vector3(0, 0, 1));
             }        
     
             private void LoadTexturesAndMaterials()
             {
                 material = new Material();
     
                 material.Diffuse = Color.White;
                 material.Ambient = Color.White;
     
                 scenerytexture = TextureLoader.FromFile(device, "texturemap.jpg");
                 bullettexture = TextureLoader.FromFile(device, "bullet.jpg");
             }
     
             private void LoadFloorplan()
             {
                 WIDTH = 20;
                 HEIGHT = 15;
     
                 int_Floorplan = new int[,]
                 {
                     {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,1,1,0,0,0,1,1,0,0,1,0,1},
                     {1,0,0,1,1,0,0,0,1,0,0,0,1,0,1},
                     {1,0,0,0,1,1,0,1,1,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,1,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,1,1,0,0,0,1,0,0,0,0,0,0,1},
                     {1,0,1,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,1,0,0,0,0,0,0,0,0,1},
                     {1,0,0,0,0,1,0,0,0,1,0,0,0,0,1},
                     {1,0,1,0,0,0,0,0,0,1,0,0,0,0,1},
                     {1,0,1,1,0,0,0,0,1,1,0,0,0,1,1},
                     {1,0,0,0,0,0,0,0,1,1,0,0,0,1,1},
                     {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                 };        
     
                 Random random = new Random();
                 for (int x = 0; x < WIDTH; x++)
                 {
                     for (int y = 0; y < HEIGHT; y++)
                     {
                         if (int_Floorplan[x, y] == 1)
                         {
                             int_Floorplan[x, y] = random.Next(differentbuildings) + 1;
                         }
                     }
                 }
             }
     
             private void LoadMesh(string filename, ref Mesh mesh, ref Material[] meshmaterials, ref Texture[] meshtextures, ref float meshradius)
             {
                 ExtendedMaterial[] materialarray;
                 mesh = Mesh.FromFile(filename, MeshFlags.Managed, device, out materialarray);
     
                 if ((materialarray != null) && (materialarray.Length > 0))
                 {
                     meshmaterials = new Material[materialarray.Length];
                     meshtextures = new Texture[materialarray.Length];
     
                     for (int i = 0; i < materialarray.Length; i++)
                     {
                         meshmaterials[i] = materialarray[i].Material3D;
                         meshmaterials[i].Ambient = meshmaterials[i].Diffuse;
     
                         if ((materialarray[i].TextureFilename != null) && (materialarray[i].TextureFilename != string.Empty))
                         {
                             meshtextures[i] = TextureLoader.FromFile(device, materialarray[i].TextureFilename);
                         }
                     }                
                 }
     
                 mesh = mesh.Clone(mesh.Options.Value, CustomVertex.PositionNormalTextured.Format, device);
                 mesh.ComputeNormals();
     
                 VertexBuffer vertices = mesh.VertexBuffer;
                 GraphicsStream stream = vertices.Lock(0, 0, LockFlags.None);
                 Vector3 meshcenter;
                 meshradius = Geometry.ComputeBoundingSphere(stream, mesh.NumberVertices, mesh.VertexFormat, out meshcenter) * scaling;
             }
     
             private void LoadMeshes()
             {
                 float dummy = 0;
                 LoadMesh("xwing.x", ref spacemesh, ref spacemeshmaterials, ref spacemeshtextures, ref spacemeshradius);
                 LoadMesh("skybox2.x", ref skyboxmesh, ref skyboxmaterials, ref skyboxtextures, ref dummy);
                 targetmesh = Mesh.Sphere(device, 1f, 10, 10);            
             }        
             private void DrawMesh(Mesh mesh, Material[] meshmaterials, Texture[] meshtextures)
             {
                 for (int i = 0; i < meshmaterials.Length; i++)
                 {
                     device.Material = meshmaterials[i];
                     device.SetTexture(0, meshtextures[i]);
                     mesh.DrawSubset(i);
                 }
             }
     
             private void UpdatePosition(ref Vector3 position, Vector3 angles, float speed)
             {
                 Vector3 addvector = new Vector3();
                 addvector.X += (float)(Math.Sin(angles.Z));
                 addvector.Y += (float)(Math.Cos(angles.Z));
                 addvector.Z -= (float)(Math.Tan(angles.Y));
                 addvector.Normalize();
     
                 position += addvector * speed;
             }
     
             private void InitializeInputDevices()
             {
                 keyb = new DI.Device(SystemGuid.Keyboard);
                 keyb.SetCooperativeLevel(this, CooperativeLevelFlags.Background | CooperativeLevelFlags.NonExclusive);
                 keyb.Acquire();
             }
     
             private void ReadUserInput(float speed)
             {
                 KeyboardState keys = keyb.GetCurrentKeyboardState();
     
                 if (keys[Key.Right])
                 {
                     spacemeshangles.X += 2.5f * speed;
                 }
                 if (keys[Key.Left])
                 {
                     spacemeshangles.X -= 2.5f * speed;
                 }
     
                 if (keys[Key.Down])
                 {
                     spacemeshangles.Z -= (float)(speed * Math.Sin(spacemeshangles.X));
                     spacemeshangles.Y -= (float)(speed * Math.Cos(spacemeshangles.X));
                 }
                 if (keys[Key.Up])
                 {
                     spacemeshangles.Z += (float)(speed * Math.Sin(spacemeshangles.X));
                     spacemeshangles.Y += (float)(speed * Math.Cos(spacemeshangles.X));
                 }
     
                 if (keys[Key.Space])
                 {
                     double distance = 0;
                     if (spritelist.Count > 0)
                     {
                         spritestruct lastsprite = (spritestruct)spritelist[spritelist.Count-1];
                         distance = Math.Sqrt(Math.Pow(lastsprite.position.X - spacemeshposition.X, 2) + Math.Pow(lastsprite.position.Y - spacemeshposition.Y, 2) + Math.Pow(lastsprite.position.Z - spacemeshposition.Z, 2));
                     }
                     if ((distance > 0.4) || (spritelist.Count == 0))
                     {
                         spritestruct newsprite = new spritestruct();
                         newsprite.position = spacemeshposition;
                         newsprite.angles = spacemeshangles;
                         spritelist.Add(newsprite);                    
                         if (score >= 10) score -= 10;
                     }
                 }
             }
     
             private int CheckCollision(Vector3 position, float radius)
             {            
                 if (position.Z - radius < 0) return 1;
                 if (position.Z + radius > 15) return 2;
     
                 if ((position.X < -10) || (position.X > WIDTH+10)) return 2;
                 if ((position.Y < -10) || (position.Y > HEIGHT+10)) return 2;
                 
                 if ((position.X - radius > 0) && (position.X + radius < WIDTH) && (position.Y - radius> 0) && (position.Y + radius < HEIGHT))
                 {
                     if (position.Z - radius < buildingheights[int_Floorplan[(int)position.X, (int)position.Y]]) return 1;
                 }
     
                 for (int i = 0; i < targetlist.Count; i++)
                 {
                     targetstruct currenttarget = (targetstruct)targetlist[i];
                     if (Math.Sqrt(Math.Pow(currenttarget.position.X - position.X, 2) + Math.Pow(currenttarget.position.Y - position.Y, 2) + Math.Pow(currenttarget.position.Z - position.Z, 2)) < radius + currenttarget.radius)
                     {
                         targetlist.RemoveAt(i);
                         i--;
                         return 3;
                     }
                 }
                 
                 return 0;
             }
     
             private void AddTargets()
             {    
                 while (targetlist.Count < maxtargets)
                 {
                     Random random = new Random();
                     int x = random.Next(WIDTH);
                     int y = random.Next(HEIGHT);
                     float z = (float)random.Next(2000) / 1000f + 1;
                     float radius = (float)random.Next(1000) / 1000f * 0.2f+ 0.01f;
     
                     bool acceptableposition = true;
                     if (int_Floorplan[x, y] > 0) acceptableposition = false;
                     foreach (targetstruct currenttarget in targetlist)
                     {
                         if (((int)currenttarget.position.X == x) && ((int)currenttarget.position.Y == y)) acceptableposition = false;
                     }
     
                     if (acceptableposition)
                     {
                         targetstruct newtarget = new targetstruct();
                         newtarget.position = new Vector3(x +0.5f, y+0.5f, z);
                         newtarget.radius = radius;
                         Material newmaterial = new Material();
                         newmaterial.Diffuse = Color.Red;
                         newmaterial.Ambient = Color.Red;
                         newtarget. material = newmaterial;
                         targetlist.Add(newtarget);
                     }
                 }
             }
     
             private void DrawTargets()
             {
                 device.SetTexture(0, null);
                 foreach (targetstruct currenttarget in targetlist)
                 {
                     device.Transform.World = Matrix.Scaling(currenttarget.radius, currenttarget.radius, currenttarget.radius) * Matrix.Translation(-(float)spacemeshposition.X + currenttarget.position.X, -(float)spacemeshposition.Y + currenttarget.position.Y, -(float)spacemeshposition.Z + currenttarget.position.Z) * Matrix.RotationYawPitchRoll((float)spacemeshangles.X, (float)spacemeshangles.Y, (float)spacemeshangles.Z);
                     device.Material = currenttarget.material;
                     targetmesh.DrawSubset(0);
                 }
             }
     
             private void DrawSprites()
             {
                 myownvertexformat[] spritecoordsarray = new myownvertexformat[spritelist.Count];
     
                 for (int i = 0; i < spritelist.Count; i++)
                 {
                     spritestruct currentsprite = (spritestruct)spritelist[i];
                     UpdatePosition(ref currentsprite.position, currentsprite.angles, gamespeed * 5);        
                     spritelist[i] = currentsprite;
     
                     spritecoordsarray[i] = new myownvertexformat((float)currentsprite.position.X, (float)currentsprite.position.Y, (float)currentsprite.position.Z, 0.5f, Color.White.ToArgb());
     
                     int collisionkind = CheckCollision(currentsprite.position, 0.05f);
                     if (collisionkind > 0)
                     {
                         spritelist.RemoveAt(i);
                         i--;
                                             
                         if (collisionkind == 3)
                         {
                             score += 200;
                             gamespeed *= 1.02f;
                             AddTargets();
                         }
                     }
                 }
     
                 if (spritelist.Count > 0)
                 {
                     device.SetTexture(0, bullettexture);
                     device.Material = material;
                     device.VertexFormat = VertexFormats.Position | VertexFormats.PointSize | VertexFormats.Diffuse;
                     device.Transform.World = Matrix.Translation(-(float)spacemeshposition.X, -(float)spacemeshposition.Y, -(float)spacemeshposition.Z) * Matrix.RotationYawPitchRoll((float)spacemeshangles.X, (float)spacemeshangles.Y, (float)spacemeshangles.Z);
                     device.RenderState.AlphaBlendEnable = true;
                     device.DrawUserPrimitives(PrimitiveType.PointList, spritelist.Count, spritecoordsarray);                
                     device.RenderState.AlphaBlendEnable = false;
                 }
             }
     
     
             private void VertexDeclaration()
             {
                 float imagesintexture = 1 + differentbuildings * 2;
     
                 for (int x = 0; x < WIDTH; x++)
                 {
                     for (int y = 0; y < HEIGHT; y++)
                     {
                         int currentbuilding = int_Floorplan[x, y];
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(0, 0, 1), (currentbuilding * 2 + 1) / imagesintexture, 1));
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, buildingheights[currentbuilding]), new Vector3(0, 0, 1), currentbuilding * 2 / imagesintexture, 1));
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y + 1, buildingheights[currentbuilding]), new Vector3(0, 0, 1), currentbuilding * 2 / imagesintexture, 0));
     
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y + 1, buildingheights[currentbuilding]), new Vector3(0, 0, 1), currentbuilding * 2 / imagesintexture, 0));
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, buildingheights[currentbuilding]), new Vector3(0, 0, 1), (currentbuilding * 2 + 1) / imagesintexture, 0));
                         verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(0, 0, 1), (currentbuilding * 2 + 1) / imagesintexture, 1));
     
                         if (y > 0)
                         {
                             if (int_Floorplan[x, y - 1] != int_Floorplan[x, y])
                             {
                                 if (int_Floorplan[x, y - 1] > 0)
                                 {
                                     currentbuilding = int_Floorplan[x, y - 1];
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(0, 1, 0), (currentbuilding * 2 - 1) / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, buildingheights[currentbuilding]), new Vector3(0, 1, 0), currentbuilding * 2 / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, 0f), new Vector3(0, 1, 0), currentbuilding * 2 / imagesintexture, 1));
     
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, buildingheights[currentbuilding]), new Vector3(0, 1, 0), currentbuilding * 2 / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(0, 1, 0), (currentbuilding * 2 - 1) / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(0, 1, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
     
                                 }
                                 if (int_Floorplan[x, y] > 0)
                                 {
                                     currentbuilding = int_Floorplan[x, y];
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(0, -1, 0), currentbuilding * 2 / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, 0f), new Vector3(0, -1, 0), (currentbuilding * 2 - 1) / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, buildingheights[currentbuilding]), new Vector3(0, -1, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
     
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(0, -1, 0), currentbuilding * 2 / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x + 1, y, buildingheights[currentbuilding]), new Vector3(0, -1, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(0, -1, 0), currentbuilding * 2 / imagesintexture, 0));
                                 }
     
                             }
                         }
     
                         if (x > 0)
                         {
                             if (int_Floorplan[x - 1, y] != int_Floorplan[x, y])
                             {
                                 if (int_Floorplan[x - 1, y] > 0)
                                 {
                                     currentbuilding = int_Floorplan[x - 1, y];
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(1, 0, 0), currentbuilding * 2 / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, 0f), new Vector3(1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, buildingheights[currentbuilding]), new Vector3(1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
     
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, buildingheights[currentbuilding]), new Vector3(1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(1, 0, 0), currentbuilding * 2 / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(1, 0, 0), currentbuilding * 2 / imagesintexture, 1));
                                 }
                                 if (int_Floorplan[x, y] > 0)
                                 {
                                     currentbuilding = int_Floorplan[x, y];
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, 0f), new Vector3(-1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 1));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(-1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, 0f), new Vector3(-1, 0, 0), currentbuilding * 2 / imagesintexture, 1));
     
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y, buildingheights[currentbuilding]), new Vector3(-1, 0, 0), (currentbuilding * 2 - 1) / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, buildingheights[currentbuilding]), new Vector3(-1, 0, 0), currentbuilding * 2 / imagesintexture, 0));
                                     verticeslist.Add(new CustomVertex.PositionNormalTextured(new Vector3(x, y + 1, 0f), new Vector3(-1, 0, 0), currentbuilding * 2 / imagesintexture, 1));
                                 }
                             }
                         }
                     }
                 }
                 verticesarray = (CustomVertex.PositionNormalTextured[])verticeslist.ToArray(typeof(CustomVertex.PositionNormalTextured));
             }
     
             protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
                     if (components != null)
                     {
                         components.Dispose();
                     }
                 }
                 base.Dispose(disposing);
             }
     
             private void InitializeComponent()
             {
                 this.components = new System.ComponentModel.Container();
                 this.Size = new System.Drawing.Size(500, 500);
                 this.Text = "Riemer's DirectX Tutorial using C# -- Season 2";
             }
     
             static void Main()
             {
                 using (WinForm our_directx_form = new WinForm())
                 {
                     our_directx_form.InitializeDevice();
                     our_directx_form.SetUpCamera();
                     our_directx_form.LoadFloorplan();
                     our_directx_form.VertexDeclaration();
                     our_directx_form.LoadTexturesAndMaterials();
                     our_directx_form.LoadMeshes();
                     our_directx_form.InitializeInputDevices();
                     our_directx_form.AddTargets();
                     Application.Run(our_directx_form);
                 }
             }
         }
     }


    Google
     
    Webwww.riemers.net


    If you appreciate the amount of time I spend creating and updating
    these pages, feel free to donate -- any amount is welcome !



    - Website design & XNA + DirectX code : Riemer Grootjans -
    ©2003 - 2011 Riemer Grootjans
  • Translations

    This site in English
    This site in Korean
    This site in Czech

    Microsoft MVP Award



    2007 - 2011 MVP Award
    DirectX - XNA

    Contents

    News
    Home
    Forum
    XNA 2.0 Recipes Book (8)
    XNA 3.0 Recipes Book (8)
    Downloads
    Extra Reading (3)
    Matrices: geometrical
    Matrix Mathematics
    Homogenous matrices
    Community Projects (1)
    Tutorials (160)
    XNA 4.0 using C# (89)
    DirectX using C# (54)
    Series 1:Terrain (14)
    Series 2: Flightsim (19)
    Starting code
    Textures
    The floorplan
    Creating the 3D City
    Meshloading from file
    Ambient light
    Action
    Flight kinematics
    Collision detection
    Skybox
    Texture filtering
    Adding targets
    Point sprites
    Alpha blending
    DirectSound
    Sounds in 3D
    Playing MP3 files
    Displaying text
    Going fullscreen
    Series 3: HLSL (19)
    Short Tuts (2)
    DirectX using C++ (15)
    DirectX using VB (2)
    -- Expand all --


    Thank you!

    Support this site --
    any amount is welcome !

    Stay up-to-date

    I don't have the time to keep a News section, so stay informed about the updates by clicking on this RSS file!