/**
         * Main Update Method
         */
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            int numOFProjectiles = _data.Length;
            int batchSize        = 500;

            var raycastCommands = new NativeArray <RaycastCommand>(numOFProjectiles, Allocator.TempJob);
            var raycastHits     = new NativeArray <RaycastHit>(numOFProjectiles, Allocator.TempJob);

            var raycastCommandsJob = new PrepareRaycastCommands
            {
                DeltaTime   = Time.deltaTime,
                Commands    = raycastCommands,
                Projectiles = _data.Projectile
            };

            // SCHEDULE Job for creating raycast commands
            JobHandle raycastDependency =
                raycastCommandsJob.Schedule(numOFProjectiles, batchSize);

            // SCHEDULE Raycast job
            JobHandle raycastJobHandle =
                RaycastCommand.ScheduleBatch(raycastCommands, raycastHits, batchSize, raycastDependency);

            // Update Projectiles with new state
            var projectileStateUpdate = new ProjectileHitUpdateJob
            {
                Projectiles   = _data.Projectile,
                RaycastHits   = raycastHits,
                Entities      = _data.Entities,
                CommandBuffer = _jobBarrier.CreateCommandBuffer().ToConcurrent()
            };

            JobHandle stateUpdateJob = projectileStateUpdate.Schedule(numOFProjectiles, batchSize, raycastJobHandle);

            stateUpdateJob.Complete();

            raycastCommands.Dispose();
            raycastHits.Dispose();

            return(stateUpdateJob);
        }
    void Update()
    {
        // only do an update if the data has been initialized
        if (!positions.IsCreated)
        {
            return;
        }

        var deltaTime = Time.deltaTime;

        // FORCE ACCUMILATION

        // First off lets apply gravity to all the object in our scene that arnt currently asleep
        var gravityJob = new GravityJob()
        {
            DeltaTime  = deltaTime,
            Gravity    = gravity,
            Velocities = velocities,
            Sleeping   = sleeping
        };
        var gravityDependency = gravityJob.Schedule(objectCount, 32);

        // TODO accumilate other forces here! gravity is just the simplest force to apply to our objects,
        // but theres no limit on the kind of forces we can simulate. We could add friction, air resistnace,
        // constant acceleration, joints and constrainsts, boyancy.. anything we can think of that can effect
        // the velocity of an object can have its own job scheduled here.

        // INTERGRATION AND COLLISION

        // Create temporary arrays for the raycast info. Lets use the TempJob allocator,
        // this means we have to dispose them when the job has finished - its short lived data
        var raycastCommands = new NativeArray <RaycastCommand>(objectCount, Allocator.TempJob);
        var raycastHits     = new NativeArray <RaycastHit>(objectCount, Allocator.TempJob);

        // Lets schedule jobs to do a collision raycast for each object. One job Prepare    s all the raycast commands,
        // the second actually does the raycasts.
        var setupRaycastsJob = new PrepareRaycastCommands()
        {
            DeltaTime  = deltaTime,
            Positions  = positions,
            Raycasts   = raycastCommands,
            Velocities = velocities
        };

        var setupDependency = setupRaycastsJob.Schedule(objectCount, 32, gravityDependency);

        // BUG| WORKAROUND - Checked against Unity 2018.1b8
        // BUG| RaycastCommand seems to be ignoring any passed in dependencies. We have to explicity wait here.
        // BUG| This has been reported to Unity and fixed. When the fix appears in public betas this can be removed.
        setupDependency.Complete();
        // BUG| END WORKAROUND

        var raycastDependency = RaycastCommand.ScheduleBatch(raycastCommands, raycastHits, 32, setupDependency);

        // Now we know if there is a collision along our velocity vector, its time to integrate the velocity into
        // our objects for the current timeset.
        var integrateJob = new IntegratePhysics()
        {
            DeltaTime  = deltaTime,
            Positions  = positions,
            Velocities = velocities,
            Sleeping   = sleeping,
            Hits       = raycastHits
        };
        var integrateDependency = integrateJob.Schedule(objectCount, 32, raycastDependency);

        // finally, respond to any collisions that happened in the lsat update step.
        var collisionResponeJob = new CalculateCollisionResponse()
        {
            Hits       = raycastHits,
            Velocities = velocities,
            Sleeping   = sleeping
        };
        var collisionDependency = collisionResponeJob.Schedule(objectCount, 32, integrateDependency);

        // Now the physics is done, we need to create a drawing matrix for every object. This simple demo dosnt
        // implment roation, so only the translation values in the matrix reallllly matter.
        var renderMatrixJob = new CalculateDrawMatricies()
        {
            positions      = positions,
            renderMatrices = renderMatrices
        };
        var matrixJob = renderMatrixJob.Schedule(objectCount, 32, collisionDependency);

        // All the jobs we want to execute have been scheduled! By calling .Complete() on the last job in the
        // chain, Unity makes the main thread help out with scheduled jobs untill they are all complete.
        // then we can move on and use the data caluclated in the jobs safely, without worry about data being changed
        // by other threads as we try to use it - we *know* all the work is done
        matrixJob.Complete();

        // make sure we dispose of the temporary NativeArrays we used for raycasting
        raycastCommands.Dispose();
        raycastHits.Dispose();

        // Well, all the updating is done! lets actually issue a draw!
        Graphics.DrawMeshInstanced(mesh, 0, material, renderMatrices.ToArray());

        // DEBUG 1 - draw red lines showing object velocity
        //for (int i = 0; i < objectCount; i++)
        //{
        ///   Debug.DrawLine(positions[i], positions[i] + velocities[i], Color.red, 0.016f, true);
        //}

        // DEBUG 2 - draw a trail for a few objects, really helps to visualize the bounce!
        //var duration = 01f;
        //Debug.DrawLine(positions[0], positions[0] + velocities[0], Color.red, duration, true);
        //Debug.DrawLine(positions[200], positions[200] + velocities[200], Color.cyan, duration, true);
        //Debug.DrawLine(positions[400], positions[400] + velocities[400], Color.green, duration, true);
        //Debug.DrawLine(positions[600], positions[600] + velocities[600], Color.magenta, duration, true);
        //Debug.DrawLine(positions[800], positions[800] + velocities[800], Color.yellow, duration, true);
        //Debug.DrawLine(positions[1000], positions[1000] + velocities[1000], Color.blue, duration, true);
        //Debug.DrawLine(positions[100], positions[100] + velocities[100], Color.red, duration, true);
        //Debug.DrawLine(positions[300], positions[300] + velocities[300], Color.cyan, duration, true);
        //Debug.DrawLine(positions[500], positions[500] + velocities[500], Color.green, duration, true);
        //Debug.DrawLine(positions[700], positions[700] + velocities[700], Color.magenta, duration, true);
        //Debug.DrawLine(positions[900], positions[900] + velocities[900], Color.yellow, duration, true);

        // finally lets respawn any object that has been asleep and stable for a while
        // TODO as of Unity 2018.1b6, NativeArray is the only native collection type. When
        // NativeQueue is included in the beta this last task can be jobified!
        for (int i = 0; i < objectCount; i++)
        {
            if (sleeping[i] > 15)
            {
                Respawn(i);
            }
        }
    }
Пример #3
0
    void Update()
    {
        // only do an update if the data has been initialized
        if (!positions.IsCreated)
        {
            return;
        }

        sampler.Begin();

        var deltaTime = Time.deltaTime;

        // FORCE ACCUMILATION

        // First off lets apply gravity to all the object in our scene that arnt currently asleep
        var gravityJob = new GravityJob()
        {
            DeltaTime  = deltaTime,
            Gravity    = gravity,
            Velocities = velocities,
            Sleeping   = sleepingTimer
        };
        var gravityDependency = gravityJob.Schedule(objectCount, 32);

        // TODO accumilate other forces here! gravity is just the simplest force to apply to our objects,
        // but theres no limit on the kind of forces we can simulate. We could add friction, air resistnace,
        // constant acceleration, joints and constrainsts, boyancy.. anything we can think of that can effect
        // the velocity of an object can have its own job scheduled here.

        // INTERGRATION AND COLLISION

        // Create temporary arrays for the raycast info. Lets use the TempJob allocator,
        // this means we have to dispose them when the job has finished - its short lived data
        var raycastCommands = new NativeArray <RaycastCommand>(objectCount, Allocator.TempJob);
        var raycastHits     = new NativeArray <RaycastHit>(objectCount, Allocator.TempJob);

        // Lets schedule jobs to do a collision raycast for each object. One job Prepare    s all the raycast commands,
        // the second actually does the raycasts.
        var setupRaycastsJob = new PrepareRaycastCommands()
        {
            DeltaTime  = deltaTime,
            Positions  = positions,
            Raycasts   = raycastCommands,
            Velocities = velocities
        };

        var setupDependency = setupRaycastsJob.Schedule(objectCount, 32, gravityDependency);

        var raycastDependency = RaycastCommand.ScheduleBatch(raycastCommands, raycastHits, 32, setupDependency);

        // Now we know if there is a collision along our velocity vector, its time to integrate the velocity into
        // our objects for the current timeset.
        var integrateJob = new IntegratePhysics()
        {
            DeltaTime  = deltaTime,
            Positions  = positions,
            Velocities = velocities,
            Sleeping   = sleepingTimer,
            Hits       = raycastHits
        };
        var integrateDependency = integrateJob.Schedule(objectCount, 32, raycastDependency);

        // finally, respond to any collisions that happened in the lsat update step.
        var collisionResponeJob = new CalculateCollisionResponse()
        {
            Hits       = raycastHits,
            Velocities = velocities,
            Sleeping   = sleepingTimer
        };
        var collisionDependency = collisionResponeJob.Schedule(objectCount, 32, integrateDependency);

        // Now the physics is done, we need to create a drawing matrix for every object. This simple demo dosnt
        // implment roation, so only the translation values in the matrix reallllly matter.
        var renderMatrixJob = new CalculateDrawMatricies()
        {
            positions      = positions,
            renderMatrices = renderMatrices
        };
        var matrixDependency = renderMatrixJob.Schedule(objectCount, 32, collisionDependency);

        // All the jobs we want to execute have been scheduled! By calling .Complete() on the last job in the
        // chain, Unity makes the main thread help out with scheduled jobs untill they are all complete.
        // then we can move on and use the data caluclated in the jobs safely, without worry about data being changed
        // by other threads as we try to use it - we *know* all the work is done
        matrixDependency.Complete();

        // make sure we dispose of the temporary NativeArrays we used for raycasting
        raycastCommands.Dispose();
        raycastHits.Dispose();

        // lets schedule a job to figure out which objects are sleeping - this can run in the background whilst
        // we dispach the drawing commands for this frame.
        var sleepJob = new FindSleepingObjects()
        {
            Sleeping   = sleepingTimer,
            SleepQueue = asleep.AsParallelWriter()
        };
        var sleepDependancy = sleepJob.Schedule(objectCount, 32, matrixDependency);

        //  lets actually issue a draw!
        renderMatrices.CopyTo(renderMatrixArray); // copy to a preallocated array, we would get garbage from ToArray()
        Graphics.DrawMeshInstanced(mesh, 0, material, renderMatrixArray);

        // DEBUG 1 - draw red lines showing object velocity
        //for (int i = 0; i < objectCount; i++)
        //{
        ///   Debug.DrawLine(positions[i], positions[i] + velocities[i], Color.red, 0.016f, true);
        //}

        // DEBUG 2 - draw a trail for a few objects, really helps to visualize the bounce!
        //var duration = 01f;
        //Debug.DrawLine(positions[0], positions[0] + velocities[0], Color.red, duration, true);
        //Debug.DrawLine(positions[200], positions[200] + velocities[200], Color.cyan, duration, true);
        //Debug.DrawLine(positions[400], positions[400] + velocities[400], Color.green, duration, true);
        //Debug.DrawLine(positions[600], positions[600] + velocities[600], Color.magenta, duration, true);
        //Debug.DrawLine(positions[800], positions[800] + velocities[800], Color.yellow, duration, true);
        //Debug.DrawLine(positions[1000], positions[1000] + velocities[1000], Color.blue, duration, true);
        //Debug.DrawLine(positions[100], positions[100] + velocities[100], Color.red, duration, true);
        //Debug.DrawLine(positions[300], positions[300] + velocities[300], Color.cyan, duration, true);
        //Debug.DrawLine(positions[500], positions[500] + velocities[500], Color.green, duration, true);
        //Debug.DrawLine(positions[700], positions[700] + velocities[700], Color.magenta, duration, true);
        //Debug.DrawLine(positions[900], positions[900] + velocities[900], Color.yellow, duration, true);

        // finally lets respawn any object that has been found to be asleep (ie not moved for 15 frames)
        // were going to respawn that object so there is a constant flow
        sleepDependancy.Complete();
        for (int i = asleep.Count; i != 0; i--)
        {
            int index = asleep.Dequeue();
            Respawn(index);
        }



        sampler.End();
    }
Пример #4
0
        public void Bake(int raySamples, List <Renderer> renderers, Action <SDFVolume, float[], float, object> bakeComplete, object passthrough = null)
        {
            onBakeComplete = bakeComplete;

            int progressInterval = _settings.CellCount / 4;
            int progress         = 0;

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();

            vec3  halfVoxel   = _settings.HalfVoxel;
            float maxDistance = 0f;

            //adjusted to best timings from testing but it could vary by CPU
            int calcRayLengthBatchCount = 32;

            calcRayLengthBatchCount = Mathf.Clamp(calcRayLengthBatchCount, 1, raySamples);
            int raycastBatchCount = 8;

            raycastBatchCount = Mathf.Clamp(raycastBatchCount, 1, raySamples);
            int prepareRaysBatchCount = 64;

            prepareRaysBatchCount = Mathf.Clamp(prepareRaysBatchCount, 1, raySamples);
            int compareBatchCount = 128;

            //for raycast method front facing geo and flipped backfacing geo is required
            List <Collider> geoFront = new List <Collider>();
            List <Collider> geoBack  = new List <Collider>();

            CreateColliders(ref renderers, ref geoFront, ref geoBack);

            //prepare data
            NativeArray <float>       distances  = new NativeArray <float>(_settings.CellCount, Allocator.TempJob);
            NativeArray <CellResults> allResults = new NativeArray <CellResults>(_settings.CellCount, Allocator.TempJob);

            //constant for all cells
            NativeArray <vec3> sphereSamples = new NativeArray <vec3>(raySamples, Allocator.TempJob);
            //NativeArray<vec3> randomDirections = new NativeArray<vec3>(raySamples, Allocator.TempJob);
            NativeArray <vec4> volumePlanes = new NativeArray <vec4>(6, Allocator.TempJob);

            GetUniformPointsOnSphereNormalized(ref sphereSamples);
            //GetRandomDirections( _halfVoxel*settings.JitterScale, settings.JitterSeed, ref randomDirections);

            vec3 aabbMin = BoundsWorldAABB.min;
            vec3 aabbMax = BoundsWorldAABB.max;
            //the max ray length, used to normalize all resulting distances
            //so they are treated as 0 to 1 within a volume
            float aabbMagnitude = BoundsWorldAABB.size.magnitude;

            Plane pl = new Plane(Vector3.right, aabbMin);
            Plane pr = new Plane(Vector3.left, aabbMax);
            Plane pd = new Plane(Vector3.up, aabbMin);
            Plane pu = new Plane(Vector3.down, aabbMax);
            Plane pb = new Plane(Vector3.forward, aabbMin);
            Plane pf = new Plane(Vector3.back, aabbMax);

            volumePlanes[0] = new vec4(pl.normal.x, pl.normal.y, pl.normal.z, pl.distance);
            volumePlanes[1] = new vec4(pr.normal.x, pr.normal.y, pr.normal.z, pr.distance);
            volumePlanes[2] = new vec4(pd.normal.x, pd.normal.y, pd.normal.z, pd.distance);
            volumePlanes[3] = new vec4(pu.normal.x, pu.normal.y, pu.normal.z, pu.distance);
            volumePlanes[4] = new vec4(pb.normal.x, pb.normal.y, pb.normal.z, pb.distance);
            volumePlanes[5] = new vec4(pf.normal.x, pf.normal.y, pf.normal.z, pf.distance);

            //iterate each cell performing raycasted samples
            for (int i = 0; i < _settings.CellCount; i++)
            {
#if UNITY_EDITOR
                if (i % progressInterval == 0)
                {
                    EditorUtility.DisplayProgressBar(strProgressTitle, strProgress, i / (float)_settings.CellCount);
                }
#endif

                vec3 positionWS    = _settings.ToPositionWS(i, LocalToWorldNoScale);
                vec3 centerVoxelWS = positionWS + halfVoxel;

                NativeArray <float>          rayLengths       = new NativeArray <float>(raySamples, Allocator.TempJob);
                NativeArray <RaycastCommand> allRaycastsFront = new NativeArray <RaycastCommand>(raySamples, Allocator.TempJob);
                NativeArray <RaycastCommand> allRaycastsBack  = new NativeArray <RaycastCommand>(raySamples, Allocator.TempJob);
                NativeArray <RaycastHit>     frontHits        = new NativeArray <RaycastHit>(raySamples, Allocator.TempJob);
                NativeArray <RaycastHit>     backHits         = new NativeArray <RaycastHit>(raySamples, Allocator.TempJob);

                //calculate the ray lengths, just so rays are clipped within the volume when raycasting
                CalculateRayLengths calcRayLengths = new CalculateRayLengths
                {
                    Samples      = sphereSamples,
                    VolumePlanes = volumePlanes,
                    RayLengths   = rayLengths,
                    RayLength    = aabbMagnitude,
                    RayOrigin    = centerVoxelWS
                };
                JobHandle rayLengthHandle = calcRayLengths.Schedule(raySamples, calcRayLengthBatchCount);

                //prepare raycasts front
                PrepareRaycastCommands frontPrc = new PrepareRaycastCommands
                {
                    Samples    = sphereSamples,
                    RayLengths = rayLengths,
                    LayerMask  = LAYER_MASK_FRONT,
                    Raycasts   = allRaycastsFront,
                    RayOrigin  = centerVoxelWS,
                };
                //prepare raycasts back
                PrepareRaycastCommands backPrc = new PrepareRaycastCommands
                {
                    Samples    = sphereSamples,
                    RayLengths = rayLengths,
                    LayerMask  = LAYER_MASK_BACK,
                    Raycasts   = allRaycastsBack,
                    RayOrigin  = centerVoxelWS,
                };

                //schedule front raycasts
                JobHandle prepareFrontHandle = frontPrc.Schedule(
                    raySamples, prepareRaysBatchCount, rayLengthHandle);
                JobHandle scheduleFrontHandle = RaycastCommand.ScheduleBatch(
                    allRaycastsFront, frontHits, raycastBatchCount, prepareFrontHandle);

                //schedule back raycasts
                JobHandle prepareBackHandle = backPrc.Schedule(
                    raySamples, prepareRaysBatchCount, rayLengthHandle);
                JobHandle scheduleBackHandle = RaycastCommand.ScheduleBatch(
                    allRaycastsBack, backHits, raycastBatchCount, prepareBackHandle);

                //combine handles
                JobHandle frontBackHandle = JobHandle.CombineDependencies(scheduleFrontHandle, scheduleBackHandle);

                //process results and put into current cell index
                ProcessHits processHits = new ProcessHits
                {
                    FrontHits = frontHits,
                    BackHits  = backHits,
                    Results   = allResults.Slice(i, 1),
                };

                JobHandle cellHandle = processHits.Schedule(frontBackHandle);
                cellHandle.Complete();

                rayLengths.Dispose();
                allRaycastsFront.Dispose();
                allRaycastsBack.Dispose();
                frontHits.Dispose();
                backHits.Dispose();
            } //for each cell

            //final distances
            CompareDistances compareDistances = new CompareDistances
            {
                Distances = distances,
                Results   = allResults
            };

            JobHandle compareDistancesHandle = compareDistances.Schedule(_settings.CellCount, compareBatchCount);
            compareDistancesHandle.Complete();

            stopwatch.Stop();
            Debug.Log("SDF bake completed in " + stopwatch.Elapsed.ToString("mm\\:ss\\.ff"));
#if UNITY_EDITOR
            EditorUtility.ClearProgressBar();
#endif
            float[] distancesOut = new float[_settings.CellCount];
            distances.CopyTo(distancesOut);

            //cleanup all the temp arrays
            distances.Dispose();
            allResults.Dispose();
            sphereSamples.Dispose();
            //randomDirections.Dispose();
            volumePlanes.Dispose();

            foreach (var c in geoFront)
            {
                Object.DestroyImmediate(c.gameObject);
            }
            foreach (var c in geoBack)
            {
                Object.DestroyImmediate(c.gameObject);
            }

            //NOTE do not use max distance, instead use aabbMagnitude so distance fields are interchangeable
            bakeComplete?.Invoke(this, distancesOut, aabbMagnitude, passthrough);
        }
Пример #5
0
        public void Generate()
        {
            if (mesh == null)
            {
                mesh = new Mesh();
            }

            if (useSeed)
            {
                Random.InitState(randomSeed);
            }

            Vector3[] TEMPpositions = GeneratePositions();
            amount = TEMPpositions.Length;

            NativeArray <Vector3> rayPositions = new NativeArray <Vector3>(amount, Allocator.TempJob);
            NativeArray <Vector3> vertices     = new NativeArray <Vector3>(amount, Allocator.TempJob);
            NativeArray <int>     indices      = new NativeArray <int>(amount, Allocator.TempJob);
            NativeArray <Vector3> normals      = new NativeArray <Vector3>(amount, Allocator.TempJob);
            NativeArray <Vector4> tangents     = new NativeArray <Vector4>(amount, Allocator.TempJob);
            NativeArray <Color>   colors       = new NativeArray <Color>(amount, Allocator.TempJob);

            //Copy generated positions
            rayPositions.CopyFrom(TEMPpositions);

            for (int i = 0; i < amount; i++)
            {
                colors[i] = new Color(
                    Random.Range(grassHeightRange.x, grassHeightRange.y), //Height
                    1,                                                    //This is used by the wind, but could be saved and used before the wind is applied
                    Random.Range(grassWidthRange.x, grassWidthRange.y));  //Width;
            }

            var raycastCommands = new NativeArray <RaycastCommand>(amount, Allocator.TempJob);
            NativeArray <RaycastHit> raycastHits = new NativeArray <RaycastHit>(amount, Allocator.TempJob);

            var setupRaycastsJob = new PrepareRaycastCommands()
            {
                Raycasts  = raycastCommands,
                Positions = rayPositions
            };

            var setupDependency = setupRaycastsJob.Schedule(amount, 32, default(JobHandle));

            var raycastDependency = RaycastCommand.ScheduleBatch(raycastCommands, raycastHits, 32, setupDependency);

            raycastDependency.Complete();

            var setupMeshDataJob = new PrepareMeshData()
            {
                Vertices    = vertices,
                Indices     = indices,
                Normals     = normals,
                Tangents    = tangents,
                Colors      = colors,
                hit         = raycastHits,
                ObjPosition = transform.position
            };

            var setupMeshDependency = setupMeshDataJob.Schedule(amount, 32, raycastDependency);

            setupMeshDependency.Complete();

            mesh.Clear();
#if UNITY_2019_3_OR_NEWER
            mesh.SetVertices(vertices);
            mesh.SetIndices(indices, MeshTopology.Points, 0);
            mesh.SetNormals(normals);
            mesh.SetTangents(tangents);
            mesh.SetColors(colors);
#else
            mesh.vertices = vertices.ToArray();
            mesh.SetIndices(indices.ToArray(), MeshTopology.Points, 0);
            mesh.normals  = normals.ToArray();
            mesh.tangents = tangents.ToArray();
            mesh.colors   = colors.ToArray();
#endif

            meshFilter.sharedMesh = mesh;

            raycastCommands.Dispose();
            raycastHits.Dispose();
            rayPositions.Dispose();
            vertices.Dispose();
            indices.Dispose();
            normals.Dispose();
            tangents.Dispose();
            colors.Dispose();
        }