/CollisionDetection/CollisionDetection/Game1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Graphics.PackedVector;
using System.Diagnostics;

namespace CollisionDetection
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        bool draw = true;

        Stopwatch stopwatch, sw2;
        int cycles = 0;
        int cycles2 = 0;

        Camera camera, camera2;

        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        GraphicsDevice device;

        float particleDiameter = 0.125f;
        //float particleDiameter = 0.0625f;
        float particleDrawSize = 0.06f;
        float particleStep = 0.125f;

        VertexPositionTexture[] particles;

        String fps = "0 fps";
        String fps2 = "0 fps";

        SpriteFont font1;

        GPUCollisionDetection gpucd;

        RenderTarget2D rt;

        Stopwatch sw = new Stopwatch();

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            graphics.PreferredBackBufferWidth = 1350;
            graphics.PreferredBackBufferHeight = 900;
        }


        protected override void Initialize()
        {
            base.Initialize();
            //TargetElapsedTime = new TimeSpan((int)(5.5 * 10000));
            TargetElapsedTime = new TimeSpan((int)(3 * 10000));
        }


        protected override void LoadContent()
        {
            int bodyTextureWidth = 16; int bodyTextureHeight = 16;
            int particleTextureWidth = 512; int particleTextureHeight = 512;
            //int particleTextureWidth = 512; int particleTextureHeight = 512;
            //int spatialHashWidth = 128; int spatialHashHeight = 128;
            //int spatialHashWidth = 256; int spatialHashHeight = 256;
            int spatialHashWidth = 512; int spatialHashHeight = 512;
            int bucketWidth = 12; int bucketHeight = 12;

            //Vector2 worldSize = new Vector2(12, 12);
            //Vector2 worldPosition = new Vector2(-6, -6);

            //Vector2 worldSize = new Vector2(60, 40);
            //Vector2 worldPosition = new Vector2(-30, -20);
            Vector2 worldSize = new Vector2(66, 40);
            Vector2 worldPosition = new Vector2(-33, -20);

            Vector3 globalWorldSize, globalWorldPosition;

            stopwatch = new Stopwatch();

            globalWorldPosition = new Vector3(worldPosition.X, worldPosition.Y, 0);
            globalWorldSize = new Vector3(worldSize.X, worldSize.Y, 1);

            bucketWidth = (int)(worldSize.X / particleStep);
            bucketHeight = (int)(worldSize.Y / particleStep);
            Console.WriteLine(bucketWidth + "," + bucketHeight);

            device = GraphicsDevice;
            spriteBatch = new SpriteBatch(GraphicsDevice);


            //if (first) printData();

            camera = new Camera(device.Viewport, 1, 1);
            camera.Position = new Vector3(0.5f, -0.5f, 1);
            camera.LookAt = new Vector3(0.5f, -0.5f, 0);
            camera.Update();

            camera2 = new Camera(device.Viewport, worldSize.X / 2, worldSize.Y / 2);
            camera2.LookAt = new Vector3(0, 0, 0);
            camera2.Position = new Vector3(0, 0, 1);
            camera2.Update();

            font1 = Content.Load<SpriteFont>(@"fonts\MyFont");

            stopwatch.Start();

            gpucd = new GPUCollisionDetection(device, Content, particleDiameter,
                new TextureDimension2D(bodyTextureWidth, bodyTextureHeight), new TextureDimension2D(particleTextureWidth, particleTextureHeight),
                new TextureDimension2D(spatialHashWidth, spatialHashHeight), globalWorldSize, globalWorldPosition, new TextureDimension3D(bucketWidth, bucketHeight, 1));

            interestingWorldGPUcd();
            //interestingWorldGPUcd2();
            //interestingWorldGPUcd3();
            //fluids();
            //fluidBoxes(0.25f);
            //fluidBoxes(0.375f);

            gpucd.setBuffers();
            //gpucd.spatialHash.setBuffersComplete();

            gpucd.deleteObject(0);
            //gpucd.deleteObject(1);

            rt = new RenderTarget2D(device, gpucd.bodyLinearMomentum.Width, gpucd.bodyLinearMomentum.Height, false, SurfaceFormat.Vector4, DepthFormat.None);

            sw2 = new Stopwatch();


            sw.Start();
            sw2.Start();
            cycles2 = 0;
        }


        protected override void UnloadContent()
        {

        }


        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            VertexPositionTexture[] quad = new VertexPositionTexture[4];
            quad[0] = new VertexPositionTexture(new Vector3(0, 0, 0), new Vector2(0, 0));
            quad[1] = new VertexPositionTexture(new Vector3(1, 0, 0), new Vector2(1, 0));
            quad[2] = new VertexPositionTexture(new Vector3(0, -1, 0), new Vector2(0, 1));
            quad[3] = new VertexPositionTexture(new Vector3(1, -1, 0), new Vector2(1, 1));

            device.SetRenderTarget(rt);

            Effect gravityEffect = Content.Load<Effect>(@"external_effects\gravity");

            gravityEffect.CurrentTechnique = gravityEffect.Techniques["Gravity"];

            gravityEffect.Parameters["Projection"].SetValue(camera.ProjectionMatrix);
            gravityEffect.Parameters["View"].SetValue(camera.ViewMatrix);
            gravityEffect.Parameters["World"].SetValue(Matrix.Identity);


            gravityEffect.Parameters["bodyMass"].SetValue(gpucd.bodyMass);
            gravityEffect.Parameters["bodyLinearMomentum"].SetValue(gpucd.bodyLinearMomentum);
            float factor = gameTime.ElapsedGameTime.Ticks == 0 ? 1 : (gameTime.ElapsedGameTime.Ticks / 10000f);

            //gravityEffect.Parameters["gravity"].SetValue(0.005f * factor);
            gravityEffect.Parameters["gravity"].SetValue(0.002f * factor);

            device.BlendState = BlendState.Opaque;
            device.Clear(Color.Black);

            foreach (var pass in gravityEffect.CurrentTechnique.Passes)
            {
                pass.Apply();
                device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleStrip, quad, 0, 2);
            }
            device.SetRenderTarget(null);
            if (sw.ElapsedMilliseconds > 3000)
            {
                gpucd.bodyLinearMomentum = (Texture2D)rt;
            }


            gpucd.update(gameTime, false);

            cycles++;

            if (stopwatch.ElapsedMilliseconds >= 500)
            {
                stopwatch.Stop();

                fps = (int)(1000 / (stopwatch.ElapsedMilliseconds / (float)cycles)) + " fps";

                stopwatch.Restart();
                cycles = 0;
            }

            base.Update(gameTime);
        }


        protected override void Draw(GameTime gameTime)
        {
            
            #region Draw

            if (draw)
            {
                GraphicsDevice.Clear(Color.White);
                Effect drawEffect = Content.Load<Effect>(@"external_effects\draw_particles");
                drawEffect.CurrentTechnique = drawEffect.Techniques["Draw"];

                drawEffect.Parameters["Projection"].SetValue(camera2.ProjectionMatrix);
                drawEffect.Parameters["View"].SetValue(camera2.ViewMatrix);
                drawEffect.Parameters["World"].SetValue(Matrix.Identity);

                drawEffect.Parameters["pposition"].SetValue((Texture2D)gpucd.particlePosition);

                drawEffect.Parameters["ptextureWidth"].SetValue(gpucd.particlesTX.Width);
                drawEffect.Parameters["ptextureHeight"].SetValue(gpucd.particlesTX.Height);
                drawEffect.Parameters["size"].SetValue(particleDrawSize / 2.0f);
                drawEffect.Parameters["color"].SetValue(new Vector4(1, 0, 0, 0.5f));

                foreach (var pass in drawEffect.CurrentTechnique.Passes)
                {
                    pass.Apply();
                    device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, particles, 0, particles.Length / 3);
                }

                Effect drawEffect2 = Content.Load<Effect>(@"external_effects\draw_particles");
                drawEffect2.CurrentTechnique = drawEffect2.Techniques["Draw"];

                drawEffect2.Parameters["Projection"].SetValue(camera2.ProjectionMatrix);
                drawEffect2.Parameters["View"].SetValue(camera2.ViewMatrix);
                drawEffect2.Parameters["World"].SetValue(Matrix.Identity);

                drawEffect2.Parameters["pposition"].SetValue((Texture2D)gpucd.particlePosition);

                drawEffect2.Parameters["ptextureWidth"].SetValue(gpucd.particlesTX.Width);
                drawEffect2.Parameters["ptextureHeight"].SetValue(gpucd.particlesTX.Height);
                drawEffect2.Parameters["size"].SetValue(particleDiameter / 2.0f);
                drawEffect2.Parameters["color"].SetValue(new Vector4(0.7f, 0.7f, 0.7f, 1));

                foreach (var pass in drawEffect2.CurrentTechnique.Passes)
                {
                    pass.Apply();
                    device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, particles, 0, particles.Length / 3);
                }
            }


            // draw fps
            Vector2 FontOrigin = font1.MeasureString(fps) / 2;
            Vector2 fontPos = new Vector2(5, 5);
            spriteBatch.Begin();
            spriteBatch.DrawString(font1, fps, fontPos + FontOrigin, Color.Purple, 0, FontOrigin, 1.0f, SpriteEffects.None, 0.5f);
            spriteBatch.End();

            // draw fps
            FontOrigin = font1.MeasureString(fps2) / 2;
            fontPos = new Vector2(5, 25);
            spriteBatch.Begin();
            spriteBatch.DrawString(font1, fps2, fontPos + FontOrigin, Color.Purple, 0, FontOrigin, 1.0f, SpriteEffects.None, 0.5f);
            spriteBatch.End();

            base.Draw(gameTime);

            #endregion

            cycles2++;

            if (sw2.ElapsedMilliseconds >= 500)
            {
                sw2.Stop();

                fps2 = (int)(1000 / (sw2.ElapsedMilliseconds / (float)cycles2)) + " fps";

                sw2.Restart();
                cycles2 = 0;
            }

        }


        private VertexPositionTexture[] getParticles()
        {
            VertexPositionTexture[] particles = new VertexPositionTexture[gpucd.Particles * 6];
            int j = 0;
            for (int i = 0; i < gpucd.Particles; i++)
            {
                float index = i / (float)(gpucd.particlesTX.Width * gpucd.particlesTX.Height);
                particles[j] = new VertexPositionTexture(new Vector3(-0.5f, 0.5f, index), new Vector2(0, 0)); j++;
                particles[j] = new VertexPositionTexture(new Vector3(0.5f, 0.5f, index), new Vector2(0, 0)); j++;
                particles[j] = new VertexPositionTexture(new Vector3(-0.5f, -0.5f, index), new Vector2(0, 0)); j++;

                particles[j] = new VertexPositionTexture(new Vector3(0.5f, 0.5f, index), new Vector2(0, 0)); j++;
                particles[j] = new VertexPositionTexture(new Vector3(0.5f, -0.5f, index), new Vector2(0, 0)); j++;
                particles[j] = new VertexPositionTexture(new Vector3(-0.5f, -0.5f, index), new Vector2(0, 0)); j++;
            }

            return particles;
        }

        private Particle[] circle(float diameter, float weight)
        {
            double phi = Math.Tan(particleDiameter / (diameter/2));

            int n = (int)(2 * Math.PI / phi) + 1;
            Particle[] particles = new Particle[n];
            int i = 0;
            for (double p = 0; p <= 2 * Math.PI; p += phi)
            {
                float x = (float)(diameter/2 * Math.Cos(p));
                float y = (float)(diameter/2 * Math.Sin(p));
                particles[i] = new Particle(new Vector3(x, y, 0), weight / n);
                i++;
            }

            return particles;
        }


        private Particle[] box(float diameter, float weight) {
            int n = 0;
            float k = diameter / 2;
            for (float x = -k + particleStep; x <= k - particleStep; x += particleStep)
                n++;
            for (float x = -k + particleStep; x <= k - particleStep; x += particleStep)
                n++;
            for (float y = -k; y <= k; y += particleStep)
                n++;
            for (float y = -k; y <= k; y += particleStep)
                n++;

            // add bounding box
            Particle[] particles = new Particle[n];
            int i = 0;
            for (float x = -k + particleStep; x <= k - particleStep; x += particleStep)
            {
                particles[i] = new Particle(new Vector3(x, -k, 0), weight/n); i++;
            }
            for (float x = -k + particleStep; x <= k - particleStep; x += particleStep)
            {
                particles[i] = new Particle(new Vector3(x, k, 0), weight / n); i++;
            }
            for (float y = -k; y <= k; y += particleStep)
            {
                particles[i] = new Particle(new Vector3(-k, y, 0), weight / n); i++;
            }
            for (float y = -k; y <= k; y += particleStep)
            {
                particles[i] = new Particle(new Vector3(k, y, 0), weight / n); i++;
            }

            return particles;
        }

        private Particle[] rectangle(float x_, float y_, float weight)
        {
            int n = 0;
            float kx = x_ / 2;
            float ky = y_ / 2;
            for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                n++;
            for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                n++;
            for (float y = -ky; y <= ky; y += particleStep)
                n++;
            for (float y = -ky; y <= ky; y += particleStep)
                n++;

            // add bounding box
            Particle[] particles = new Particle[n];
            int i = 0;
            for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
            {
                particles[i] = new Particle(new Vector3(x, -ky, 0), weight / n); i++;
            }
            for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
            {
                particles[i] = new Particle(new Vector3(x, ky, 0), weight / n); i++;
            }
            for (float y = -ky; y <= ky; y += particleStep)
            {
                particles[i] = new Particle(new Vector3(-kx, y, 0), weight / n); i++;
            }
            for (float y = -ky; y <= ky; y += particleStep)
            {
                particles[i] = new Particle(new Vector3(kx, y, 0), weight / n); i++;
            }

            return particles;
        }

        private void interestingWorldGPUcd()
        {
            Particle[] particles;
            bool run = true;


            particles = box(0.5f, 10);
            gpucd.addObject(
                new Vector3(-0.3f, 0.1f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            particles = box(0.5f, 10);
            gpucd.addObject(
                new Vector3(0.6f, -0.35f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            particles = box(0.5f, 10);
            gpucd.addObject(
                new Vector3(0.4f, 0.6f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            // circle
            particles = circle(2.5f, 6);
            gpucd.addObject(
                new Vector3(0.1f, 0.1f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            particles = box(4f, 10);
            gpucd.addObject(
                new Vector3(0.5f, -0.5f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            // circle
            particles = circle(0.8f, 6);
            gpucd.addObject(
                new Vector3(1.5f, -1.5f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);


            particles = box(1f, 10);
            gpucd.addObject(
                new Vector3(3f, 3f, 0), Quaternion.Identity,
                new Vector3(run ? 40 : 0, run ? 25 : 0, 0), Vector3.Zero,
                particles);

            particles = box(1f, 10);
            gpucd.addObject(
                new Vector3(-3f, 3f, 0), Quaternion.Identity,
                new Vector3(run ? 50 : 0, 0, 0), Vector3.Zero,
                //new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            particles = box(1f, 10);
            gpucd.addObject(
                new Vector3(3f, -4f, 0), Quaternion.Identity,
                new Vector3(run ? 30 : 0, run ? 50 : 0, 0), Vector3.Zero,
                //new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            for (int i = 0; i < 5; i++)
            {
                particles = circle(0.7f, 3);
                gpucd.addObject(
                    new Vector3(-3f, i - 3, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = new Particle[] { new Particle(Vector3.Zero, 2) };
                gpucd.addObject(
                    new Vector3(-3f, i - 3, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = circle(0.7f, 3);
                gpucd.addObject(
                    new Vector3(-4f, i - 3, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = new Particle[] { new Particle(Vector3.Zero, 2) };
                gpucd.addObject(
                    new Vector3(-4f, i - 3 - 0.1f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = new Particle[] { new Particle(Vector3.Zero, 2) };
                gpucd.addObject(
                    new Vector3(-4f, i - 3 + 0.1f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = new Particle[] { new Particle(Vector3.Zero, 2) };
                gpucd.addObject(
                    new Vector3(-4f - 0.2f, i - 3, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);
            }

            for (int i = 0; i < 5; i++)
            {
                particles = circle(0.7f, 3);
                gpucd.addObject(
                    new Vector3(4f, i - 3, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);
            }

            for (int i = 0; i < 6; i++)
            {
                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 3, 4f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 3, 4f + 0.5f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);
            }

            for (int i = 0; i < 3; i++)
            {
                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, 3f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, 2.5f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, 2f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);
            }

            for (float i = -1; i < 3.2f; i += 0.38f)
            {
                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, -4.6f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, -4.2f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, -3.8f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, -3.4f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);

                particles = box(0.25f, 3);
                gpucd.addObject(
                    new Vector3(i - 1, -3f, 0), Quaternion.Identity,
                    new Vector3(0, 0, 0), Vector3.Zero,
                    particles);
            }



            //containment
            particles = box(10f, 50000);
            gpucd.addObject(
                new Vector3(0f, 0f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles, true);

            this.particles = getParticles();
        }

        private void interestingWorldGPUcd3() {
            Particle[] particles;
            particles = rectangle(7f, 7f, 10);
            gpucd.addObject(
                new Vector3(-0.0f, -0.0f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), new Vector3(0,0,1000f),
                particles);

            this.particles = getParticles();
        }

        private void interestingWorldGPUcd2() {
            Particle[] particles;

            particles = rectangle(7f, 0.125f, 10);
            gpucd.addObject(
                new Vector3(-0.0f, -0.0f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            particles = new Particle[] { new Particle(Vector3.Zero, 50000) };
            gpucd.addObject(
                new Vector3(0.1f, -0.2f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles, true);

            particles = new Particle[] { new Particle(Vector3.Zero, 50000) };
            gpucd.addObject(
                new Vector3(-0.1f, -0.2f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles, true);


            // circle
            particles = circle(1.8f, 25);
            gpucd.addObject(
                new Vector3(-3f, 3.8f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);

            // circle
            particles = circle(0.5f, 2.5f);
            gpucd.addObject(
                new Vector3(3f, 0.438f, 0), Quaternion.Identity,
                new Vector3(0, 0, 0), Vector3.Zero,
                particles);


            //containment
            //int n = 5;
            //List<Particle> lst = new List<Particle>();
            //for (int i = 0; i < n; i++)
            //{
            //    lst.AddRange(box(10f + i*particleDiameter, 50000));

            //}
            //particles = lst.ToArray();

            //gpucd.addObject(
            //    new Vector3(0f, 0f, 0), Quaternion.Identity,
            //    new Vector3(0, 0, 0), Vector3.Zero,
            //    particles, true);

            //this.particles = getParticles();


            int n = 2;
            List<Particle> lst = new List<Particle>();
            for (int i = 0; i < n; i++)
            {
                float kx = 5;
                float ky = 5;
                float weight = 500;
                particles = new Particle[(int)((kx - particleStep) * 2) + 1];
                int m = 0;
                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[m] = new Particle(new Vector3(x, -ky, 0), weight / n); i++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);

                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[i] = new Particle(new Vector3(x, ky, 0), weight / n); i++;
                }
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[i] = new Particle(new Vector3(-kx, y, 0), weight / n); i++;
                }
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[i] = new Particle(new Vector3(kx, y, 0), weight / n); i++;
                }

                particles = box(10f + i * particleDiameter, 50000);
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);

            }
            this.particles = getParticles();
        }

        public void fluids() {
            Particle[] particles;
            Random r = new Random();

            Vector3 v = new Vector3();

            //for (float y = -18f + particleDiameter; y < -5f; y = y + particleDiameter / 0.99f)
            for (float y = -14f + particleDiameter; y < 12.8f; y = y + particleDiameter / 0.99f)
            //for (float y = -8f + particleDiameter; y < -7; y = y + particleDiameter / 0.99f)
            {
                //for (float x = -9f + particleDiameter; x < 8.8f; x += particleDiameter / 0.99f)
                for (float x = -19f + particleDiameter; x < 19f; x += particleDiameter / 0.99f)
                {
                    particles = new Particle[] { new Particle(Vector3.Zero, 0.1f, 7f, 0.0005f, 0.002f) };
                    v.X = x + (float)(r.NextDouble() * 0.005f);
                    v.Y = y + (float)(r.NextDouble() * 0.005f);
                    gpucd.addObject(
                        v, Quaternion.Identity,
                        Vector3.Zero, Vector3.Zero,
                        particles);

                    
                }
            }

            

            #region containment box
            int n = 1;
            List<Particle> lst = new List<Particle>();
            for (int i = 0; i < n; i++)
            {
                float kx = 25f;
                float ky = 18f;
                float weight = 5000;
                particles = new Particle[(int)((kx - particleStep) * 2 / particleStep) + 1];
                int m = 0;
                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[m] = new Particle(new Vector3(x, -ky, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[m] = new Particle(new Vector3(x, ky, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                particles = new Particle[(int)((ky) * 2 / particleStep) + 1];
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[m] = new Particle(new Vector3(-kx, y, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[m] = new Particle(new Vector3(kx, y, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
            }
            #endregion

            //particles = box(18f, 50000);
            //gpucd.addObject(
            //    new Vector3(0f, 0f, 0), Quaternion.Identity,
            //    new Vector3(0, 0, 0), Vector3.Zero,
            //    particles, true);

            this.particles = getParticles();
        }

        private void fluidBoxes(float diameter) {
            Particle[] particles = null;
            Random r = new Random();
            Vector3 v = new Vector3();

            //for (float y = -14f + diameter; y < 12.8f; y = y + diameter / 0.89f)
            int c = 0;
            //for (float y = -18f + diameter; y < 17.5f; y = y + diameter / 0.85f)
            //for (float y = -18f + diameter; y < 17.5f; y = y + diameter / 0.59f)
            for (float y = -18f + diameter; y < 17.5f; y = y + diameter / 0.59f)
            {
                //for (float x = -23f + diameter; x < 8f; x += diameter / 0.59f)
                //for (float x = -23f + diameter; x < 17.5f; x += diameter / 0.59f)
                for (float x = -31.5f + diameter; x < 31.5f; x += diameter / 0.59f)
                {
                    //particles = new Particle[] { new Particle(Vector3.Zero, 0.1f, 7f, 0.0005f, 0.002f) };
                    particles = box(diameter, 1);
                    //v.X = x + (float)(r.NextDouble() * 0.005f);
                    //v.Y = y + (float)(r.NextDouble() * 0.005f);
                    v.X = x;
                    v.Y = y;
                    int index = gpucd.addObject(
                        v, Quaternion.Identity,
                        Vector3.Zero, Vector3.Zero,
                        particles);
                    c++;
                }
            }

            Console.WriteLine(c + " boxes");
            Console.WriteLine(particles.Length * c + " particles");
            float kx = 32f;
            float ky = 18f;
            #region containment box
            int n = 1;
            for (int i = 0; i < n; i++)
            {

                float weight = 5000;
                particles = new Particle[(int)((kx - particleStep) * 2 / particleStep) + 1];
                int m = 0;
                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[m] = new Particle(new Vector3(x, -ky, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                for (float x = -kx + particleStep; x <= kx - particleStep; x += particleStep)
                {
                    particles[m] = new Particle(new Vector3(x, ky, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                particles = new Particle[(int)((ky) * 2 / particleStep) + 1];
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[m] = new Particle(new Vector3(-kx, y, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
                m = 0;
                for (float y = -ky; y <= ky; y += particleStep)
                {
                    particles[m] = new Particle(new Vector3(kx, y, 0), weight / n, 30f, 0.0f); m++;
                }
                gpucd.addObject(
                    Vector3.Zero, Quaternion.Identity,
                    Vector3.Zero, Vector3.Zero,
                    particles, true);
            }
            #endregion

            this.particles = getParticles();
        }
    }
}