public void TestCreateDestroyInstance()
    {
        Flex.Library    lib    = Flex.Init(Flex.FLEX_VERSION, ErrorCallback);
        Flex.SolverDesc slvDsc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref slvDsc);
        slvDsc.maxParticles = 1000;
        Flex.Solver       solver    = Flex.CreateSolver(lib, ref slvDsc);
        FlexExt.Container container = FlexExt.CreateContainer(lib, solver, 1000);

        FlexExt.Asset.Handle asset = CreateTestClothAsset();

        FlexExt.ParticleData data = FlexExt.MapParticleData(container);

        Matrix4x4 transform = Matrix4x4.identity;

        FlexExt.Instance.Handle instance = FlexExt.CreateInstance(container, ref data, asset, ref transform, 1.0f, 1.0f, 1.0f, Flex.MakePhase(1, Flex.Phase.Default), 1.0f);

        Assert.AreEqual(asset.asset.numParticles, instance.instance.numParticles);

        FlexExt.DestroyInstance(container, instance);

        FlexExt.UnmapParticleData(container);

        FlexExt.DestroyAsset(asset);

        FlexExt.DestroyContainer(container);
        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }
    public void TestCreateDestroyContainerWithDevice()
    {
        Flex.InitDesc desc = new Flex.InitDesc
        {
            deviceIndex      = -1,
            enableExtensions = false,
#if FLEX_CUDA
            computeType = Flex.ComputeType.CUDA,
#else
            computeType = Flex.ComputeType.D3D11,
#endif
            renderContext = default(IntPtr),
            renderDevice  = default(IntPtr)
        };
        Flex.Library    lib    = Flex.Init(Flex.FLEX_VERSION, ErrorCallback, ref desc);
        Flex.SolverDesc slvDsc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref slvDsc);
        slvDsc.maxParticles = 1000;
        Flex.Solver solver = Flex.CreateSolver(lib, ref slvDsc);

        FlexExt.Container container = FlexExt.CreateContainer(lib, solver, 10000);
        FlexExt.DestroyContainer(container);

        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }
    public void TestCreateDestroyContainer()
    {
        Flex.Library    lib    = Flex.Init(Flex.FLEX_VERSION, ErrorCallback);
        Flex.SolverDesc slvDsc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref slvDsc);
        slvDsc.maxParticles = 1000;
        Flex.Solver solver = Flex.CreateSolver(lib, ref slvDsc);

        FlexExt.Container container = FlexExt.CreateContainer(lib, solver, 10000);
        FlexExt.DestroyContainer(container);

        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }
    public void TestLockUnlockShapeData()
    {
        Flex.Library    lib    = Flex.Init(Flex.FLEX_VERSION, ErrorCallback);
        Flex.SolverDesc slvDsc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref slvDsc);
        slvDsc.maxParticles = 1000;
        Flex.Solver       solver    = Flex.CreateSolver(lib, ref slvDsc);
        FlexExt.Container container = FlexExt.CreateContainer(lib, solver, 1000);

        FlexExt.ShapeData data = FlexExt.MapShapeData(container);

        Assert.AreNotEqual(IntPtr.Zero, data.positions);

        FlexExt.UnmapShapeData(container);

        FlexExt.DestroyContainer(container);
        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }
    public void TestAllocateFreeParticles()
    {
        Flex.Library    lib    = Flex.Init(Flex.FLEX_VERSION, ErrorCallback);
        Flex.SolverDesc slvDsc = default(Flex.SolverDesc);
        Flex.SetSolverDescDefaults(ref slvDsc);
        slvDsc.maxParticles = 1000;
        Flex.Solver       solver    = Flex.CreateSolver(lib, ref slvDsc);
        FlexExt.Container container = FlexExt.CreateContainer(lib, solver, 1000);

        int n = 1000;

        int[] indices = new int[n];

        int m = FlexExt.AllocParticles(container, n, ref indices[0]);

        Assert.AreEqual(n, m);

        FlexExt.FreeParticles(container, n, ref indices[0]);

        FlexExt.DestroyContainer(container);
        Flex.DestroySolver(solver);
        Flex.Shutdown(lib);
    }