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

Point sprites – Billboarding

This chapter we’ll add bullets to our game. For these bullets, we could use real 3D spheres, but this would ask too much from our graphics card. Instead, we’ll be using a very simple 2D image of a fireball, which you can download here (link). We will only supply the central point of the image in 3D space to DirectX, and DirectX will display the image, always facing the viewer and scaled to reflect the distance between the viewer and the point in 3D space. This technique is called billboarding. Since only 1 point is needed, this method consumes very little bandwidth to our graphics card in our AGP/PCI express slot.

First we’ll start by letting DirectX know we’ll be drawing point sprites. If we wouldn’t, DirectX would simply draw a single point for every point we specify, instead of the while 2D image. Put this code after your device creation:

 device.RenderState.PointSpriteEnable = true;
 device.RenderState.PointScaleEnable = true;

The second line indicates we want DirectX to scale the size of the 2D image according to the distance between the viewer and the specified point in 3D space.

We will load our 2D image into a texture variable. As we need to keep track of all the bullets we’ve fired, we’ll need an ArrayList to store all our bullets, so put these line at the top of your code:

 private Texture bullettexture;
 private ArrayList spritelist = new ArrayList();

First we’ll load the 2D image into our texture variable. This is done by adding this line to the LoadTexturesAndMaterials method:

 bullettexture = TextureLoader.FromFile(device, "bullet.jpg");

You can download my sample image here (link). When being fired, the bullets will move forward continuously. Thus, for every bullet, we’ll need the position and the 3 angles, just as with our plane. So we’re going to define a new struct at the top of our code:

 struct spritestruct
 {
      public Vector3 position;
      public Vector3 angles;
 }

Now, every time the user presses the spacebar, we want a new bullet to be created and be added to our ArrayList, so add this code at the bottom of your ReadUserInput method:

 if (keys[Key.Space])
 {                
      spritestruct newsprite = new spritestruct();
      newsprite.position = spacemeshposition;
      newsprite.angles = spacemeshangles;
      spritelist.Add(newsprite);    
 }

When the spacebar is pressed, we’ll create a new spritestruct, and the current position and angles of the airplane will be given to it. This is of course because we want the bullet to travel in the same direction as our plane was flying the moment the bullet was fired. Then the new bullet is added to the ArrayList.

Now we want to let the bullets move forward. We’ve already created a method that does all the calculations: UpdatePosition. We’re going to create a new method, DrawSprites, that will be called from within out OnPaint method. This method will scroll through our spritelist, and will update the position of every sprite, and then draw the sprite. So start with this code:

 private void DrawSprites()
 {    
      for (int i = 0; i < spritelist.Count; i++)
      {
          spritestruct currentsprite = (spritestruct)spritelist[i];
          UpdatePosition(ref currentsprite.position, currentsprite.angles, gamespeed * 5);    
         spritelist[i] = currentsprite;
      }
 }

This will update the position of every bullet in our spritelist. You notice that our bullets will travel 5 times as fast as our airplane. Next, we want to draw them. For each bullet, DirectX needs to be passed a vertex definition containing 3 things: the position, the size and the color. Up till now, we used CustomVertex formats to hold this data. For a point sprite, which is already a bit advanced, however, there is no CustomVertex format we can use. So we need to define our very own Vertexformat, and a structure to hold the corresponding data. So put this struct at the top of your code:

 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;
      }
 }

This struct can hold all the data DirectX needs to draw point sprites. Now we need to fill an array of these vertices and pass it to DirectX. First we need to create this array, so make this the first line of your DrawSprites method:

 myownvertexformat[] spritecoordsarray = new myownvertexformat[spritelist.Count];

You see the array has the same amount of elements as there are bullets. Now we only have to fill an element for every sprite. So add this line between your for loop, which will fill the position, the size and the color of your sprites:

 spritecoordsarray[i] = new myownvertexformat((float)currentsprite.position.X, (float)currentsprite.position.Y, (float)currentsprite.position.Z, 0.5f, Color.White.ToArgb());

After your for loop, your spritecoordsarray will contain an element corresponding to the sprites you want to draw. Now we will actually draw the sprites. Put this code at the end of the method:

 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.DrawUserPrimitives(PrimitiveType.PointList, spritelist.Count, spritecoordsarray);    
 }

First we set the image of our bullet as the current texture for our graphics card, and we use the standard material. The next line creates our own new VertexFormat: we use this to indicate DirectX it can expect information about the position, the size and the color. Then we set the World space matrix so the images will be placed at the correct spots. The last line is the actual call to DrawUserPrimitives, where you need to pass the type of data, the number of elements in the array and the array we just created. As type of data, we indicate PointList, because our array only contains separate points. Remember again, this is exactly the strength of point sprites: only 1 point is needed to draw a complete image. This last line will fail is the presented array empty, so we first check to make sure this is not the case.

This concludes the method; remember to call it from within your OnPaint method, immediately before you call to EndScene. Now try to run this code!

When you press the spacebar, you should see a huge image of our fireball appearing. This is because we haven’t yet set the scaling factors! Go to your device creation method, and add these lines to the bottom:

 device.RenderState.PointScaleA = 100f;
 device.RenderState.PointScaleB = 0f;
 device.RenderState.PointScaleC = 0f;    

When you run this code, you’ll see the image has been reduced in size, but it doesn’t become smaller as it moves away. This is because we’ve only set PointScaleA to 100. This first value is the constant scaling factor, with a larger value meaning a smaller image. Increasing PointScaleB will make the image become smaller as the distance increases. PointScaleC has the same effect, but to the second power. This means that when the distance is doubled, the size of the image will be reduced by a factor of 4. Although mathematically not 100% correct, we will only use PointScaleC, to enhance the effect:

 device.RenderState.PointScaleA = 0f;
 device.RenderState.PointScaleB = 0f;
 device.RenderState.PointScaleC = 100f;    

Running this code should give a screen as the one below:




DirectX Tutorial 13 - Point sprites

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:
  • Sprites appearing upside-down
          I tried to use another image replacing the bullet,...
  • Bullet picture presentation trouble
          Hello! First of all I wish to thank you for your ...
  • confused on sprites
          Hi, i'm just trying to use point sprites in order...
  • LOADS of errors
          There are loads of errors on the final code at the...


    We will fine-tune our bullets in the next chapter. This will also include detecting collisions between a bullet and an obstacle. In case of a collision, the bullet will be removed from our spritelist, which will free the memory. To see this is needed, try firing bullets continuously for 5 minutes while having a look at the memory consumption and CPU power (in your Task Manager).

     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;
             }
     
             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])
                 {
                     spritestruct newsprite = new spritestruct();
                     newsprite.position = spacemeshposition;
                     newsprite.angles = spacemeshangles;
                     spritelist.Add(newsprite);
                 }
             }
     
             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());
                 }
     
                 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.DrawUserPrimitives(PrimitiveType.PointList, spritelist.Count, spritecoordsarray);
                 }
             }
     
             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!