/// <summary>
        /// A fluid simulation using a hybrid SPH and grid
        /// based method.  Each SPH particle is calculated
        /// against a fixed number of other particles, with
        /// the results scaled to account for the particles
        /// which are not tested against
        /// </summary>
        public HybridFluidSim(FSQ finalRender, Device device)
        {
            _finalRender = finalRender ??
                           throw new ArgumentNullException(nameof(finalRender));

            _device = device ??
                      throw new ArgumentNullException(nameof(device));

            var generatedFilename =
                GenerateTempFile(
                    "HybridFluid/HybridFluidComputeShaders2.hlsl",
                    ParticleOutputShader.MarkupList.
                    Concat(ParticleUpdateShader.MarkupList).
                    Concat(WriteParticlesToSubspaceShader.MarkupList));

            const float fieldHalfSize = 500.0f;
            const int   particleCount = 10000;

            _particleBuffers =
                new ParticleBuffers(
                    _device,
                    new Vector3(fieldHalfSize / 3.0f, fieldHalfSize, 0.0f),
                    new Vector3(fieldHalfSize * 1.6f, fieldHalfSize, fieldHalfSize),
                    //new Vector3(fieldHalfSize, fieldHalfSize, 0.0f),
                    //new Vector3(fieldHalfSize, fieldHalfSize, fieldHalfSize),
                    particleCount);

            _particleUpdateShader =
                new ParticleUpdateShader(
                    generatedFilename,
                    _device,
                    _particleBuffers,
                    particleCount);

            _particleOutputShader =
                new ParticleOutputShader(
                    generatedFilename,
                    _device,
                    _particleBuffers.ReadBuffer,
                    _finalRender.UAV,
                    particleCount);

            _subspaceBuffers = new SubspaceBuffers(
                _device,
                32,
                32,
                32);

            _writeParticlesToSubspaceShader =
                new WriteParticlesToSubspaceShader(
                    generatedFilename,
                    device,
                    _subspaceBuffers,
                    _particleBuffers,
                    ParticleUpdateShader.ParticleReadSlot);
        }
Beispiel #2
0
        public WriteParticlesToSubspaceShader(
            string filename,
            Device device,
            SubspaceBuffers subspaceBuffers,
            ParticleBuffers particleBuffers,
            int particleReadSlot) :
            base(filename, "WriteParticlesToSubspace", device)
        {
            _subspaceBuffers = subspaceBuffers ??
                               throw new ArgumentNullException(nameof(subspaceBuffers));

            _particleBuffers = particleBuffers ??
                               throw new ArgumentNullException(nameof(particleBuffers));

            _particleReadSlot = particleReadSlot;
        }
Beispiel #3
0
        /// <summary>
        /// Shader which reads in the particles in the read buffer,
        /// updates their state (position, velocity etc), and writes
        /// them to the output buffer
        /// </summary>
        public ParticleUpdateShader(
            string filename,
            Device device,
            ParticleBuffers particleBuffer,
            int particleCount) :
            base(
                filename,
                "UpdateParticles",
                device)
        {
            _particleBuffer = particleBuffer ??
                              throw new ArgumentNullException(nameof(particleBuffer));

            _threadGroupsX = particleCount / threadGroupSize;
            _threadGroupsY = 1;
            _threadGroupsZ = 1;
        }