예제 #1
0
    void UpdateLayer(LayerRender layer)
    {
        int jobID = ChunkRendererPool.instance.AddJob(m_x, m_z, layer.layerIndex, m_chunk.world);
        var item  = m_waitingJobs.Find(x => { return(x.jobID == jobID); });

        if (item == null)
        {
            WaitingJob job = new WaitingJob();
            job.jobID      = jobID;
            job.layerIndex = layer.layerIndex;
            m_waitingJobs.Add(job);
        }
    }
        public void TestWaitingJob()
        {
            var sw    = new DebugStopwatch();
            var queue = new LongJobQueue(sw);

            var tcs = new TaskCompletionSource <object>();

            var job = new WaitingJob(tcs.Task);

            queue.EnqueueJob(job);

            queue.Process();
            Assert.That(job.Status, Is.EqualTo(JobStatus.Waiting));
            queue.Process();
            Assert.That(job.Status, Is.EqualTo(JobStatus.Waiting));
            tcs.SetResult(1);
            queue.Process();
            Assert.That(job.Status, Is.EqualTo(JobStatus.Finished));

            Assert.That(job.Result, Is.EqualTo("oof!"));
        }
예제 #3
0
    //return true if updated
    bool CheckLayerUpdated(WaitingJob job)
    {
        var layer = m_layers.Find(x => { return(x.layerIndex == job.layerIndex); });

        if (layer == null)
        {
            ChunkRendererPool.instance.FreeJob(job.jobID);
            return(true);
        }

        var meshParams = ChunkRendererPool.instance.GetJobData(job.jobID);

        if (meshParams == null)
        {
            //no job ? create it again !
            if (!ChunkRendererPool.instance.HaveJob(job.jobID))
            {
                job.jobID = ChunkRendererPool.instance.AddJob(m_x, m_z, job.layerIndex, m_chunk.world);
            }
            return(false);
        }

        var materials = meshParams.GetNonEmptyMaterials();
        int nbMesh    = 0;

        foreach (var m in materials)
        {
            nbMesh += meshParams.GetMeshCount(m);
        }
        int nbColliderMesh = meshParams.GetColliderMeshCount();

        //remove
        while (layer.objects.Count > nbMesh)
        {
            var l = layer.objects[layer.objects.Count - 1];
            if (l.meshFilter.mesh != null)
            {
                Destroy(l.meshFilter.mesh);
            }
            Destroy(l.meshFilter.gameObject);
            layer.objects.RemoveAt(layer.objects.Count - 1);
        }

        while (layer.colliders.Count > nbColliderMesh)
        {
            var l = layer.colliders[layer.colliders.Count - 1];
            if (l.sharedMesh != null)
            {
                Destroy(l.sharedMesh);
            }
            Destroy(l.gameObject);
            layer.colliders.RemoveAt(layer.colliders.Count - 1);
        }

        //add
        while (layer.objects.Count < nbMesh)
        {
            layer.objects.Add(CreateNewLayerObject(layer.layerIndex));
        }

        while (layer.colliders.Count < nbColliderMesh)
        {
            layer.colliders.Add(CreateNewLayerCollider(layer.layerIndex));
        }

        //set
        int meshIndex = 0;

        foreach (var m in materials)
        {
            nbMesh = meshParams.GetMeshCount(m);

            for (int i = 0; i < nbMesh; i++)
            {
                var obj = layer.objects[meshIndex];
                UpdateLayerObject(obj, m, i, meshParams);
            }
        }

        for (int i = 0; i < nbColliderMesh; i++)
        {
            var obj = layer.colliders[i];
            UpdateLayerCollider(obj, i, meshParams);
        }

        ChunkRendererPool.instance.FreeJob(job.jobID);

        return(true);
    }