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

DirectSound – Playing sound files with DirectX

This far we’ve only mainly considered the graphical side, together with a little input. Adding sound to a game, however, will greatly improve the overall gaming experience. Playing simple sound files is extremely easy in DirectX. In fact, all you need are 2 variables: again a ‘device’ variable, that will hold the link to the soundcard in your system (which might be integrated into the northbridge of your motherboard), and a buffer to hold the data loaded from the soundfile. So add these 2 variables to the top of your code:

 private DS.Device sounddevice;
 private SecondaryBuffer shotsound;

A SecondaryBuffer is a buffer where you can add sound effects. Before you can run this, you’ll need to add a new reference to Microsoft.DirectX.DirectSound, or you’ll be getting error messages like ‘The type or namespace name 'SecondaryBuffer' could not be found (are you missing a using directive or an assembly reference?)
‘. We’ll also need to put these lines in our using block:

 using Microsoft.DirectX.DirectSound;
 using DS = Microsoft.DirectX.DirectSound;

Now we’ll create a method that takes care of all the sound initialisation:

 private void InitializeSound()
 {
     sounddevice = new DS.Device();
     sounddevice.SetCooperativeLevel(this, CooperativeLevel.Normal);
 
     BufferDescription description = new BufferDescription();
     description.ControlEffects = false;
     shotsound = new SecondaryBuffer("shot.wav", description, sounddevice);
     shotsound.Play(0, BufferPlayFlags.Default);
 }

Now call this method from your Main method and run the program! If your speakers are powered on, you’ll already hear a small shot in the beginning of your program. That’s how easy it is to play a sound effect!

Let’s cycle throught the InitializeSound method. First, we initialize the sound device, and we set the CooperativeLevel to Normal, resulting in easy resource management. To initialize our SecondaryBuffer, we need to provide a BufferDescription, which, well, describes the buffer. If you want to be able to control the volume of the buffer during the game, for example, you’ld have to change to ControlVolume property of this BufferDescription to true. In our case, we will simply turn the ControlEffects to false, which is a requirement is you want to use the Clone method of your SecondaryBuffer, which we will use soon. Then we effectively create the SecondaryBuffer by loading data from the file shot.wav into it. You can find a sample soundfile here (link). The last line actually plays the buffer. The 0 indicates the priority, and Default indicates to only play the sound once, which is the opposite of Looping.

That’s all there is to it! In our case, however, we don’t need the last line, so remove it. We’re going to play the file when a bullet is fired, so go find that piece of code in your ReadUserInput method. Put the line immediately before the line where you subtract 10 points from the score.

When you run this code, you’ll notice the sound will only play when the previous shotsound has ended. This is because 1 buffer cannot be played multiple times at the same time! Another thought would be to Stop() and Play() the sound, but this would give a very odd effect, as you can try.

What we have to do, is to clone our SecondaryBuffer, thus creating a new buffer, that can be played immediately when it’s created. This way, we can have multiple buffers playing simultaneously:

 SecondaryBuffer newshotsound = shotsound.Clone(sounddevice);
 newshotsound.Play(0, BufferPlayFlags.Default);

This will do the trick! Remember, if your Clone method crashes, this means you have to put the ControlEffects member of your BufferDescription to false, as indicated above.

When you keep firing bullets, your computer will slow down. This is of course because you get a huge amount of buffers stored in your memory! So we need to put all of these buffers in a ArrayList, so we can dispose them from memory when they’re finished. Put this arraylist at the top of your code:

 private ArrayList soundlist = new ArrayList();

And immediately under the line where you play your cloned buffer:

 soundlist.Add(newshotsound);

This allows you to keep track of all the buffers in memory. We’ll create a very useful method, that will cycle through all of our buffers in memory, and discard those that are finished:

 private void SoundAffairs()
 {
     if (soundlist.Count > 0)
     {
         for (int i = soundlist.Count - 1; i > -1; i--)
         {
             SecondaryBuffer currentsound = (SecondaryBuffer)soundlist[i];
             if (!currentsound.Status.Playing)
             {
                 currentsound.Dispose();
                 soundlist.RemoveAt(i);
             }
         }
     }
 }

Moving backwards is my favorite way of cycling through an ArrayList. This way, you don’t have to put the i—- when you delete an item, such as we did with our targets. On topic, the method cycles through our soundlist and removes from memory all buffers that don’t have the Playing status. In other words, those that have stopped playing.

Make sure you call this method from within your OnPaint method! Now when you run the program, you can fire as much bullets as you want, without increasing your memory usage.




DirectX Tutorial 15 - DirectSound

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:
  • DirsctSound TV Tuner Help???
          Hello , I am developoing an application in WPF wh...
  • Microphone input...
          Hi! Is that possible to have Microphone input i...
  • Application crashes
          Hello, Whenever I try run the simple program; ...
  • How mayn Active Buffers?
          Hey, Read your tutorial and it really did help ...


    This chapter you’ve learned playing a wav file using DirectX. You should also be able to play it continuously by selecting the Looping property, and you have learned how you can play multiple instances of one SecondaryBuffer simultaneously by using the Clone method, without spilling memory.

    Next chapter we’ll be playing sounds in 3D space!

     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;
     using Microsoft.DirectX.DirectSound;
     using DS = Microsoft.DirectX.DirectSound;
     
     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();
             private DS.Device sounddevice;
             private SecondaryBuffer shotsound;
             private ArrayList soundlist = 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();
     
                 SoundAffairs();
             }
     
             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);
     
                         SecondaryBuffer newshotsound = shotsound.Clone(sounddevice);
                         newshotsound.Play(0, BufferPlayFlags.Default);
                         soundlist.Add(newshotsound);
     
                         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 SoundAffairs()
             {
                 if (soundlist.Count > 0)
                 {
                     for (int i = soundlist.Count - 1; i > -1; i--)
                     {
                         SecondaryBuffer currentsound = (SecondaryBuffer)soundlist[i];
                         if (!currentsound.Status.Playing)
                         {
                             currentsound.Dispose();
                             soundlist.RemoveAt(i);
                         }
                     }
                 }
             }
     
             private void InitializeSound()
             {
                 sounddevice = new DS.Device();
                 sounddevice.SetCooperativeLevel(this, CooperativeLevel.Normal);
     
                 BufferDescription description = new BufferDescription();
                 description.ControlEffects = false;
                 shotsound = new SecondaryBuffer("shot.wav", description, sounddevice);
             }
     
             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();
                     our_directx_form.InitializeSound();
                     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!