Example #1
0
    // Update is called once per frame
    void Update()
    {
        // Map buffers for reading / writing.
        particles  = Flex.Map(_particleBuffer);
        velocities = Flex.Map(_velocityBuffer);
        phases     = Flex.Map(_phaseBuffer);

        // Spawn particles.
        //spawnParticles(particles, velocities, phases);

        // Render particles.
        RenderParticles(particles, velocities, phases);

        // Unmap buffers.
        Flex.Unmap(_particleBuffer);
        Flex.Unmap(_velocityBuffer);
        Flex.Unmap(_phaseBuffer);

        // Write to device (async).
        Flex.SetParticles(_solver, _particleBuffer);
        Flex.SetVelocities(_solver, _velocityBuffer);
        Flex.SetPhases(_solver, _phaseBuffer);

        // Tick.
        Flex.UpdateSolver(_solver, Time.deltaTime, 1);

        // Read back (async).
        Flex.GetParticles(_solver, _particleBuffer);
        Flex.GetVelocities(_solver, _velocityBuffer);
        Flex.GetPhases(_solver, _phaseBuffer);
    }
Example #2
0
        private void PushParticlesToGPU(IntPtr solverPtr, FlexContainer cnt, Flex.Memory memory)
        {
            Flex.SetActive(solverPtr, cnt.m_activeSetHndl.AddrOfPinnedObject(), cnt.m_activeParticlesCount, memory);

            Flex.SetParticles(solverPtr, cnt.m_particlesHndl.AddrOfPinnedObject(), cnt.m_particlesCount, memory);
            Flex.SetRestParticles(solverPtr, cnt.m_restParticlesHndl.AddrOfPinnedObject(), cnt.m_particlesCount, memory);
            Flex.SetVelocities(solverPtr, cnt.m_velocitiesHndl.AddrOfPinnedObject(), cnt.m_particlesCount, memory);
            Flex.SetNormals(solverPtr, cnt.m_normalsHndl.AddrOfPinnedObject(), cnt.m_particlesCount, memory);
            Flex.SetPhases(solverPtr, cnt.m_phases, cnt.m_particlesCount, memory);
        }
Example #3
0
    public void TestSetParticlesPhases()
    {
        float DELTA_T = 0.016f;
        float INTERACTION_DISTANCE = 0.5f;
        float SOLID_REST_DISTANCE  = 0.2f;

        Flex.Library    lib  = Flex.Init(Flex.FLEX_VERSION, ErrorCallback);
        Flex.SolverDesc desc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref desc);
        desc.maxParticles        = 1000;
        desc.maxDiffuseParticles = 1000;
        Flex.Solver solver = Flex.CreateSolver(lib, ref desc);

        Flex.Params prms = new Flex.Params();
        Flex.GetParams(solver, ref prms);
        prms.radius            = INTERACTION_DISTANCE;
        prms.solidRestDistance = SOLID_REST_DISTANCE;
        Flex.SetParams(solver, ref prms);

        Flex.Buffer particles = CreateBuffer(lib, 2, 4, new float[]
        {
            -0.001f, 0.0f, 0.0f, 1.0f,
            0.001f, 0.0f, 0.0f, 1.0f,
        });
        Flex.SetParticles(solver, particles);

        Flex.Buffer phases = CreateBuffer(lib, 2, 1, new int[]
        {
            Flex.MakePhase(1, Flex.Phase.SelfCollide),
            Flex.MakePhase(1, Flex.Phase.SelfCollide),
        });
        Flex.SetPhases(solver, phases);

        Flex.SetActiveCount(solver, 2);

        Flex.Buffer active = CreateBuffer(lib, 2, 1, new int[]
        {
            0, 1,
        });
        Flex.SetActive(solver, active);

        Flex.UpdateSolver(solver, DELTA_T, 1);

        Flex.GetParticles(solver, particles);
        float[] values; ReadBuffer(lib, particles, 2, 4, out values);

        Assert.AreEqual(SOLID_REST_DISTANCE, Vector3.Distance(new Vector3(values[0], values[1], values[2]), new Vector3(values[4], values[5], values[6])));

        Flex.FreeBuffer(particles);
        Flex.FreeBuffer(phases);
        Flex.FreeBuffer(active);

        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }