示例#1
0
 public void Schedule(DrawingData gizmos, Camera camera)
 {
     if (type != Type.Static)
     {
         unsafe {
             buildJob = CommandBuilder.Build(gizmos, (MeshBuffers *)NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(temporaryMeshBuffers), camera, splitterJob);
         }
     }
 }
示例#2
0
 public void Release(DrawingData gizmos)
 {
     if (!isValid)
     {
         throw new System.InvalidOperationException();
     }
     type = Type.Invalid;
     splitterJob.Complete();
     buildJob.Complete();
     PoolMeshes(gizmos);
 }
示例#3
0
 void PoolMeshes(DrawingData gizmos)
 {
     if (type != Type.CustomMeshes)
     {
         for (int i = 0; i < meshes.Count; i++)
         {
             gizmos.PoolMesh(meshes[i].mesh);
         }
     }
     meshes.Clear();
 }
示例#4
0
            public void Submit(DrawingData gizmos)
            {
                if (state != State.Initialized)
                {
                    throw new System.InvalidOperationException();
                }

                meta.version = gizmos.version;

                // Command stream
                // split to static, dynamic and persistent
                // render static
                // render dynamic per camera
                // render persistent per camera
                int staticBuffer     = gizmos.processedData.Reserve(ProcessedBuilderData.Type.Static, meta);
                int dynamicBuffer    = gizmos.processedData.Reserve(ProcessedBuilderData.Type.Dynamic, meta);
                int persistentBuffer = gizmos.processedData.Reserve(ProcessedBuilderData.Type.Persistent, meta);

                unsafe {
                    splitterJob = new CommandBuilder.StreamSplitter {
                        inputBuffers     = commandBuffers,
                        staticBuffer     = gizmos.processedData.Get(staticBuffer).splitterOutputPtr,
                        dynamicBuffer    = gizmos.processedData.Get(dynamicBuffer).splitterOutputPtr,
                        persistentBuffer = gizmos.processedData.Get(persistentBuffer).splitterOutputPtr,
                    }.Schedule();
                }

                gizmos.processedData.Get(staticBuffer).SetSplitterJob(gizmos, splitterJob);
                gizmos.processedData.Get(dynamicBuffer).SetSplitterJob(gizmos, splitterJob);
                gizmos.processedData.Get(persistentBuffer).SetSplitterJob(gizmos, splitterJob);

                if (meshes.Count > 0)
                {
                    var customMeshes = gizmos.processedData.Get(gizmos.processedData.Reserve(ProcessedBuilderData.Type.CustomMeshes, meta)).meshes;
                    // Copy meshes to render
                    for (int i = 0; i < meshes.Count; i++)
                    {
                        customMeshes.Add(new MeshWithType {
                            mesh = meshes[i], lines = false
                        });
                    }
                    meshes.Clear();
                }

                // TODO: Allocate 3 output objects and pipe splitter to them

                // Only meshes valid for all cameras have been submitted.
                // Meshes that depend on the specific camera will be submitted just before rendering
                // that camera. Line drawing depends on the exact camera.
                // In particular when drawing circles different number of segments
                // are used depending on the distance to the camera.
                state = State.WaitingForSplitter;
            }
示例#5
0
 public void BuildMeshes(DrawingData gizmos)
 {
     if ((type == Type.Static && submitted) || type == Type.CustomMeshes)
     {
         return;
     }
     buildJob.Complete();
     unsafe {
         PoolMeshes(gizmos);
         CommandBuilder.BuildMesh(gizmos, meshes, (MeshBuffers *)temporaryMeshBuffers.GetUnsafePtr());
     }
     submitted = true;
 }
示例#6
0
 public void ReleaseAllWithHash(DrawingData gizmos, Hasher hasher)
 {
     if (data == null)
     {
         return;
     }
     for (int i = 0; i < data.Length; i++)
     {
         if (data[i].isValid && data[i].meta.hasher.Hash == hasher.Hash)
         {
             Release(gizmos, i);
         }
     }
 }
示例#7
0
 public void ReleaseDataOlderThan(DrawingData gizmos, int version)
 {
     if (data == null)
     {
         return;
     }
     for (int i = 0; i < data.Length; i++)
     {
         if (data[i].isValid && data[i].meta.version < version)
         {
             Release(gizmos, i);
         }
     }
 }
示例#8
0
 public void Dispose(DrawingData gizmos)
 {
     if (data == null)
     {
         return;
     }
     for (int i = 0; i < data.Length; i++)
     {
         if (data[i].isValid)
         {
             Release(gizmos, i);
         }
         data[i].Dispose();
     }
     // Ensures calling Dispose multiple times is a NOOP
     data = null;
 }
示例#9
0
            public void SetSplitterJob(DrawingData gizmos, JobHandle splitterJob)
            {
                this.splitterJob = splitterJob;
                if (type == Type.Static)
                {
                    unsafe {
                        buildJob = CommandBuilder.Build(gizmos, (MeshBuffers *)NativeArrayUnsafeUtility.GetUnsafeBufferPointerWithoutChecks(temporaryMeshBuffers), null, splitterJob);
                    }

                    SubmittedJobs++;
                    // ScheduleBatchedJobs is expensive, so only do it once in a while
                    if (SubmittedJobs % 8 == 0)
                    {
                        Profiler.BeginSample("ScheduleJobs");
                        JobHandle.ScheduleBatchedJobs();
                        Profiler.EndSample();
                    }
                }
            }
示例#10
0
 public void SubmitMeshes(DrawingData gizmos, Camera camera, int versionThreshold, bool allowGizmos)
 {
     if (data == null)
     {
         return;
     }
     for (int i = 0; i < data.Length; i++)
     {
         if (data[i].isValid && data[i].meta.version >= versionThreshold && (allowGizmos || !data[i].meta.isGizmos))
         {
             data[i].Schedule(gizmos, camera);
         }
     }
     for (int i = 0; i < data.Length; i++)
     {
         if (data[i].isValid && data[i].meta.version >= versionThreshold && (allowGizmos || !data[i].meta.isGizmos))
         {
             data[i].BuildMeshes(gizmos);
         }
     }
 }
示例#11
0
        void OnEnable()
        {
            if (_instance == null)
            {
                _instance = this;
            }

            // Ensure we don't have duplicate managers
            if (_instance != this)
            {
                // We cannot destroy the object while it is being enabled, so we need to delay it a bit
#if UNITY_EDITOR
                // This is only important in the editor to avoid a build-up of old managers.
                // In an actual game at most 1 (though in practice zero) old managers will be laying around.
                // It would be nice to use a coroutine for this instead, but unfortunately they do not work for objects marked with HideAndDontSave.
                EditorApplication.update += DelayedDestroy;
#endif
                return;
            }

            actuallyEnabled = true;
            if (gizmos == null)
            {
                gizmos = new DrawingData();
            }
            gizmos.frameRedrawScope = new RedrawScope(gizmos);
            Draw.builder            = gizmos.GetBuiltInBuilder(false);
            Draw.ingame_builder     = gizmos.GetBuiltInBuilder(true);
            commandBuffer           = new CommandBuffer();
            commandBuffer.name      = "ALINE Gizmos";

            // Callback when rendering with the built-in render pipeline
            Camera.onPostRender += PostRender;
            // Callback when rendering with a scriptable render pipeline
            UnityEngine.Rendering.RenderPipelineManager.beginFrameRendering += BeginFrameRendering;
            UnityEngine.Rendering.RenderPipelineManager.endCameraRendering  += EndCameraRendering;
#if UNITY_EDITOR
            EditorApplication.update += OnUpdate;
#endif
        }
示例#12
0
 void Release(DrawingData gizmos, int i)
 {
     data[i].Release(gizmos);
     freeSlots.Push(i);
 }
示例#13
0
 public RedrawScope(DrawingData gizmos)
 {
     this.gizmos = gizmos;
     // Should be enough with 4 billion ids before they wrap around.
     id = idCounter++;
 }