private void Callback(AsyncGPUReadbackRequest request) { if (request.done) { if (request.hasError) { Debug.LogError("Has error!"); } // What the f**k is going on here!??! // request.GetData() doesn't match classic buffer.GetData() Debug.Log("Layer ct: " + request.layerCount); Debug.Log("LayerDataSize: " + request.layerDataSize); asyncEdgeVertices = request.GetData <GPUEdgeVertices>(0); Debug.Log("Done, length: " + asyncEdgeVertices.Length); Debug.Log("First index: " + asyncEdgeVertices[0].index); // In bytes check: var b = request.GetData <byte>(); Debug.Log("Byte length: " + b.Length); Debug.Log("GPUEdgeVertices vs byte compare: " + (float)b.Length / asyncEdgeVertices.Length); Debug.Log("Compare remainder: " + b.Length % asyncEdgeVertices.Length); Debug.Log("First byte: " + b[0]); } }
protected override void WriteFrame(AsyncGPUReadbackRequest r) { var format = Settings.GetCurrentEncoder().GetTextureFormat(Settings); Settings.m_EncoderManager.AddFrame(m_EncoderHandle, r.width, r.height, 0, format, r.GetData <byte>()); WarnOfConcurrentRecorders(); }
static void batched_OnGPUComplete(AsyncGPUReadbackRequest request) { if (request.hasError) { Debug.Log("GPU readback error detected."); return; } var result = request.GetData <Block>(); for (int i = 0; i < cs_generation_batchsize; i++) { if (CSGenerationQueue_waitForReadback[i] == null) { continue; } var chkResult = result.GetSubArray(32768 * i, 32768); CSGenerationQueue_waitForReadback[i].OnGPUFinish(chkResult); } blkBufOK = true; if (blkBufOK && strBufOK && strlenBufOK) { HandleStructures(); csgen_readingBack = false; } }
protected void OnCompleteAsyncReadback(AsyncGPUReadbackRequest request) { if (request.hasError) { Debug.LogError("Failed to read GPU texture"); return; } // Debug.Assert(request.done); if (request.done) { var readbackData = request.GetData <byte>(); camImageData.SetTextureBufferData(readbackData); var image = imageStamped.Image; if (image.Data.Length == camImageData.GetImageDataLength()) { var imageData = camImageData.GetImageData(); PostProcessing(ref imageData); // Debug.Log(imageStamped.Image.Height + "," + imageStamped.Image.Width); image.Data = imageData; if (GetParameters().save_enabled) { var saveName = name + "_" + Time.time; camImageData.SaveRawImageData(GetParameters().save_path, saveName); // Debug.LogFormat("{0}|{1} captured", GetParameters().save_path, saveName); } } readbackData.Dispose(); } }
void Update() { Graphics.Blit(m_CamTexture, m_FlatTexture); if (!m_PostReadbackJobHandle.IsCompleted) { m_PostReadbackJobHandle.Complete(); //m_LoadBuffer.LoadRawTextureData(m_ReadbackData); //m_LoadBuffer.Apply(); } if (!m_ReadbackRequest.done) { return; } if (m_ReadbackRequest.hasError) { Debug.LogError("error during readback ??"); } m_ReadbackRequest = AsyncGPUReadback.Request(m_FlatTexture, 0, request => { m_ReadbackData = request.GetData <Color32>(); var job = new PostReadJob() { pixels = m_ReadbackData }; m_PostReadbackJobHandle = job.Schedule(m_ReadbackData.Length, 1024); }); }
public void Generate() { int sizeOfChunk = chunkSize + 2; pointsBuffer.SetCounterValue(0); faceInfoBuffer.SetCounterValue(0); kernel = shader.FindKernel("Basic"); faceInfoBuffer.SetData(clearArray); shader.SetBuffer(kernel, "points", pointsBuffer); shader.SetInt("size_of_chunk", sizeOfChunk); shader.SetInt("height_of_chunk", chunkHeight + 2); shader.SetVector("offset", new Vector3(chunkOffset.x, chunkOffset.y, chunkOffset.z)); var groups = Mathf.CeilToInt(sizeOfChunk / 8.0f); var heightGroup = Mathf.CeilToInt(chunkHeight / 8.0f); shader.Dispatch(kernel, groups, heightGroup, groups); kernel = geomShader.FindKernel("Gen"); geomShader.SetBuffer(kernel, "face_info", faceInfoBuffer); geomShader.SetBuffer(kernel, "points", pointsBuffer); geomShader.SetInt("size_of_chunk", sizeOfChunk); geomShader.SetInt("height_of_chunk", chunkHeight + 2); geomShader.Dispatch(kernel, groups, heightGroup, groups); request = AsyncGPUReadback.Request(faceInfoBuffer); state = State.Loading; if (destroyed) { ClearBuffers(); } }
public void MoveRenderTexture(UMAData umaData, RenderTextureSource rts) { // Thread p = new Thread(new ParameterizedThreadStart(CopyRenderTexture(rts)) int arrayLen = 0; int width = rts.renderTexture.width; int height = rts.renderTexture.height; /* * for (int i=0; i< rts.renderTexture.mipmapCount; i++) * { * arrayLen += width * height * 4; * width >>= 1; * height >>= 1; * }*/ DestinationTextureHolder dtex = new DestinationTextureHolder(); dtex.CompleteArray = new NativeArray <uint>(arrayLen, Allocator.Persistent); /* dtex.mipCount = rts.renderTexture.mipmapCount; */ dtex.MipConverted = new bool[dtex.mipCount + 1]; dtex.isDisposed = false; for (int i = 0; i < rts.renderTexture.mipmapCount; i++) { AsyncGPUReadbackRequest agr = AsyncGPUReadback.Request(rts.renderTexture, i, TextureFormat.ARGB32, OnCompleteReadback); ReadBackTracker rbt = new ReadBackTracker(); rbt.request = agr; rbt.texSource = rts; rbt.umaData = umaData; rbt.texAccumulator = dtex; trackedItems.Add(agr, rbt); } }
private void OnSuccessedInternal(AsyncGPUReadbackRequest readback) { this.OnSuccessed(new FrameData() { readback = readback }); }
void OnCompleteReadback(AsyncGPUReadbackRequest request) { if (request.hasError) { Debug.LogError("GPU readback error detected"); return; } // This happens when the delayed async readback happens as we're exiting play mode if (instance == null || visibilityMaskTexture == null) { return; } // Read the color of the visibility mask texture to determine which visibility masks are active on cursor Texture2D visibilityMaskTex = new Texture2D( 1, 1, GraphicsFormatUtility.GetTextureFormat(visibilityMaskTexture.graphicsFormat), false ); visibilityMaskTex.LoadRawTextureData(request.GetData <Color32>()); visibilityMaskTex.Apply(); // Only one pixel so we can sample at 0, 0 Color sample = visibilityMaskTex.GetPixel(0, 0); visibilityMaskValue = DimensionShaderUtils.MaskValueFromSample(sample.linear); }
void EncodeImage(AsyncGPUReadbackRequest req, ulong timeStampNs) { if (m_Server == null) { return; } var spsNalu = new NativeList <byte>(Allocator.TempJob); var ppsNalu = new NativeList <byte>(Allocator.TempJob); var imageNalu = new NativeList <byte>(Allocator.TempJob); JobHandle prevJob = m_JobQueue.Count > 0 ? m_JobQueue.Peek().job : default(JobHandle); var encodeJob = m_Encoder.Encode(prevJob, req.GetData <byte>(), timeStampNs, ref spsNalu, ref ppsNalu, ref imageNalu); //Debug.Log("Encode image at t=" + timeStampNs); if (encodeJob.Equals(default(JobHandle))) { spsNalu.Dispose(); ppsNalu.Dispose(); imageNalu.Dispose(); return; } m_JobQueue.Enqueue(new JobItem { job = encodeJob, req = req, spsNalu = spsNalu, ppsNalu = ppsNalu, imageNalu = imageNalu, timeStampNs = timeStampNs }); }
public void GetResults() { if (resultData.Length == 0) { return; } while (asyncRequests.Count > 0) { AsyncGPUReadbackRequest asyncGPUReadbackRequest = asyncRequests.Peek(); if (asyncGPUReadbackRequest.hasError) { asyncRequests.Dequeue(); continue; } if (asyncGPUReadbackRequest.done) { NativeArray <Color32> data = asyncGPUReadbackRequest.GetData <Color32>(); for (int i = 0; i < data.Length; i++) { resultData[i] = data[i]; } asyncRequests.Dequeue(); continue; } break; } }
public void GetResults() { if (this.resultData.Length != 0) { while (this.asyncRequests.Count > 0) { AsyncGPUReadbackRequest asyncGPUReadbackRequest = this.asyncRequests.Peek(); if (!asyncGPUReadbackRequest.hasError) { if (!asyncGPUReadbackRequest.done) { break; } NativeArray <Color32> data = asyncGPUReadbackRequest.GetData <Color32>(0); for (int i = 0; i < data.Length; i++) { this.resultData[i] = data[i]; } this.asyncRequests.Dequeue(); } else { this.asyncRequests.Dequeue(); } } } }
public void Start() { Debug.Assert(Status != AsyncTextureReaderStatus.Reading); if (Type == ReadType.None) { return; } else if (Type == ReadType.Native) { NativeReadRequest = AsyncGPUReadback.Request(Texture, 0, NativeReadFormat); } else if (Type == ReadType.LinuxOpenGL) { if (LinuxId >= 0) { unsafe { AsyncTextureReaderImports.AsyncTextureReaderStart(LinuxId, new IntPtr(Data.GetUnsafePtr())); } GL.IssuePluginEvent(LinuxUpdate, LinuxId); } } Status = AsyncTextureReaderStatus.Reading; }
public void Capture() { if (useAsync) { bool done = false; while (requests.Count > 0) { AsyncGPUReadbackRequest req = requests.Peek(); if (req.hasError) { requests.Dequeue(); } else if (req.done) { tex.SetPixels32(req.GetData <Color32>().ToArray()); requests.Dequeue(); done = true; } else { break; } } if (done) { tex.Apply(); cam.targetTexture.DiscardContents(); } } }
public void Request(RenderTexture texture, int downsample, bool async) { if (texture == null) { Debug.LogError("Texture null."); return; } if (requested == true) { Debug.LogError("Already requested."); return; } if (buffer != null) { Debug.LogError("Buffer exists."); return; } originalSize.x = downsampledSize.x = texture.width; originalSize.y = downsampledSize.y = texture.height; for (var i = 0; i < downsample; i++) { if (downsampledSize.x > 2) { downsampledSize.x /= 2; } if (downsampledSize.y > 2) { downsampledSize.y /= 2; } } downsampleSteps = downsample; downsampleBoost = (originalSize.x / downsampledSize.x) * (originalSize.y / downsampledSize.y); var desc = texture.descriptor; desc.useMipMap = false; desc.width = downsampledSize.x; desc.height = downsampledSize.y; buffer = P3dHelper.GetRenderTexture(desc); P3dCommandReplace.Blit(buffer, texture, Color.white); #if ASYNC_READBACK_SUPPORTED if (async == true) { request = AsyncGPUReadback.Request(buffer, 0, TextureFormat.RGBA32); requested = true; UpdateRequest(); } else #endif { CompleteDirectly(); } }
public AsyncGPUReadbackRequestEntry(AsyncGPUReadbackRequest request, int layer, Action <NativeArray <TType> > callback) { Request = request; Callback = callback; Layer = layer; }
public virtual void OnRead(AsyncGPUReadbackRequest data) { if (data.done) { DecodeData(data.GetData <float>().ToArray()); newData = true; } }
public static UniTask <AsyncGPUReadbackRequest> ToUniTask(this AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken)) { if (asyncOperation.done) { return(UniTask.FromResult(asyncOperation)); } return(new UniTask <AsyncGPUReadbackRequest>(AsyncGPUReadbackRequestAwaiterConfiguredSource.Create(asyncOperation, timing, cancellationToken, out var token), token)); }
public void UpdateJobsGerstnerCache(AsyncGPUReadbackRequest request) { NativeArray <ushort> resultData = request.GetData <ushort>(); NativeArray <ushort> data = new NativeArray <ushort>(resultData, Allocator.Temp); ShapeGerstnerJobs.AddNewOceanDepthCache(this, data); data.Dispose(); }
public void ApplyNormalData(AsyncGPUReadbackRequest request) { //GPU readback might have happened too late and chuck might have been made invisible by that time. if (IsVisible) { var vectorData = request.GetData <Vector3>(); Filter.sharedMesh.normals = vectorData.ToArray(); } }
/// <summary> /// Handle data access callback from gpu. /// Wraps data request in to struct that handles protection and sampling. /// </summary> /// <param name="iRequest">requested callback to wrap.</param> private void AsyncReadCallback(AsyncGPUReadbackRequest iRequest) { if (iRequest.hasError || iRequest.done == false) { return; } mTextureDataRequest = new TextureDataRequest(iRequest); }
void PointCloudCompleted(AsyncGPUReadbackRequest request) { particleUnifiedArray.AsynchUpdate(request); if (pointCloud != null) { pointCloud.UpdatePointCloud(particleUnifiedArray.nativeArray); } gate = true; }
/// <summary> /// Handle data access callback from gpu. /// Wraps data request in to struct that handles protection and sampling. /// </summary> /// <param name="iRequest">requested callback to wrap.</param> private void AsyncReadCallback(AsyncGPUReadbackRequest iRequest) { if (iRequest.hasError || iRequest.done == false || mTextureDataRequest == null) { return; } mTextureDataRequest.StoreData(iRequest); }
void ReadPixel(AsyncGPUReadbackRequest request) { if (request.hasError) { Debug.LogError("Can't readback the texture from GPU"); return; } output = request.GetData <Color>(0)[0]; }
void OnCompleteReadback(AsyncGPUReadbackRequest request) { hasRequest = false; if (request.hasError) { Debug.Log("GPU readback error detected."); return; } outputReady = true; }
private void SetPoints(AsyncGPUReadbackRequest obj) { if (_destroy) { return; } _vertices = obj.GetData <Vector3>().ToArray(); _mesh.vertices = _vertices; }
private unsafe void OnReadBack(AsyncGPUReadbackRequest obj) { if (OK && !obj.hasError && obj.done) { fixed(byte *data = obj.GetData <byte>().ToArray()) { ROS_Node.Instance.Publish_Image(Topic, name, (uint)Time.frameCount, (uint)obj.width, (uint)obj.height, data); } } }
void OnCompleteReadback(AsyncGPUReadbackRequest request) { if (request.hasError) { Debug.Log("GPU readback error detected."); return; } callback.Invoke(request.GetData <byte>().ToArray()); }
private void ReadbackDone(AsyncGPUReadbackRequest r) { Profiler.BeginSample("BaseTextureRecorder.ReadbackDone"); WriteFrame(r, m_OngoingRequests[r]); Profiler.EndSample(); m_OngoingRequests.Remove(r); if (m_OngoingRequests.Count == 0 && m_DelayedEncoderDispose) { DisposeEncoder(); } }
/// <summary> /// Writes the frame from an asynchronous GPU read request. /// </summary> /// <param name="r">The asynchronous readback target.</param> protected virtual void WriteFrame(AsyncGPUReadbackRequest r, double timestamp) { if (m_ReadbackTexture == null) { m_ReadbackTexture = CreateReadbackTexture(r.width, r.height); } Profiler.BeginSample("BaseTextureRecorder.LoadRawTextureData"); m_ReadbackTexture.LoadRawTextureData(r.GetData <byte>()); Profiler.EndSample(); WriteFrame(m_ReadbackTexture); }