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);
}
