protected override void RunInternal()
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.Profiling);
Console.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
Console.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer<long> buffer = new ComputeBuffer<long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, false, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
commands.Finish();
Console.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
Console.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
}
public MaterialCache(ComputeCommandQueue commandQueue)
{
_commandQueue = commandQueue;
_materialArray = new Material[DefaultCacheSize];
Buffer = new ComputeBuffer<Material>(commandQueue.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, _materialArray);
}
public static void Run(TextWriter log, ComputeContext context)
{
StartTest(log, "Vector addition test");
try
{
int count = 10;
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
ComputeBuffer<float> a = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
ComputeBuffer<float> b = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
ComputeBuffer<float> c = new ComputeBuffer<float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
ComputeProgram program = new ComputeProgram(context, kernelSource);
program.Build(null, null, null, IntPtr.Zero);
ComputeKernel kernel = program.CreateKernel("VectorAdd");
kernel.SetMemoryArgument(0, a);
kernel.SetMemoryArgument(1, b);
kernel.SetMemoryArgument(2, c);
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
ICollection<ComputeEventBase> events = new Collection<ComputeEventBase>();
// BUG: ATI Stream v2.2 crash if event list not null.
commands.Execute(kernel, null, new long[] { count }, null, events);
//commands.Execute(kernel, null, new long[] { count }, null, null);
arrC = new float[count];
GCHandle arrCHandle = GCHandle.Alloc(arrC, GCHandleType.Pinned);
commands.Read(c, true, 0, count, arrCHandle.AddrOfPinnedObject(), events);
arrCHandle.Free();
for (int i = 0; i < count; i++)
log.WriteLine("{0} + {1} = {2}", arrA[i], arrB[i], arrC[i]);
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
EndTest(log, "Vector addition test");
}
private void initBuffers()
{
// Create array for lights
_pointLightArray = new SimplePointLight[_lights.Count];
_lights.CopyTo(_pointLightArray, 0);
PointLightCount = _lights.Count;
PointLightBuffer = new ComputeBuffer<SimplePointLight>(_commandQueue.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, _pointLightArray);
// Create primitive array
_geometryArray = new Triangle[_primitives.Count];
_primitives.CopyTo(_geometryArray, 0);
Geometry = new ComputeBuffer<Triangle>(_commandQueue.Context, ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer, _geometryArray);
// Copy BVH node array to buffer
BvhNodeBuffer = new ComputeBuffer<LinearBVHNode>(_commandQueue.Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, _nodes);
// Don't need to sync buffers here. Will be done before rendering.
}
protected override void RunInternal()
{
int count = 10;
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
ComputeBuffer<float> a = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
ComputeBuffer<float> b = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
ComputeBuffer<float> c = new ComputeBuffer<float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
ComputeProgram program = new ComputeProgram(context, new string[] { kernelSource });
program.Build(null, null, null, IntPtr.Zero);
ComputeKernel kernel = program.CreateKernel("VectorAdd");
kernel.SetMemoryArgument(0, a);
kernel.SetMemoryArgument(1, b);
kernel.SetMemoryArgument(2, c);
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
ComputeEventList events = new ComputeEventList();
commands.Execute(kernel, null, new long[] { count }, null, events);
arrC = new float[count];
GCHandle arrCHandle = GCHandle.Alloc(arrC, GCHandleType.Pinned);
commands.Read(c, false, 0, count, arrCHandle.AddrOfPinnedObject(), events);
commands.Finish();
arrCHandle.Free();
for (int i = 0; i < count; i++)
Console.WriteLine("{0} + {1} = {2}", arrA[i], arrB[i], arrC[i]);
}
private static void ConductSearch(ComputeContext context, ComputeKernel kernel)
{
var todos = GetQueenTaskPartition(NumQueens, 4);
var done = new List<QueenTask>();
ComputeEventList eventList = new ComputeEventList();
var commands = new ComputeCommandQueue(context, context.Devices[1], ComputeCommandQueueFlags.None);
Console.WriteLine("Starting {0} tasks, and working {1} at a time.", todos.Count, Spread);
QueenTask[] inProgress = GetNextAssignment(new QueenTask[] {}, todos, done);
var sw = new Stopwatch();
sw.Start();
while (inProgress.Any())
{
var taskBuffer =
new ComputeBuffer<QueenTask>(context,
ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.CopyHostPointer,
inProgress);
kernel.SetMemoryArgument(0, taskBuffer);
commands.WriteToBuffer(inProgress, taskBuffer, false, null);
for (int i = 0; i < 12; i++)
commands.Execute(kernel, null, new long[] { inProgress.Length }, null, eventList);
commands.ReadFromBuffer(taskBuffer, ref inProgress, false, eventList);
commands.Finish();
inProgress = GetNextAssignment(inProgress, todos, done);
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds / 1000.0);
ulong sum = done.Select(state => state.solutions)
.Aggregate((total, next) => total + next);
Console.WriteLine("Q({0})={1}", NumQueens, sum);
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
log.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer<long> buffer = new ComputeBuffer<long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, true, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
log.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
log.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
// wait for the unmap to happen
commands.Finish();
// cleanup buffer
buffer.Dispose();
// cleanup commands
commands.Dispose();
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public ClIntersectionDevice(RayEngineScene scene, bool lowLatency, int index)
: base(scene) {
wallclock = new Stopwatch();
this.todoRayBuffers = new ConcurrentQueue<RayBuffer>();
this.doneRayBuffers = new ConcurrentQueue<RayBuffer>();
this.started = false;
clContext = new ClDeviceContext() { KernelSrc = Kernels.PbrtBVHKernel };
clContext.Initialize();
clContext.SetupDevice("Intersect");
var rayBufferSize = lowLatency ? (RayBuffer.RayBufferSize / 8) : RayBuffer.RayBufferSize;
var sceneVertices = scene.Vertices.ToArray();
var sceneTriangles = scene.Triangles.ToArray();
Tracer.TraceLine("Vertices Data Size {0:F3} MBytes", (sceneVertices.Length * 12f) / (1024f * 1024f));
Tracer.TraceLine("Indexes Data Size {0:F3} MBytes", (sceneTriangles.Length * 12f) / (1024f * 1024f));
var da = new BvhDataAdapter(scene);
var st = DateTime.UtcNow;
TriangleDataInfo[] triData = null;
var treeData = da.BuildLData(out triData);
//scene.Triangles = triData.ToList();
var dc = treeData.Count(item => item.IsLeaf);
Tracer.TraceLine("Bvh Leaf nodes {0}", dc);
verts = new ComputeBuffer<Point>(clContext.context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, sceneVertices);
tris = new ComputeBuffer<TriangleInfo>(clContext.context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, triData.Select(item=>item.GetInfo()).ToArray());
Tracer.TraceLine("BVH Data Size {0:F3} MBytes" ,(treeData.Length*32f) / (1024f*1024f));
tree = new ComputeBuffer<LNode>(clContext.context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, treeData);
rays = new ComputeBuffer<RayData>(clContext.context, ComputeMemoryFlags.ReadOnly, rayBufferSize);
rayHits = new ComputeBuffer<RayHit>(clContext.context, ComputeMemoryFlags.WriteOnly, rayBufferSize);
Tracer.TraceLine("Bvh Build and Load Time {0}", DateTime.UtcNow - st);
clContext.kernel.SetMemoryArgument(0, rays);
clContext.kernel.SetMemoryArgument(1, rayHits);
clContext.kernel.SetMemoryArgument(2, verts);
clContext.kernel.SetMemoryArgument(3, tris);
clContext.kernel.SetValueArgument(4, (uint)tris.Count);
clContext.kernel.SetValueArgument(5, (uint)tree.Count);
clContext.kernel.SetMemoryArgument(6, tree);
}
public static void Run(TextWriter log, ComputeContext context)
{
StartTest(log, "Dummy test");
try
{
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
log.WriteLine("Original content:");
Random rand = new Random();
int count = 6;
long[] bufferContent = new long[count];
for (int i = 0; i < count; i++)
{
bufferContent[i] = (long)(rand.NextDouble() * long.MaxValue);
log.WriteLine("\t" + bufferContent[i]);
}
ComputeBuffer<long> buffer = new ComputeBuffer<long>(context, ComputeMemoryFlags.CopyHostPointer, bufferContent);
IntPtr mappedPtr = commands.Map(buffer, false, ComputeMemoryMappingFlags.Read, 0, bufferContent.Length, null);
commands.Finish();
log.WriteLine("Mapped content:");
for (int i = 0; i < bufferContent.Length; i++)
{
IntPtr ptr = new IntPtr(mappedPtr.ToInt64() + i * sizeof(long));
log.WriteLine("\t" + Marshal.ReadInt64(ptr));
}
commands.Unmap(buffer, ref mappedPtr, null);
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
EndTest(log, "Dummy test");
}
public void DispatchCompute(ComputeShader computeShader, int kernelIndex, ComputeBuffer indirectBuffer, uint argsOffset)
{
Internal_DispatchComputeIndirect(computeShader, kernelIndex, indirectBuffer, argsOffset);
}
public void SetRayTracingBufferParam(RayTracingShader rayTracingShader, int nameID, ComputeBuffer buffer)
{
Internal_SetRayTracingBufferParam(rayTracingShader, nameID, buffer);
}
static public AsyncGPUReadbackRequest RequestIntoNativeArray <T>(ref NativeArray <T> output, ComputeBuffer src, int size, int offset, Action <AsyncGPUReadbackRequest> callback = null) where T : struct
{
unsafe
{
var data = AsyncRequestNativeArrayData.CreateAndCheckAccess(output);
AsyncGPUReadbackRequest request = Request_Internal_ComputeBuffer_2(src, size, offset, &data);
request.SetScriptingCallback(callback);
return(request);
}
}
static private extern AsyncGPUReadbackRequest Request_Internal_ComputeBuffer_2([NotNull] ComputeBuffer src, int size, int offset, AsyncRequestNativeArrayData *data);
public IEnumerator ApplyTextureMappingCoroutine(List <Matrix4x4> worldToCameraMatrixList, List <Matrix4x4> projectionMatrixList, Texture2DArray textureArray)
{
var mesh = GetComponent <MeshFilter>().mesh;
var vertices = mesh.vertices;
var triangles = mesh.triangles;
var uvArray = new float[vertices.Length * 2 * (worldToCameraMatrixList.Count + 1)];
var textureIndexArray = new int[vertices.Length];
var index = 0;
foreach (var v in vertices)
{
Vector2 uv = Vector2.one;
var textureIndex = 0;
var score = 0f;
/* set default texture */
uvArray[2 * index * (worldToCameraMatrixList.Count + 1)] = -1f;
uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 1] = -1f;
for (int i = 0; i < worldToCameraMatrixList.Count; i++)
{
//set default value
uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i + 1)] = -1f;
uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i + 1) + 1] = -1f;
var position = transform.TransformPoint(new Vector3(v.x, v.y, v.z));
var w2c = worldToCameraMatrixList[i];
var pm = projectionMatrixList[i];
var cameraSpacePosition = w2c.MultiplyPoint(position);
if (cameraSpacePosition.z >= 0)
{
continue;
}
var projectionPosition = pm.MultiplyPoint(cameraSpacePosition);
var projectionUV = new Vector2(projectionPosition.x, projectionPosition.y);
if (float.IsNaN(projectionUV.x) || float.IsNaN(projectionUV.y))
{
continue;
}
if (Mathf.Abs(projectionUV.x) <= 2.0f && Mathf.Abs(projectionUV.y) <= 2.0f)
{
/*
* //check raycast
* //cameraPosition
* var cameraPosition = w2c.inverse.MultiplyPoint3x4(Vector3.zero);
* var direction = cameraPosition - position;
* //SpatialMappingManager.Instance.LayerMask;
* //SpatialUnderstanding.Instance.UnderstandingCustomMesh.
* if (Physics.Raycast(position, direction, direction.magnitude, SpatialMappingManager.Instance.LayerMask))
* {
* continue;
* }
*/
uv = 0.5f * projectionUV + 0.5f * Vector2.one;
if ((uv.x < (1024.0 / 1280.0)) && (uv.y > (208.0 / 720.0)))
{
uv.x = uv.x * (1280.0f / 1024.0f);
uv.y = uv.y * (720.0f / 512.0f) - (208.0f / 512.0f);
var newScore = 10 - Mathf.Abs(uv.x - 0.5f) - Mathf.Abs(uv.y - 0.5f);
if (score <= newScore)
{
score = newScore;
textureIndex = i + 1;
}
uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i + 1)] = uv.x;
uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i + 1) + 1] = uv.y;
continue;
}
else
{
/*
* uv = 0.5f * projectionUV + 0.5f * Vector2.one;
* uv.x = uv.x * (1280.0f / 1024.0f);
* uv.y = uv.y * (720.0f / 512.0f) - (208.0f / 512.0f);
* uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i+1)] = uv.x;
* uvArray[2 * index * (worldToCameraMatrixList.Count + 1) + 2 * (i+1) + 1] = uv.y;
*/
continue;
}
}
else
{
continue;
}
}
textureIndexArray[index] = textureIndex;
index += 1;
}
yield return(null);
var material = GetComponent <Renderer>().material;
if (vertices.Length == 0)
{
yield break;
}
if (buffer != null)
{
buffer.Release();
}
buffer = new ComputeBuffer(vertices.Length * (worldToCameraMatrixList.Count + 1), sizeof(float) * 2);
buffer.SetData(uvArray);
material.SetBuffer("_UVArray", buffer);
if (textureIndexBuffer != null)
{
textureIndexBuffer.Release();
}
textureIndexBuffer = new ComputeBuffer(vertices.Length, sizeof(int));
textureIndexBuffer.SetData(textureIndexArray);
material.SetBuffer("_TextureIndexArray", textureIndexBuffer);
material.SetInt("_TextureCount", worldToCameraMatrixList.Count + 1);
material.SetTexture("_TextureArray", textureArray);
}
public static void DrawProceduralIndirect(MeshTopology topology, ComputeBuffer bufferWithArgs){}
public static void CopyCount(ComputeBuffer src, ComputeBuffer dst, int dstOffset){}
public void DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs)
{
DrawMeshInstancedIndirect(mesh, submeshIndex, material, shaderPass, bufferWithArgs, 0, null);
}
private static void InitBuffer(ComputeBuffer buf, int count, int stride, ComputeBufferType type){}
private static void DestroyBuffer(ComputeBuffer buf){}
public void SetBuffer(int kernelIndex, string name, ComputeBuffer buffer){}
private static void Internal_SetRandomWriteTargetBuffer(int index, ComputeBuffer uav){}
public static void SetRandomWriteTarget(int index, ComputeBuffer uav){}
public void DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset)
{
DrawProceduralIndirect(matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, null);
}
public void OnResize(int width, int height)
{
if (_disposed)
throw new ObjectDisposedException(ToString());
_width = width;
_height = height;
GL.Viewport(0, 0, width, height);
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, _pub);
GL.BufferData(BufferTarget.PixelUnpackBuffer, new IntPtr(width * height * sizeof(float) * 4), IntPtr.Zero, BufferUsageHint.DynamicCopy);
if (_openCl != null)
_openCl.Dispose();
_openCl = ComputeBuffer<Vector4>.CreateFromGLBuffer<Vector4>(_queue.Context, ComputeMemoryFlags.WriteOnly, _pub);
GL.BindTexture(TextureTarget.Texture2D, _texture);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, width, height, 0, PixelFormat.Rgba, PixelType.Float, IntPtr.Zero);
const int glLinear = 9729;
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, new[] { glLinear });
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, new[] { glLinear });
}
public void DrawProceduralIndirect(GraphicsBuffer indexBuffer, Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs)
{
DrawProceduralIndirect(indexBuffer, matrix, material, shaderPass, topology, bufferWithArgs, 0);
}
/// <summary>
/// Initializes local fields and the underlying compute context.
/// </summary>
public void Initialize()
{
if (this.context == null)
{
var devices = ComputePlatform.Platforms.SelectMany(a => a.Devices).Where(a => a.Extensions.Contains("cl_khr_fp64")).Take(1).ToArray();
ComputeContextPropertyList list = new ComputeContextPropertyList(devices[0].Platform);
this.context = new ComputeContext(devices, list, null, IntPtr.Zero);
}
this.program = new ComputeProgram(this.context, File.ReadAllText("Mandelbrot.cl"));
this.program.Build(null, null, null, IntPtr.Zero);
this.mandelbrot = this.program.CreateKernel("Mandelbrot");
this.toBitmap = this.program.CreateKernel("ToBitmap");
this.resultBuffer = new ComputeBuffer<int>(this.context, ComputeMemoryFlags.ReadWrite, this.ImageWidth * this.ImageHeight);
this.bitmapBuffer = new ComputeBuffer<byte>(this.context, ComputeMemoryFlags.ReadWrite, this.ImageWidth * this.ImageHeight * 4);
this.mandelbrot.SetMemoryArgument(7, this.resultBuffer);
this.toBitmap.SetMemoryArgument(1, this.resultBuffer);
this.toBitmap.SetMemoryArgument(2, this.bitmapBuffer);
this.commandQueue = new ComputeCommandQueue(this.context, this.context.Devices.OrderBy(a => a.Type).Where(a => a.Extensions.Contains("cl_khr_fp64")).First(), ComputeCommandQueueFlags.None);
}
public void SetRandomWriteTarget(int index, ComputeBuffer buffer)
{
SetRandomWriteTarget(index, buffer, false);
}
public unsafe void InitData(List<ProcessLayer> LayerData, double param, long count)
{
_param = (float)param;
_ld = LayerData;
_count = count;
points = new List<Tuple<int, int, Complex, Complex>>();
long n = count;
inx = new float2[n];
inc = new float2[n];
opl = new PrProcessLayer[_ld.Count][];
for (int i = 0; i < _ld.Count; i++) opl[i] = new PrProcessLayer[n];
x = new ComputeBuffer<float2>(_context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.AllocateHostPointer, n);
c = new ComputeBuffer<float2>(_context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.AllocateHostPointer, n);
outp = new ComputeBuffer<PrProcessLayer>[_ld.Count];
for (int i = 0; i < _ld.Count; i++) outp[i] = new ComputeBuffer<PrProcessLayer>(_context, ComputeMemoryFlags.WriteOnly, n);
}
void InitializeBuffers()
{
hierarchyBuf = new ComputeBuffer(hierarchy.Count, sizeof(int));
hierarchyBuf.SetData(hierarchy.ToArray());
jointDataBuf = new ComputeBuffer(numJoints, sizeof(int) * 21 + sizeof(float) * 32);
jointDataBuf.SetData(jointData);
tXBuf = new ComputeBuffer(keyframes[0].Count, sizeof(float) * 4);
tXBuf.SetData(keyframes[0].ToArray());
tYBuf = new ComputeBuffer(keyframes[1].Count, sizeof(float) * 4);
tYBuf.SetData(keyframes[1].ToArray());
tZBuf = new ComputeBuffer(keyframes[2].Count, sizeof(float) * 4);
tZBuf.SetData(keyframes[2].ToArray());
rXBuf = new ComputeBuffer(keyframes[3].Count, sizeof(float) * 4);
rXBuf.SetData(keyframes[3].ToArray());
rYBuf = new ComputeBuffer(keyframes[4].Count, sizeof(float) * 4);
rYBuf.SetData(keyframes[4].ToArray());
rZBuf = new ComputeBuffer(keyframes[5].Count, sizeof(float) * 4);
rZBuf.SetData(keyframes[5].ToArray());
rWBuf = new ComputeBuffer(keyframes[6].Count, sizeof(float) * 4);
rWBuf.SetData(keyframes[6].ToArray());
sXBuf = new ComputeBuffer(keyframes[7].Count, sizeof(float) * 4);
sXBuf.SetData(keyframes[7].ToArray());
sYBuf = new ComputeBuffer(keyframes[8].Count, sizeof(float) * 4);
sYBuf.SetData(keyframes[8].ToArray());
sZBuf = new ComputeBuffer(keyframes[9].Count, sizeof(float) * 4);
sZBuf.SetData(keyframes[9].ToArray());
xforms = model.bindposes;
xformBuf = new ComputeBuffer(numJoints, sizeof(float) * 16);
xformBuf.SetData(xforms);
int kid = jointComputer.FindKernel("CalculateTransforms");
jointComputer.SetBuffer(kid, "hierarchyBuf", hierarchyBuf);
jointComputer.SetBuffer(kid, "jointBuf", jointDataBuf);
jointComputer.SetBuffer(kid, "tXBuf", tXBuf);
jointComputer.SetBuffer(kid, "tYBuf", tYBuf);
jointComputer.SetBuffer(kid, "tZBuf", tZBuf);
jointComputer.SetBuffer(kid, "rXBuf", rXBuf);
jointComputer.SetBuffer(kid, "rYBuf", rYBuf);
jointComputer.SetBuffer(kid, "rZBuf", rZBuf);
jointComputer.SetBuffer(kid, "rWBuf", rWBuf);
jointComputer.SetBuffer(kid, "sXBuf", sXBuf);
jointComputer.SetBuffer(kid, "sYBuf", sYBuf);
jointComputer.SetBuffer(kid, "sZBuf", sZBuf);
jointComputer.SetBuffer(kid, "xformBuf", xformBuf);
jointComputer.SetInt("numJoints", numJoints);
modelMat.SetBuffer("xforms", xformBuf);
var wghts = model.boneWeights;
Vector4[] boneIndices = new Vector4[wghts.Length];
Vector4[] boneWeights = new Vector4[wghts.Length];
for (int i = 0; i < wghts.Length; i++)
{
BoneWeight w = wghts[i];
boneIndices[i] = new Vector4(w.boneIndex0, w.boneIndex1, w.boneIndex2, w.boneIndex3);
boneWeights[i] = new Vector4(w.weight0, w.weight1, w.weight2, w.weight3);
}
boneIdxBuf = new ComputeBuffer(wghts.Length, sizeof(float) * 4);
boneWeightBuf = new ComputeBuffer(wghts.Length, sizeof(float) * 4);
boneIdxBuf.SetData(boneIndices);
boneWeightBuf.SetData(boneWeights);
modelMat.SetBuffer("weights", boneWeightBuf);
modelMat.SetBuffer("boneIndices", boneIdxBuf);
jointComputer.SetInt("numJoints", numJoints);
debugs = new Matrix4x4[numJoints];
for (int i = 0; i < debugs.Length; i++)
{
debugs[i] = new Matrix4x4();
}
debugBuf = new ComputeBuffer(debugs.Length, sizeof(float) * 16);
debugBuf.SetData(debugs);
jointComputer.SetBuffer(kid, "debugBuf", debugBuf);
}
public static void SetGlobalBuffer(string propertyName, ComputeBuffer buffer){}
// creates the shader for depth2color coordinate mapping
private bool CreateCoordMapperShader(KinectInterop.SensorData sensorData, bool bAstraPro, bool bColor2Depth)
{
if (_coordMapperShader == null)
{
_coordMapperShader = Resources.Load("AstraCoordMapper") as ComputeShader;
}
if (_coordMapperShader)
{
//bAstraPro = false; // don't use NN
_depth2colorKernel = _coordMapperShader.FindKernel("MapDepth2ColorPP");
//_color2depthKernel = !bAstraPro ? _coordMapperShader.FindKernel("MapColor2DepthPP") : _coordMapperShader.FindKernel("MapColor2DepthNN");
// float[] space2spaceMat = new float[] {
// matCamD2C.m00, matCamD2C.m01, matCamD2C.m02, matCamD2C.m03,
// matCamD2C.m10, matCamD2C.m11, matCamD2C.m12, matCamD2C.m13
// };
int depthImageLength = sensorData.depthImageWidth * sensorData.depthImageHeight;
int colorImageLength = sensorData.colorImageWidth * sensorData.colorImageHeight;
_coordMapperShader.SetFloat("depthResX", (float)sensorData.depthImageWidth);
_coordMapperShader.SetFloat("depthResY", (float)sensorData.depthImageHeight);
_coordMapperShader.SetInt("depthImageLen", depthImageLength);
_coordMapperShader.SetFloat("colorResX", (float)sensorData.colorImageWidth);
_coordMapperShader.SetFloat("colorResY", (float)sensorData.colorImageHeight);
//if (!bColor2Depth)
{
_coordMapperShader.SetVector("d2cMat0", new Vector4(matCamD2C.m00, matCamD2C.m01, matCamD2C.m02, matCamD2C.m03));
_coordMapperShader.SetVector("d2cMat1", new Vector4(matCamD2C.m10, matCamD2C.m11, matCamD2C.m12, matCamD2C.m13));
// Debug.Log("Shader d2cMat0: " + new Vector4 (matCamD2C.m00, matCamD2C.m01, matCamD2C.m02, matCamD2C.m03));
// Debug.Log("Shader d2cMat1: " + new Vector4 (matCamD2C.m10, matCamD2C.m11, matCamD2C.m12, matCamD2C.m13));
}
// else
// {
// _coordMapperShader.SetFloats("color2depthMat", space2spaceMat);
// }
// compute buffers
if (_depthDepthValuesBuf == null)
{
_depthDepthValuesBuf = new ComputeBuffer(depthImageLength, sizeof(float));
_coordMapperShader.SetBuffer(_depth2colorKernel, "depthDepthValues", _depthDepthValuesBuf);
}
//if (!bColor2Depth)
{
_depthPlaneCoordsBuf = new ComputeBuffer(depthImageLength, 2 * sizeof(float));
_colorPlaneCoordsBuf = new ComputeBuffer(!bColor2Depth ? depthImageLength : colorImageLength, 2 * sizeof(float));
// set plane coords
Vector2[] depthPlaneCoords = new Vector2[depthImageLength];
for (int dy = 0, di = 0; dy < sensorData.depthImageHeight; dy++)
{
for (int dx = 0; dx < sensorData.depthImageWidth; dx++)
{
depthPlaneCoords[di] = new Vector2(dx, dy);
di++;
}
}
_depthPlaneCoordsBuf.SetData(depthPlaneCoords);
_coordMapperShader.SetBuffer(_depth2colorKernel, "depthPlaneCoords", _depthPlaneCoordsBuf);
_coordMapperShader.SetBuffer(_depth2colorKernel, "colorPlaneCoords", _colorPlaneCoordsBuf);
}
// else
// {
// int colorImageLength = sensorData.colorImageWidth * sensorData.colorImageHeight;
//
// _colorSpaceCoordsBuf = new ComputeBuffer(colorImageLength, 3 * sizeof(float));
// _colorDepthCoordsBuf = new ComputeBuffer(colorImageLength, 2 * sizeof(float));
//
// _coordMapperShader.SetBuffer(_color2depthKernel, "colorSpaceCoords", _colorSpaceCoordsBuf);
// _coordMapperShader.SetBuffer(_color2depthKernel, "colorDepthCoords", _colorDepthCoordsBuf);
// }
}
return(_coordMapperShader != null);
}
/// <summary>
/// Construct a simple kernel to add two vectors.
/// </summary>
///
/// <param name="device">The device to use.</param>
/// <param name="length">The length of the vector.</param>
public KernelVectorAdd(EncogCLDevice device, int length)
: base(device, "Encog.Engine.Resources.KernelVectorAdd.txt", "VectorAdd")
{
// Create input- and output data
this.arrayA = new float[length];
this.arrayB = new float[length];
this.targetArray = new float[length];
this.bufferArrayA = this.CreateArrayReadOnly(this.arrayA);
this.bufferArrayB = this.CreateArrayReadOnly(this.arrayB);
this.bufferTargetArray = CreateFloatArrayWriteOnly(this.targetArray.Length);
GlobalWork = length;
LocalWork = 1;
}
static private extern AsyncGPUReadbackRequest Request_Internal_ComputeBuffer_1([NotNull] ComputeBuffer buffer, AsyncRequestNativeArrayData *data);
public void InitGPU(int platformIdx)
{
platform = ComputePlatform.Platforms[platformIdx];
context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platform), null, IntPtr.Zero);
StreamReader streamReader = new StreamReader("../../program.cl");
string clSource = streamReader.ReadToEnd();
streamReader.Close();
ComputeProgram program = new ComputeProgram(context, clSource);
program.Build(null, null, null, IntPtr.Zero);
ComputeKernel kernelInit = program.CreateKernel("init");
ComputeKernel kernelUpdate = program.CreateKernel("update");
var flags = ComputeMemoryFlags.ReadWrite | ComputeMemoryFlags.UseHostPointer;
int aantalPixels = screen.height * screen.width;
rays = new GPURay[aantalPixels];
pixels = new Vector3[aantalPixels];
setGPUCameraToCamera();
GPUCamera[] gpuCamArray = { gpuCamera };
ComputeBuffer<GPURay> bufferRays = new ComputeBuffer<GPURay>(context, flags, rays);
ComputeBuffer<Vector3> bufferPixels = new ComputeBuffer<Vector3>(context, flags, pixels);
ComputeBuffer<GPUCamera> bufferCamera = new ComputeBuffer<GPUCamera>(context, flags, gpuCamArray);
kernelUpdate.SetMemoryArgument(0, bufferRays);
kernelUpdate.SetMemoryArgument(1, bufferPixels);
kernelUpdate.SetMemoryArgument(2, bufferCamera);
ComputeCommandQueue queue = new ComputeCommandQueue(context, context.Devices[0], 0);
}
public void SetComputeBufferParam(ComputeShader computeShader, int kernelIndex, string name, ComputeBuffer buffer)
{
SetComputeBufferParam(computeShader, kernelIndex, Shader.PropertyToID(name), buffer);
}
public String SearchPassword (byte[] hash, HashType type, int maxLength, String[] keySpace)
{
if (type != HashType.MD5) {
throw new NotImplementedException ("sums other than MD5 not supported");
}
if (maxLength > 6) {
throw new NotImplementedException ("doesn't support longer passwords than 7");
}
var joinedKeySpace = new List<byte> ();
foreach (var k in keySpace) {
if (k.Length > 1) {
throw new NotImplementedException ("doesn't support longer keyspaces than 1");
}
joinedKeySpace.AddRange (Encoding.ASCII.GetBytes (k));
}
byte[] resultData = new byte[20];
byte[] keyspaceJoined = joinedKeySpace.ToArray ();
var resultBuffer = new ComputeBuffer<byte> (Context, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.CopyHostPointer, resultData);
var hashBuffer = new ComputeBuffer<byte> (Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, hash);
var keyspaceBuffer = new ComputeBuffer<byte> (Context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, keyspaceJoined);
var passLenBuffer = new ComputeBuffer<byte> (Context, ComputeMemoryFlags.WriteOnly, 1);
var flagBuffer = new ComputeBuffer<int> (Context, ComputeMemoryFlags.None, 1);
Kernel.SetMemoryArgument (0, hashBuffer);
Kernel.SetMemoryArgument (1, keyspaceBuffer);
Kernel.SetMemoryArgument (2, resultBuffer);
Kernel.SetMemoryArgument (3, passLenBuffer);
Kernel.SetMemoryArgument (4, flagBuffer);
// execute kernel
var queue = new ComputeCommandQueue (Context, Device, ComputeCommandQueueFlags.None);
long firstDim = joinedKeySpace.Count;
var globalWorksize = new long[] { firstDim, 57 * 57, 57 * 57 };
queue.Execute (Kernel, new long[] { 0, 0, 0 }, globalWorksize, null, null);
byte[] passLen = new byte[1];
queue.ReadFromBuffer (resultBuffer, ref resultData, true, null);
queue.ReadFromBuffer (passLenBuffer, ref passLen, true, null);
String password = null;
if (passLen [0] > 0) {
logger.Info ("pass len {0}", passLen [0]);
password = Encoding.ASCII.GetString (resultData, 0, passLen [0]);
logger.Info ("Found password: \"{0}\"", password);
} else {
logger.Info ("Password not found.");
}
queue.Finish ();
return password;
}
public void SetRayTracingBufferParam(RayTracingShader rayTracingShader, string name, ComputeBuffer buffer)
{
Internal_SetRayTracingBufferParam(rayTracingShader, Shader.PropertyToID(name), buffer);
}
/// <summary>
/// Setup the kernel.
/// </summary>
///
public void Init(OpenCLTrainingProfile profile)
{
int errorSize = profile.KernelGlobalWorkgroup;
int gradientSize = profile.KernelGlobalWorkgroup
* this.flat.Weights.Length;
this.errors = new float[errorSize];
this.paramArray[0] = this.flat.InputCount;
this.paramArray[1] = this.flat.OutputCount;
this.paramArray[2] = this.flat.LayerCounts.Length;
// create the buffers
this.inputBuffer = CreateArrayReadOnly(this.inputArray);
this.idealBuffer = CreateArrayReadOnly(this.idealArray);
this.errorBuffer = CreateFloatArrayWriteOnly(errorSize);
this.gradientOutBuffer = CreateFloatArrayWriteOnly(gradientSize);
this.gradientInBuffer = CreateArrayReadOnly(this.gradients);
this.paramBuffer = CreateArrayReadOnly(this.paramArray);
this.layerIndexBuffer = CreateArrayReadOnly(this.flat.LayerIndex);
this.layerCountBuffer = CreateArrayReadOnly(this.flat.LayerCounts);
this.layerFeedCountBuffer = CreateArrayReadOnly(this.flat.LayerFeedCounts);
this.weightInArrayBuffer = CreateArrayReadOnly(this.weightInArray);
this.weightOutArrayBuffer = CreateFloatArrayWriteOnly(this.weightInArray.Length);
this.weightIndexBuffer = CreateArrayReadOnly(this.flat.WeightIndex);
this.activationTypeBuffer = CreateArrayReadOnly(this.flat.LayerCounts);
this.tempDataInBuffer = CreateArrayReadOnly(this.tempDataArray);
this.tempDataOutBuffer = CreateFloatArrayWriteOnly(this.tempDataArray.Length);
}
public void DrawProceduralIndirect(Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties)
{
if (material == null)
{
throw new ArgumentNullException("material");
}
if (bufferWithArgs == null)
{
throw new ArgumentNullException("bufferWithArgs");
}
ValidateAgainstExecutionFlags(CommandBufferExecutionFlags.None, CommandBufferExecutionFlags.AsyncCompute);
Internal_DrawProceduralIndirect(matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
}
public void Run(ComputeContext context, TextWriter log)
{
try
{
// Create the arrays and fill them with random data.
int count = 640*480; //
float[] arrA = new float[count];
float[] arrB = new float[count];
float[] arrC = new float[count];
Random rand = new Random();
for (int i = 0; i < count; i++)
{
arrA[i] = (float)(rand.NextDouble() * 100);
arrB[i] = (float)(rand.NextDouble() * 100);
}
// Create the input buffers and fill them with data from the arrays.
// Access modifiers should match those in a kernel.
// CopyHostPointer means the buffer should be filled with the data provided in the last argument.
program = new ComputeProgram(context, clProgramSource);
program.Build(null, null, null, IntPtr.Zero);
ComputeBuffer<float> a = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrA);
//ComputeBuffer<float> b = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.CopyHostPointer, arrB);
// The output buffer doesn't need any data from the host. Only its size is specified (arrC.Length).
ComputeBuffer<float> c = new ComputeBuffer<float>(context, ComputeMemoryFlags.WriteOnly, arrC.Length);
// Create and build the opencl program.
// Create the kernel function and set its arguments.
ComputeKernel kernel = program.CreateKernel("CompareGPUCPU");
DateTime ExecutionStartTime; //Var will hold Execution Starting Time
DateTime ExecutionStopTime;//Var will hold Execution Stopped Time
TimeSpan ExecutionTime;//Var will count Total Execution Time-Our Main Hero
ComputeCommandQueue commands = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
ExecutionStartTime = DateTime.Now; //Gets the system Current date time expressed as local time
int repeatTimes = 100;
for (int repeatCounter = 0; repeatCounter < repeatTimes; repeatCounter++)
{
kernel.SetMemoryArgument(0, a);
//kernel.SetMemoryArgument(1, b);
//kernel.SetMemoryArgument(2, c);
kernel.SetMemoryArgument(1, c);
// Create the event wait list. An event list is not really needed for this example but it is important to see how it works.
// Note that events (like everything else) consume OpenCL resources and creating a lot of them may slow down execution.
// For this reason their use should be avoided if possible.
//ComputeEventList eventList = new ComputeEventList();
// Create the command queue. This is used to control kernel execution and manage read/write/copy operations.
// Execute the kernel "count" times. After this call returns, "eventList" will contain an event associated with this command.
// If eventList == null or typeof(eventList) == ReadOnlyCollection<ComputeEventBase>, a new event will not be created.
//commands.Execute(kernel, null, new long[] { count }, null, eventList);
commands.Execute(kernel, null, new long[] { count }, null, null);
// Read back the results. If the command-queue has out-of-order execution enabled (default is off), ReadFromBuffer
// will not execute until any previous events in eventList (in our case only eventList[0]) are marked as complete
// by OpenCL. By default the command-queue will execute the commands in the same order as they are issued from the host.
// eventList will contain two events after this method returns.
//commands.ReadFromBuffer(c, ref arrC, false, eventList);
commands.ReadFromBuffer(c, ref arrC, false, null);
// A blocking "ReadFromBuffer" (if 3rd argument is true) will wait for itself and any previous commands
// in the command queue or eventList to finish execution. Otherwise an explicit wait for all the opencl commands
// to finish has to be issued before "arrC" can be used.
// This explicit synchronization can be achieved in two ways:
// 1) Wait for the events in the list to finish,
//eventList.Wait();
// 2) Or simply use
commands.Finish();
}
ExecutionStopTime = DateTime.Now;
ExecutionTime = ExecutionStopTime - ExecutionStartTime;
double perTaskTime = ExecutionTime.TotalMilliseconds / repeatTimes;
log.WriteLine("Use {0} ms using GPU", perTaskTime);
// Do that using CPU
/*
ExecutionStartTime = DateTime.Now; //Gets the system Current date time expressed as local time
for (int repeatCounter = 0; repeatCounter < repeatTimes; repeatCounter++)
{
for (int i = 0; i < count; i++)
{
//arrC[i] = arrA[i] + arrB[i];
int j;
for (j = 0; j < 330 * 10; j++)
arrC[i] = arrA[i] + j;
}
}
ExecutionStopTime = DateTime.Now;
ExecutionTime = ExecutionStopTime - ExecutionStartTime;
perTaskTime = ExecutionTime.TotalMilliseconds / repeatTimes;
log.WriteLine("Use {0} ms using CPU", ExecutionTime.TotalMilliseconds.ToString());
*/
log.WriteLine("arrA[0]:{0}, arrC[0]:{1}", arrA[0], arrC[0]);
}
catch (Exception e)
{
log.WriteLine(e.ToString());
}
}
public void DrawProceduralIndirect(GraphicsBuffer indexBuffer, Matrix4x4 matrix, Material material, int shaderPass, MeshTopology topology, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties)
{
if (indexBuffer == null)
{
throw new ArgumentNullException("indexBuffer");
}
if (material == null)
{
throw new ArgumentNullException("material");
}
if (bufferWithArgs == null)
{
throw new ArgumentNullException("bufferWithArgs");
}
Internal_DrawProceduralIndexedIndirect(indexBuffer, matrix, material, shaderPass, topology, bufferWithArgs, argsOffset, properties);
}
// tick: renders one frame
public void Tick()
{
// initialize timer
if (firstFrame)
{
timer.Reset();
timer.Start();
firstFrame = false;
}
// handle keys, only when running time set to -1 (infinite)
if (runningTime == -1) if (camera.HandleInput())
{
// camera moved; restart
ClearAccumulator();
}
// render
if (false) // if (useGPU)
{
// add your CPU + OpenCL path here
// mind the gpuPlatform parameter! This allows us to specify the platform on our
// test system.
// note: it is possible that the automated test tool provides you with a different
// platform number than required by your hardware. In that case, you can hardcode
// the platform during testing (ignoring gpuPlatform); do not forget to put back
// gpuPlatform before submitting!
long[] workSize = { screen.width, screen.height };
long[] localSize = { 16, 2 };
queue.Execute(kernel, null, workSize, null, null);
queue.Finish();
queue.ReadFromBuffer(outputBuffer, ref screen.pixels, true, null);
Console.WriteLine(screen.pixels[0]);
Random r = RTTools.GetRNG();
for (int i = 0; i < 1000; i++)
randoms[i] = (float)r.NextDouble();
rndBuffer = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, randoms);
cameraBuffer = new ComputeBuffer<Vector3>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, camera.toCL());
kernel.SetMemoryArgument(6, cameraBuffer);
kernel.SetMemoryArgument(7, rndBuffer);
}
else
{
// this is your CPU only path
float scale = 1.0f / (float)++spp;
Parallel.For(0, screen.height, y => {
for (int x = 0; x < screen.width; x++)
{
// generate primary ray
Ray ray = camera.Generate(RTTools.GetRNG(), x, y);
// trace path
int pixelIdx = x + y * screen.width;
accumulator[pixelIdx] += Sample(ray, 0, x, y);
// plot final color
screen.pixels[pixelIdx] = RTTools.Vector3ToIntegerRGB(scale * accumulator[pixelIdx]);
}
});
}
// stop and report when max render time elapsed
int elapsedSeconds = (int)(timer.ElapsedMilliseconds / 1000);
if (runningTime != -1) if (elapsedSeconds >= runningTime)
{
OpenTKApp.Report( (int)timer.ElapsedMilliseconds, spp, screen );
}
}
public void DrawMeshInstancedIndirect(Mesh mesh, int submeshIndex, Material material, int shaderPass, ComputeBuffer bufferWithArgs, int argsOffset, MaterialPropertyBlock properties)
{
if (!SystemInfo.supportsInstancing)
{
throw new InvalidOperationException("Instancing is not supported.");
}
if (mesh == null)
{
throw new ArgumentNullException("mesh");
}
if (submeshIndex < 0 || submeshIndex >= mesh.subMeshCount)
{
throw new ArgumentOutOfRangeException("submeshIndex", "submeshIndex out of range.");
}
if (material == null)
{
throw new ArgumentNullException("material");
}
if (bufferWithArgs == null)
{
throw new ArgumentNullException("bufferWithArgs");
}
Internal_DrawMeshInstancedIndirect(mesh, submeshIndex, material, shaderPass, bufferWithArgs, argsOffset, properties);
}
private void AddJobs()
{
// TODO: Can we avoid sorting per-frame? Change swap-remove to something else and only sort on
if (SortByDistance)
{
_pendingJobs.Sort((a, b) =>
{
var d1 = a.GameObject.transform.position.sqrMagnitude;
var d2 = b.GameObject.transform.position.sqrMagnitude;
return(d1.CompareTo(d2));
});
}
for (var i = 0; i < _pendingJobs.Count; ++i)
{
var job = _pendingJobs[i];
var go = job.GameObject;
// get new job, according to certain rules (maybe priority later)
if (!go.activeInHierarchy)
{
continue;
}
var mesh = job.Mesh;
var bounds = mesh.bounds;
var extents = bounds.extents;
var maxExtent = Mathf.Max(extents.x, extents.y, extents.z) * 2;
var centerWorld = go.transform.TransformPoint(bounds.center);
var frustum = _frustum;
_frustum[5].w += maxExtent + DrawDistance;
if (!IsInFrustum(centerWorld - CameraPosition, -maxExtent * 1.75f))
{
continue;
}
var triangleCount = mesh.GetIndexCount(0) / 3f;
var bufferSize = Math.Max(1, (maxExtent * maxExtent) / Density);
bufferSize = bufferSize < triangleCount ? triangleCount : bufferSize;
_frustum = frustum;
if (_pointGenerators.Count == 0)
{
_pointGenerators.Push(new InstanceGenerator(Instantiate(ComputeShader), InstanceGenerator.Feature.Grass)
{
Density = Density,
SplatMap = DefaultSplatMap
});
}
var pointGenerator = _pointGenerators.Pop();
var outputBuffer = new ComputeBuffer(Mathf.CeilToInt(bufferSize), sizeof(float) * 4, ComputeBufferType.Append);
outputBuffer.SetCounterValue(0);
pointGenerator.SetMesh(mesh);
pointGenerator.PlacementMapEnabled = false;
if (job.PlacementMap != null && UsePlacementMap)
{
pointGenerator.PlacementMap = job.PlacementMap;
pointGenerator.PlacementMapEnabled = true;
}
else
{
pointGenerator.PlacementMap = new Texture2D(job.Diffuse.width, job.Diffuse.height);
}
pointGenerator.ColorMap = job.Diffuse;
pointGenerator.OutputBuffer = outputBuffer;
var threadGroups = Mathf.CeilToInt(triangleCount / 16f);
pointGenerator.Dispatch(threadGroups > 0 ? threadGroups : 1);
// swap remove
if ((i + 1) < _pendingJobs.Count)
{
_pendingJobs[i--] = _pendingJobs[_pendingJobs.Count - 1];
}
_pendingJobs.RemoveAt(_pendingJobs.Count - 1);
_currentJobs.Add(new JobOutput()
{
GameObject = go,
Bounds = bounds,
PointBuffer = outputBuffer,
Generator = pointGenerator
});
if (_currentJobs.Count >= MAX_JOBS_PER_FRAME)
{
return;
}
}
}
public void SetRandomWriteTarget(int index, ComputeBuffer buffer, bool preserveCounterValue)
{
ValidateAgainstExecutionFlags(CommandBufferExecutionFlags.None, CommandBufferExecutionFlags.AsyncCompute);
SetRandomWriteTarget_Buffer(index, buffer, preserveCounterValue);
}
protected override void BindInputsAndOutputs(PropertyWrapperComputeStandalone wrapper, ComputeBuffer resultsBuffer)
{
OceanRenderer.Instance._lodDataAnimWaves.BindResultData(wrapper);
ShaderProcessQueries.SetTexture(_kernelHandle, sp_LD_TexArray_AnimatedWaves, OceanRenderer.Instance._lodDataAnimWaves.DataTexture);
ShaderProcessQueries.SetBuffer(_kernelHandle, sp_ResultDisplacements, resultsBuffer);
}
public void SetGlobalBuffer(string name, ComputeBuffer value)
{
SetGlobalBuffer(Shader.PropertyToID(name), value);
}
public void InitBuffers()
{
if (LodInfos == null)
{
LodInfos = new ComputeBuffer(8, 16);
}
if (SphereBatchBuffer == null)
{
SphereBatchBuffer = new ComputeBuffer(NumProteinSphereBatchesMax, 16, ComputeBufferType.Append);
}
//*****//
if (ProteinColors == null)
{
ProteinColors = new ComputeBuffer(NumProteinMax, 16);
}
if (ProteinToggleFlags == null)
{
ProteinToggleFlags = new ComputeBuffer(NumProteinMax, 4);
}
if (ProteinAtoms == null)
{
ProteinAtoms = new ComputeBuffer(NumProteinAtomMax, 16);
}
if (ProteinAtomClusters == null)
{
ProteinAtomClusters = new ComputeBuffer(NumProteinAtomClusterMax, 16);
}
if (ProteinAtomCount == null)
{
ProteinAtomCount = new ComputeBuffer(NumProteinMax, 4);
}
if (ProteinAtomStart == null)
{
ProteinAtomStart = new ComputeBuffer(NumProteinMax, 4);
}
if (ProteinAtomClusterCount == null)
{
ProteinAtomClusterCount = new ComputeBuffer(NumProteinMax * NumLodMax, 4);
}
if (ProteinAtomClusterStart == null)
{
ProteinAtomClusterStart = new ComputeBuffer(NumProteinMax * NumLodMax, 4);
}
if (ProteinInstanceInfos == null)
{
ProteinInstanceInfos = new ComputeBuffer(NumProteinInstancesMax, 16);
}
if (ProteinInstanceCullFlags == null)
{
ProteinInstanceCullFlags = new ComputeBuffer(NumProteinInstancesMax, 4);
}
if (ProteinInstancePositions == null)
{
ProteinInstancePositions = new ComputeBuffer(NumProteinInstancesMax, 16);
}
if (ProteinInstanceRotations == null)
{
ProteinInstanceRotations = new ComputeBuffer(NumProteinInstancesMax, 16);
}
if (ProteinDisplayPositions == null)
{
ProteinDisplayPositions = new ComputeBuffer(NumProteinInstancesMax, 16);
}
if (ProteinDisplayRotations == null)
{
ProteinDisplayRotations = new ComputeBuffer(NumProteinInstancesMax, 16);
}
//*****//
if (CurveIngredientsInfos == null)
{
CurveIngredientsInfos = new ComputeBuffer(NumCurveIngredientMax, 16);
}
if (CurveIngredientsColors == null)
{
CurveIngredientsColors = new ComputeBuffer(NumCurveIngredientMax, 16);
}
if (CurveIngredientsToggleFlags == null)
{
CurveIngredientsToggleFlags = new ComputeBuffer(NumCurveIngredientMax, 4);
}
if (CurveIngredientsAtomCount == null)
{
CurveIngredientsAtomCount = new ComputeBuffer(NumCurveIngredientMax, 4);
}
if (CurveIngredientsAtomStart == null)
{
CurveIngredientsAtomStart = new ComputeBuffer(NumCurveIngredientMax, 4);
}
if (CurveIngredientsAtoms == null)
{
CurveIngredientsAtoms = new ComputeBuffer(NumCurveIngredientAtomsMax, 16);
}
if (CurveControlPointsInfos == null)
{
CurveControlPointsInfos = new ComputeBuffer(NumCurveControlPointsMax, 16);
}
if (CurveControlPointsNormals == null)
{
CurveControlPointsNormals = new ComputeBuffer(NumCurveControlPointsMax, 16);
}
if (CurveControlPointsPositions == null)
{
CurveControlPointsPositions = new ComputeBuffer(NumCurveControlPointsMax, 16);
}
}
public void ParallelFluidStep()
{
buffer = new ComputeBuffer(fieldRender.Particles.Length, sizeof(float) * 14, ComputeBufferType.Structured);
float sizeX = fieldRender.resolution.x;
float sizeY = fieldRender.resolution.y;
float sizeZ = fieldRender.resolution.z;
////Velocity
buffer.SetData(fieldRender.Particles);
velocityStep.SetBuffer(velocityKernel, "particles", buffer);
velocityStep.SetInt("sizeX", (int)sizeX);
velocityStep.SetInt("sizeY", (int)sizeY);
velocityStep.SetInt("sizeZ", (int)sizeZ);
velocityStep.Dispatch(velocityKernel, (int)(sizeX * sizeY * sizeZ), 1, 1);
buffer.GetData(fieldRender.Particles);
//Debug.Log(fieldRender.Particles[5].GetPrevVelocityX()+ fieldRender.Particles[5].GetPrevVelocityY()+ fieldRender.Particles[5].GetPrevVelocityZ());
//Debug.Log(fieldRender.Particles[75].Print());
//Density
buffer.SetData(fieldRender.Particles);
densityStep.SetBuffer(densityKernel, "particles", buffer);
densityStep.SetInt("sizeX", (int)sizeX);
densityStep.SetInt("sizeY", (int)sizeY);
densityStep.SetInt("sizeZ", (int)sizeZ);
densityStep.Dispatch(densityKernel, (int)(sizeX * sizeY * sizeZ), 1, 1);
buffer.GetData(fieldRender.Particles);
//Debug.Log(fieldRender.Particles[15].GetVelocityY());
//if (sizeZ > 2)
//{
// #region densityBounds;
// fieldRender.Particles[IX(0, 0, 0)].SetDensity(0.33f * (fieldRender.Particles[IX(1, 0, 0)].GetDensity() + fieldRender.Particles[IX(0, 1, 0)].GetDensity() + fieldRender.Particles[IX(0, 0, 1)].GetDensity()));
// fieldRender.Particles[IX(0, 0, sizeZ - 1)].SetDensity(0.33f * (fieldRender.Particles[IX(1, 0, sizeZ - 1)].GetDensity() + fieldRender.Particles[IX(0, 1, sizeZ - 1)].GetDensity() + fieldRender.Particles[IX(0, 0, sizeZ - 2)].GetDensity()));
// fieldRender.Particles[IX(0, sizeY - 1, 0)].SetDensity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, 0)].GetDensity() + fieldRender.Particles[IX(0, sizeY - 2, 0)].GetDensity() + fieldRender.Particles[IX(0, sizeY - 1, 1)].GetDensity()));
// fieldRender.Particles[IX(sizeX - 1, 0, 0)].SetDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, 0)].GetDensity() + fieldRender.Particles[IX(sizeX - 1, 1, 0)].GetDensity() + fieldRender.Particles[IX(sizeX- 1, 0, 1)].GetDensity()));
// fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 1)].SetDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, sizeZ - 1)].GetDensity() + particles[IX(sizeX - 1, sizeY - 2, sizeZ - 1)].GetDensity() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 2)].GetDensity()));
// fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 0)].SetDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, 0)].GetDensity() + particles[IX(sizeX - 1, sizeY - 2, 0)].GetDensity() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 1)].GetDensity()));
// fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 1)].SetDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, sizeZ - 1)].GetDensity() + particles[IX(sizeX - 1, 1, sizeZ - 1)].GetDensity() + fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 2)].GetDensity()));
// fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 1)].SetDensity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, sizeZ - 1)].GetDensity() + particles[IX(0, sizeY - 2, sizeZ - 1)].GetDensity() + fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 2)].GetDensity()));
// #endregion
// #region previous densityBounds;
// fieldRender.Particles[IX(0, 0, 0)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(1, 0, 0)].GetPrevDensity() + fieldRender.Particles[IX(0, 1, 0)].GetPrevDensity() + fieldRender.Particles[IX(0, 0, 1)].GetPrevDensity()));
// fieldRender.Particles[IX(0, 0, sizeZ - 1)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(1, 0, sizeZ - 1)].GetPrevDensity() + fieldRender.Particles[IX(0, 1, sizeZ - 1)].GetPrevDensity() + fieldRender.Particles[IX(0, 0, sizeZ - 2)].GetPrevDensity()));
// fieldRender.Particles[IX(0, sizeY - 1, 0)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, 0)].GetPrevDensity() + fieldRender.Particles[IX(0, sizeY - 2, 0)].GetPrevDensity() + fieldRender.Particles[IX(0, sizeY - 1, 1)].GetPrevDensity()));
// fieldRender.Particles[IX(sizeX - 1, 0, 0)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, 0)].GetPrevDensity() + fieldRender.Particles[IX(sizeX - 1, 1, 0)].GetPrevDensity() + fieldRender.Particles[IX(sizeX - 1, 0, 1)].GetPrevDensity()));
// fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 1)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, sizeZ - 1)].GetPrevDensity() + particles[IX(sizeX - 1, sizeY - 2, sizeZ - 2)].GetPrevDensity() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 2)].GetPrevDensity()));
// fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 1)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, sizeZ - 1)].GetPrevDensity() + particles[IX(sizeX - 1, 1, sizeZ - 1)].GetPrevDensity() + fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 2)].GetPrevDensity()));
// fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 1)].SetPrevDensity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, sizeZ - 1)].GetPrevDensity() + particles[IX(0, sizeY - 2, sizeZ - 1)].GetPrevDensity() + fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 2)].GetPrevDensity()));
// #endregion
#region VelocityBounds
fieldRender.Particles[IX(0, 0, 0)].SetVelocity(0.33f * (fieldRender.Particles[IX(1, 0, 0)].GetVelocityX() + fieldRender.Particles[IX(0, 1, 0)].GetVelocityY() + fieldRender.Particles[IX(0, 0, 1)].GetVelocityZ()));
fieldRender.Particles[IX(0, 0, sizeZ - 1)].SetVelocity(0.33f * (fieldRender.Particles[IX(1, 0, sizeZ - 1)].GetVelocityX() + fieldRender.Particles[IX(0, 1, sizeZ - 1)].GetVelocityY() + fieldRender.Particles[IX(0, 0, sizeZ - 2)].GetVelocityZ()));
fieldRender.Particles[IX(0, sizeY - 1, 0)].SetVelocity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, 0)].GetVelocityX() + fieldRender.Particles[IX(0, sizeY - 2, 0)].GetVelocityY() + fieldRender.Particles[IX(0, sizeY - 1, 1)].GetVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, 0, 0)].SetVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, 0)].GetVelocityX() + fieldRender.Particles[IX(sizeX - 1, 1, 0)].GetVelocityY() + fieldRender.Particles[IX(sizeX - 1, 0, 1)].GetVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 1)].SetVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, sizeZ - 1)].GetVelocityX() + particles[IX(sizeX - 1, sizeY - 2, sizeZ - 2)].GetVelocityY() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 2)].GetVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 0)].SetVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, 0)].GetVelocityX() + particles[IX(sizeX - 1, sizeY - 2, 0)].GetVelocityY() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 1)].GetVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 1)].SetVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, sizeZ - 1)].GetVelocityX() + particles[IX(sizeX - 1, 1, sizeZ - 1)].GetVelocityY() + fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 2)].GetVelocityZ()));
fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 1)].SetVelocity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, sizeZ - 1)].GetVelocityX() + particles[IX(0, sizeY - 2, sizeZ - 1)].GetVelocityY() + fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 2)].GetVelocityZ()));
#endregion
#region previous VelocityBounds
fieldRender.Particles[IX(0, 0, 0)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(1, 0, 0)].GetPrevVelocityX() + fieldRender.Particles[IX(0, 1, 0)].GetPrevVelocityY() + fieldRender.Particles[IX(0, 0, 1)].GetPrevVelocityZ()));
fieldRender.Particles[IX(0, 0, sizeZ - 1)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(1, 0, sizeZ - 1)].GetPrevVelocityX() + fieldRender.Particles[IX(0, 1, sizeZ - 1)].GetPrevVelocityY() + fieldRender.Particles[IX(0, 0, sizeZ - 2)].GetPrevVelocityZ()));
fieldRender.Particles[IX(0, sizeY - 1, 0)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, 0)].GetPrevVelocityX() + fieldRender.Particles[IX(0, sizeY - 2, 0)].GetPrevVelocityY() + fieldRender.Particles[IX(0, sizeY - 1, 1)].GetPrevVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, 0, 0)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, 0)].GetPrevVelocityX() + fieldRender.Particles[IX(sizeX - 1, 1, 0)].GetPrevVelocityY() + fieldRender.Particles[IX(sizeX - 1, 0, 1)].GetPrevVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 1)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, sizeZ - 1)].GetPrevVelocityX() + particles[IX(sizeX - 1, sizeY - 2, sizeZ - 2)].GetPrevVelocityY() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, sizeZ - 2)].GetPrevVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 0)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, sizeY - 1, 0)].GetPrevVelocityX() + particles[IX(sizeX - 1, sizeY - 2, 0)].GetPrevVelocityY() + fieldRender.Particles[IX(sizeX - 1, sizeY - 1, 1)].GetPrevVelocityZ()));
fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 1)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(sizeX - 2, 0, sizeZ - 1)].GetPrevVelocityX() + particles[IX(sizeX - 1, 1, sizeZ - 1)].GetPrevVelocityY() + fieldRender.Particles[IX(sizeX - 1, 0, sizeZ - 2)].GetPrevVelocityZ()));
fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 1)].SetPrevVelocity(0.33f * (fieldRender.Particles[IX(1, sizeY - 1, sizeZ - 1)].GetPrevVelocityX() + particles[IX(0, sizeY - 2, sizeZ - 1)].GetPrevVelocityY() + fieldRender.Particles[IX(0, sizeY - 1, sizeZ - 2)].GetPrevVelocityZ()));
#endregion
//}
buffer.Dispose();
}
private unsafe void notify(CLProgramHandle programHandle, IntPtr userDataPtr)
{
uint[] dst = new uint[16];
fixed (uint* dstPtr = dst)
{
using (var queue = new ComputeCommandQueue(ccontext, device, ComputeCommandQueueFlags.None))
{
var buf = new ComputeBuffer<uint>(ccontext, ComputeMemoryFlags.WriteOnly, 16);
var kernel = program.CreateKernel("test");
kernel.SetValueArgument(0, 1443351125U);
kernel.SetMemoryArgument(1, buf);
var eventList = new ComputeEventList();
queue.Execute(kernel, null, new long[] { 16L, 256L, 1048576L }, null, null);
queue.Finish();
queue.Read<uint>(buf, true, 0, 16, (IntPtr)dstPtr, null);
queue.Finish();
queue.Finish();
}
}
}
void Start()
{
buffer = new ComputeBuffer(1, sizeof(float));
shader.SetBuffer(0, "Result", buffer);
}
public void SetBuffer(string propertyName, ComputeBuffer buffer){}
bool useGPU = true; // GPU code enabled (from commandline)
#endregion Fields
#region Methods
// initialize renderer: takes in command line parameters passed by template code
public void Init( int rt, bool gpu, int platformIdx )
{
// pass command line parameters
runningTime = rt;
useGPU = gpu;
gpuPlatform = platformIdx;
// initialize accumulator
accumulator = new Vector3[screen.width * screen.height];
ClearAccumulator();
// setup scene
scene = new Scene();
// setup camera
camera = new Camera( screen.width, screen.height );
// Generate randoms
Console.Write("Generating randoms....\t");
randoms = new float[1000];
Random r = RTTools.GetRNG();
for (int i = 0; i < 1000; i++)
randoms[i] = (float)r.NextDouble();
int variable = r.Next();
Console.WriteLine("Done!");
// initialize required opencl things if gpu is used
if (useGPU)
{
StreamReader streamReader = new StreamReader("../../kernel.cl");
string clSource = streamReader.ReadToEnd();
streamReader.Close();
platform = ComputePlatform.Platforms[0];
context = new ComputeContext(ComputeDeviceTypes.Gpu, new ComputeContextPropertyList(platform), null, IntPtr.Zero);
queue = new ComputeCommandQueue(context, context.Devices[0], ComputeCommandQueueFlags.None);
program = new ComputeProgram(context, clSource);
try
{
program.Build(null, null, null, IntPtr.Zero);
kernel = program.CreateKernel("Main");
sceneBuffer = new ComputeBuffer<Vector4>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, scene.toCL());
rndBuffer = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, randoms);
cameraBuffer = new ComputeBuffer<Vector3>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, camera.toCL());
outputBuffer = new ComputeBuffer<int>(context, ComputeMemoryFlags.WriteOnly | ComputeMemoryFlags.UseHostPointer, screen.pixels);
skydome = new ComputeBuffer<float>(context, ComputeMemoryFlags.ReadOnly | ComputeMemoryFlags.UseHostPointer, scene.Skydome);
kernel.SetMemoryArgument(0, outputBuffer);
kernel.SetValueArgument(1, screen.width);
kernel.SetValueArgument(2, screen.height);
kernel.SetMemoryArgument(3, sceneBuffer);
kernel.SetValueArgument(4, scene.toCL().Length);
kernel.SetMemoryArgument(5, skydome);
kernel.SetMemoryArgument(6, cameraBuffer);
kernel.SetMemoryArgument(7, rndBuffer);
}
catch (ComputeException e) {
Console.WriteLine("Error in kernel code: {0}", program.GetBuildLog(context.Devices[0]));
Console.ReadLine();
useGPU = false;
}
}
else {
return;
}
}
public ComputeShaderSkinningAdapter(SkinningBlend method, ComputeShader computeShader, RenderChunk chunk, Transform[] bones, Material material, bool tension = false)
{
this.method = method;
perVertexBuffer = new ComputeBuffer(chunk.vertexCount, Marshal.SizeOf(typeof(DataPerVertex)));
perVertexBuffer.SetData(chunk.dataPerVertex);
perVertexSkinBuffer = new ComputeBuffer(chunk.vertexCount, Marshal.SizeOf(typeof(SkinPerVertex)));
perVertexSkinBuffer.SetData(chunk.skinPerVertex);
perVertexStream = new ComputeBuffer(chunk.vertexCount, Marshal.SizeOf(typeof(DataPerVertex)));
perVertexStream.SetData(chunk.dataPerVertex);
indexBuffer = new ComputeBuffer(chunk.indices.Length, sizeof(int));
indexBuffer.SetData(chunk.indices);
indexCountBuffer = new ComputeBuffer(chunk.indexCounts.Length, sizeof(int));
indexCountBuffer.SetData(chunk.indexCounts);
sourceDispatcher = new DataToDataDispatcher(
computeShader,
() => perVertexBuffer,
() => perVertexStream
);
dispatchcer = DispatcherFactory.CreateComputeBy(
method,
computeShader,
chunk,
bones,
() => perVertexBuffer,
() => perVertexSkinBuffer,
() => perVertexStream
);
if (!tension)
{
renderer = new ComputeShaderRenderer(
chunk,
material,
() => perVertexStream,
() => indexBuffer,
() => indexCountBuffer
);
}
else
{
edgeLengthBuffer = new ComputeBuffer(chunk.edges.Length, sizeof(float));
edgeLengthBuffer.SetData(chunk.edges);
tensionBuffer = new ComputeBuffer(chunk.vertexCount, sizeof(float));
tensionBuffer.SetData(new float[chunk.vertexCount]);
tensionDispatcher = new TensionDispatcher(
computeShader,
chunk,
() => perVertexStream,
() => indexBuffer,
() => edgeLengthBuffer,
() => tensionBuffer
);
renderer = new TensionRenderer(chunk, material, () => tensionBuffer, () => perVertexStream, () => indexBuffer, () => indexCountBuffer);
}
}
public TerrainGen()
{
#if CPU_DEBUG
var platform = ComputePlatform.Platforms[1];
#else
var platform = ComputePlatform.Platforms[0];
#endif
_devices = new List<ComputeDevice>();
_devices.Add(platform.Devices[0]);
_properties = new ComputeContextPropertyList(platform);
_context = new ComputeContext(_devices, _properties, null, IntPtr.Zero);
_cmdQueue = new ComputeCommandQueue(_context, _devices[0], ComputeCommandQueueFlags.None);
#region setup generator kernel
bool loadFromSource = Gbl.HasRawHashChanged[Gbl.RawDir.Scripts];
loadFromSource = true;
_chunkWidthInBlocks = Gbl.LoadContent<int>("TGen_ChunkWidthInBlocks");
_chunkWidthInVerts = _chunkWidthInBlocks + 1;
_blockWidth = Gbl.LoadContent<int>("TGen_BlockWidthInMeters");
float lacunarity = Gbl.LoadContent<float>("TGen_Lacunarity");
float gain = Gbl.LoadContent<float>("TGen_Gain");
int octaves = Gbl.LoadContent<int>("TGen_Octaves");
float offset = Gbl.LoadContent<float>("TGen_Offset");
float hScale = Gbl.LoadContent<float>("TGen_HScale");
float vScale = Gbl.LoadContent<float>("TGen_VScale");
_genConstants = new ComputeBuffer<float>(_context, ComputeMemoryFlags.ReadOnly, 8);
var genArr = new[]{
lacunarity,
gain,
offset,
octaves,
hScale,
vScale,
_blockWidth,
_chunkWidthInBlocks
};
_cmdQueue.WriteToBuffer(genArr, _genConstants, false, null);
if (loadFromSource){
_generationPrgm = new ComputeProgram(_context, Gbl.LoadScript("TGen_Generator"));
#if CPU_DEBUG
_generationPrgm.Build(null, @"-g -s D:\Projects\Gondola\Scripts\GenTerrain.cl", null, IntPtr.Zero); //use option -I + scriptDir for header search
#else
_generationPrgm.Build(null, "", null, IntPtr.Zero);//use option -I + scriptDir for header search
#endif
Gbl.SaveBinary(_generationPrgm.Binaries, "TGen_Generator");
}
else{
var binary = Gbl.LoadBinary("TGen_Generator");
_generationPrgm = new ComputeProgram(_context, binary, _devices);
_generationPrgm.Build(null, "", null, IntPtr.Zero);
}
//loadFromSource = false;
_terrainGenKernel = _generationPrgm.CreateKernel("GenTerrain");
_normalGenKernel = _generationPrgm.CreateKernel("GenNormals");
//despite the script using float3 for these fields, we need to consider it to be float4 because the
//implementation is basically a float4 wrapper that uses zero for the last variable
_geometry = new ComputeBuffer<float>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts*_chunkWidthInVerts*4);
_normals = new ComputeBuffer<ushort>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts * _chunkWidthInVerts * 4);
_binormals = new ComputeBuffer<byte>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts*_chunkWidthInVerts*4);
_tangents = new ComputeBuffer<byte>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts*_chunkWidthInVerts*4);
_uvCoords = new ComputeBuffer<float>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts*_chunkWidthInVerts*2);
_terrainGenKernel.SetMemoryArgument(0, _genConstants);
_terrainGenKernel.SetMemoryArgument(3, _geometry);
_terrainGenKernel.SetMemoryArgument(4, _uvCoords);
_normalGenKernel.SetMemoryArgument(0, _genConstants);
_normalGenKernel.SetMemoryArgument(3, _geometry);
_normalGenKernel.SetMemoryArgument(4, _normals);
_normalGenKernel.SetMemoryArgument(5, _binormals);
_normalGenKernel.SetMemoryArgument(6, _tangents);
#endregion
#region setup quadtree kernel
if (loadFromSource){
_qTreePrgm = new ComputeProgram(_context, Gbl.LoadScript("TGen_QTree"));
#if CPU_DEBUG
_qTreePrgm.Build(null, @"-g -s D:\Projects\Gondola\Scripts\Quadtree.cl", null, IntPtr.Zero);
#else
_qTreePrgm.Build(null, "", null, IntPtr.Zero);
#endif
Gbl.SaveBinary(_qTreePrgm.Binaries, "TGen_QTree");
}
else{
var binary = Gbl.LoadBinary("TGen_QTree");
_qTreePrgm = new ComputeProgram(_context, binary, _devices);
_qTreePrgm.Build(null, "", null, IntPtr.Zero);
}
_qTreeKernel = _qTreePrgm.CreateKernel("QuadTree");
_crossCullKernel = _qTreePrgm.CreateKernel("CrossCull");
_activeVerts = new ComputeBuffer<byte>(_context, ComputeMemoryFlags.None, _chunkWidthInVerts*_chunkWidthInVerts);
_dummy = new ComputeBuffer<int>(_context, ComputeMemoryFlags.None, 50);
var rawNormals = new ushort[_chunkWidthInVerts * _chunkWidthInVerts * 4];
_emptyVerts = new byte[_chunkWidthInVerts*_chunkWidthInVerts];
for (int i = 0; i < _emptyVerts.Length; i++){
_emptyVerts[i] = 1;
}
_cmdQueue.WriteToBuffer(rawNormals, _normals, true, null);
_cmdQueue.WriteToBuffer(_emptyVerts, _activeVerts, true, null);
_qTreeKernel.SetValueArgument(1, _chunkWidthInBlocks);
_qTreeKernel.SetMemoryArgument(2, _normals);
_qTreeKernel.SetMemoryArgument(3, _activeVerts);
_qTreeKernel.SetMemoryArgument(4, _dummy);
_crossCullKernel.SetValueArgument(1, _chunkWidthInBlocks);
_crossCullKernel.SetMemoryArgument(2, _normals);
_crossCullKernel.SetMemoryArgument(3, _activeVerts);
_crossCullKernel.SetMemoryArgument(4, _dummy);
#endregion
#region setup winding kernel
if (loadFromSource){
_winderPrgm = new ComputeProgram(_context, Gbl.LoadScript("TGen_VertexWinder"));
#if CPU_DEBUG
_winderPrgm.Build(null, @"-g -s D:\Projects\Gondola\Scripts\VertexWinder.cl", null, IntPtr.Zero);
#else
_winderPrgm.Build(null, "", null, IntPtr.Zero);
#endif
Gbl.SaveBinary(_winderPrgm.Binaries, "TGen_VertexWinder");
}
else{
var binary = Gbl.LoadBinary("TGen_VertexWinder");
_winderPrgm = new ComputeProgram(_context, binary, _devices);
_winderPrgm.Build(null, "", null, IntPtr.Zero);
}
_winderKernel = _winderPrgm.CreateKernel("VertexWinder");
_indicies = new ComputeBuffer<int>(_context, ComputeMemoryFlags.None, (_chunkWidthInBlocks)*(_chunkWidthInBlocks)*8);
_winderKernel.SetMemoryArgument(0, _activeVerts);
_winderKernel.SetMemoryArgument(1, _indicies);
_emptyIndices = new int[(_chunkWidthInBlocks)*(_chunkWidthInBlocks)*8];
for (int i = 0; i < (_chunkWidthInBlocks)*(_chunkWidthInBlocks)*8; i++){
_emptyIndices[i] = 0;
}
_cmdQueue.WriteToBuffer(_emptyIndices, _indicies, true, null);
#endregion
if (loadFromSource){
Gbl.AllowMD5Refresh[Gbl.RawDir.Scripts] = true;
}
_cmdQueue.Finish();
}
// Start is called before the first frame update
void Start()
{
_startRotation = Vector3.zero;
_numberOfLinePerSide = (int)(halfSize * 2 / stepSize);
_totalLines = 3 * _numberOfLinePerSide * _numberOfLinePerSide;
WhereLinesBuffer = new ComputeBuffer(_totalLines, Marshal.SizeOf(typeof(WhereLineData)));
WhereLinesRenderBuffer = new ComputeBuffer(_totalLines, Marshal.SizeOf(typeof(WhereLineData)));
var lineData = new WhereLineData[_totalLines];
//x plane going up
int counter = 0;
for (int i = 0; i < _numberOfLinePerSide; i++)
{
for (int j = 0; j < _numberOfLinePerSide; j++)
{
float xpos = -halfSize + i * stepSize;
float ypos = -halfSize + j * stepSize;
Vector3 start = new Vector3(xpos, ypos, -halfSize);
Vector3 end = new Vector3(xpos, ypos, halfSize);
float velx = Random.Range(0f, 2f) - 1f;
velx *= speedScale;
Vector3 vel = new Vector3(velx, velx, 0);
int index = i * _numberOfLinePerSide + j;
lineData[index].start = start;
lineData[index].end = end;
lineData[index].velocity = vel;
counter += 1;
}
}
for (int i = 0; i < _numberOfLinePerSide; i++)
{
for (int j = 0; j < _numberOfLinePerSide; j++)
{
float zpos = -halfSize + i * stepSize;
float ypos = -halfSize + j * stepSize;
Vector3 start = new Vector3(-halfSize, ypos, zpos);
Vector3 end = new Vector3(halfSize, ypos, zpos);
float velz = Random.Range(0f, 2f) - 1f;
velz *= speedScale;
Vector3 vel = new Vector3(0, velz, velz);
int index = counter;
lineData[index].start = start;
lineData[index].end = end;
lineData[index].velocity = vel;
counter += 1;
}
}
for (int i = 0; i < _numberOfLinePerSide; i++)
{
for (int j = 0; j < _numberOfLinePerSide; j++)
{
float xpos = -halfSize + i * stepSize;
float zpos = -halfSize + j * stepSize;
Vector3 start = new Vector3(xpos, -halfSize, zpos);
Vector3 end = new Vector3(xpos, halfSize, zpos);
float vely = Random.Range(0f, 2f) - 1f;
vely *= speedScale;
Vector3 vel = new Vector3(0, 0, 0);
if (Random.Range(0f, 1f) > 0.5)
{
vel.x = vely;
}
else
{
vel.z = vely;
}
int index = counter;
lineData[index].start = start;
lineData[index].end = end;
lineData[index].velocity = vel;
counter += 1;
}
}
WhereLinesBuffer.SetData(lineData);
WhereLinesRenderBuffer.SetData(lineData);
lineData = null;
lineRenderMat = new Material(LineRender);
lineRenderMat.hideFlags = HideFlags.HideAndDontSave;
}
protected override unsafe void OnUpdate()
{
EntityQuery query = GetEntityQuery(ComponentType.ReadWrite <TrailBufferElement>());
NativeArray <Entity> entitis = query.ToEntityArray(Allocator.Persistent);
int segmentCount = entitis.Length;
int trailElementCount = 0;
BufferFromEntity <TrailBufferElement> buffers = GetBufferFromEntity <TrailBufferElement>();
for (int i = 0; i < entitis.Length; ++i)
{
trailElementCount += buffers[entitis[i]].Length;
}
if (!m_TrailElements.IsCreated || m_TrailElements.Length < trailElementCount)
{
if (m_TrailElements.IsCreated)
{
m_TrailElements.Dispose();
}
m_TrailElements = new NativeArray <float3>(CalcWrappingArraySize(trailElementCount), Allocator.Persistent);
m_TrailElementBufferInShader?.Dispose();
m_TrailElementBufferInShader = new ComputeBuffer(m_TrailElements.Length, sizeof(TrailBufferElement));
}
if (!m_Segments.IsCreated || m_Segments.Length < segmentCount)
{
if (m_Segments.IsCreated)
{
m_Segments.Dispose();
}
m_Segments = new NativeArray <int3>(CalcWrappingArraySize(segmentCount), Allocator.Persistent);
m_SegmentBufferInShader?.Dispose();
m_SegmentBufferInShader = new ComputeBuffer(m_Segments.Length, sizeof(TrailBufferElement));
}
int offset = 0;
float3 *trailElementsPtr = (float3 *)m_TrailElements.GetUnsafePtr();
int3 * segmentsPtr = (int3 *)m_Segments.GetUnsafePtr();
for (int i = 0; i < segmentCount; ++i)
{
DynamicBuffer <float3> trailbuffer = buffers[entitis[i]].Reinterpret <float3>();
Entity entity = entitis[i];
int bufferlength = trailbuffer.Length;
UnsafeUtility.MemCpy(trailElementsPtr, trailbuffer.GetUnsafePtr(), sizeof(float3) * bufferlength);
*segmentsPtr = new int3(offset, bufferlength, entity.Index);
offset += bufferlength;
segmentsPtr++;
trailElementsPtr += bufferlength;
for (int j = 0; j < trailbuffer.Length; ++j)
{
if (trailbuffer[j].x == 0.0f && trailbuffer[j].y == 0.0f && trailbuffer[j].z == 0.0f)
{
Debug.Log(entity.Index);
}
}
}
m_TrailElementBufferInShader.SetData(m_TrailElements);
m_SegmentBufferInShader.SetData(m_Segments);
m_MaterialPropertyBlock.SetBuffer("_Positions", m_TrailElementBufferInShader);
m_MaterialPropertyBlock.SetBuffer("_Segments", m_SegmentBufferInShader);
m_MeshInstancedArgs.SetData(m_TrailMesh, (uint)segmentCount);
Graphics.DrawMeshInstancedIndirect(
m_TrailMesh, 0, m_Material,
new Bounds(Vector3.zero, Vector3.one * 1000),
m_MeshInstancedArgs.m_Buffer, 0, m_MaterialPropertyBlock
);
entitis.Dispose();
}
internal override void Render(PostProcessRenderContext context)
{
// Waveform show localized data, so width depends on the aspect ratio
float ratio = (context.width / 2f) / (context.height / 2f);
int width = Mathf.FloorToInt(height * ratio);
CheckOutput(width, height);
exposure = Mathf.Max(0f, exposure);
int count = width * height;
if (m_Data == null)
{
m_Data = new ComputeBuffer(count, sizeof(uint) << 2);
}
else if (m_Data.count < count)
{
m_Data.Release();
m_Data = new ComputeBuffer(count, sizeof(uint) << 2);
}
var compute = context.resources.computeShaders.waveform;
var cmd = context.command;
cmd.BeginSample("Waveform");
var parameters = new Vector4(
width,
height,
RuntimeUtilities.isLinearColorSpace ? 1 : 0,
0f
);
// Clear the buffer on every frame
int kernel = compute.FindKernel("KWaveformClear");
cmd.SetComputeBufferParam(compute, kernel, "_WaveformBuffer", m_Data);
cmd.SetComputeVectorParam(compute, "_Params", parameters);
cmd.DispatchCompute(compute, kernel, Mathf.CeilToInt(width / 16f), Mathf.CeilToInt(height / 16f), 1);
// For performance reasons, especially on consoles, we'll just downscale the source
// again to reduce VMEM stalls. Eventually the whole algorithm needs to be rewritten as
// it's currently pretty naive.
cmd.GetTemporaryRT(ShaderIDs.WaveformSource, width, height, 0, FilterMode.Bilinear, context.sourceFormat);
cmd.BlitFullscreenTriangle(ShaderIDs.HalfResFinalCopy, ShaderIDs.WaveformSource);
// Gather all pixels and fill in our waveform
kernel = compute.FindKernel("KWaveformGather");
cmd.SetComputeBufferParam(compute, kernel, "_WaveformBuffer", m_Data);
cmd.SetComputeTextureParam(compute, kernel, "_Source", ShaderIDs.WaveformSource);
cmd.SetComputeVectorParam(compute, "_Params", parameters);
cmd.DispatchCompute(compute, kernel, width, Mathf.CeilToInt(height / 256f), 1);
cmd.ReleaseTemporaryRT(ShaderIDs.WaveformSource);
// Generate the waveform texture
var sheet = context.propertySheets.Get(context.resources.shaders.waveform);
sheet.properties.SetVector(ShaderIDs.Params, new Vector4(width, height, exposure, 0f));
sheet.properties.SetBuffer(ShaderIDs.WaveformBuffer, m_Data);
cmd.BlitFullscreenTriangle(BuiltinRenderTextureType.None, output, sheet, 0);
cmd.EndSample("Waveform");
}
// Flush buffers on exit
void ReleaseBuffers()
{
if (LodInfos != null)
{
LodInfos.Release(); LodInfos = null;
}
if (SphereBatchBuffer != null)
{
SphereBatchBuffer.Release(); SphereBatchBuffer = null;
}
//*****//
if (ProteinColors != null)
{
ProteinColors.Release(); ProteinColors = null;
}
if (ProteinToggleFlags != null)
{
ProteinToggleFlags.Release(); ProteinToggleFlags = null;
}
if (ProteinAtoms != null)
{
ProteinAtoms.Release(); ProteinAtoms = null;
}
if (ProteinAtomCount != null)
{
ProteinAtomCount.Release(); ProteinAtomCount = null;
}
if (ProteinAtomStart != null)
{
ProteinAtomStart.Release(); ProteinAtomStart = null;
}
if (ProteinAtomClusters != null)
{
ProteinAtomClusters.Release(); ProteinAtomClusters = null;
}
if (ProteinAtomClusterCount != null)
{
ProteinAtomClusterCount.Release(); ProteinAtomClusterCount = null;
}
if (ProteinAtomClusterStart != null)
{
ProteinAtomClusterStart.Release(); ProteinAtomClusterStart = null;
}
if (ProteinInstanceInfos != null)
{
ProteinInstanceInfos.Release(); ProteinInstanceInfos = null;
}
if (ProteinInstanceCullFlags != null)
{
ProteinInstanceCullFlags.Release(); ProteinInstanceCullFlags = null;
}
if (ProteinInstancePositions != null)
{
ProteinInstancePositions.Release(); ProteinInstancePositions = null;
}
if (ProteinInstanceRotations != null)
{
ProteinInstanceRotations.Release(); ProteinInstanceRotations = null;
}
if (ProteinDisplayPositions != null)
{
ProteinDisplayPositions.Release(); ProteinDisplayPositions = null;
}
if (ProteinDisplayRotations != null)
{
ProteinDisplayRotations.Release(); ProteinDisplayRotations = null;
}
//*****//
if (CurveIngredientsInfos != null)
{
CurveIngredientsInfos.Release(); CurveIngredientsInfos = null;
}
if (CurveIngredientsColors != null)
{
CurveIngredientsColors.Release(); CurveIngredientsColors = null;
}
if (CurveIngredientsToggleFlags != null)
{
CurveIngredientsToggleFlags.Release(); CurveIngredientsToggleFlags = null;
}
if (CurveIngredientsAtoms != null)
{
CurveIngredientsAtoms.Release(); CurveIngredientsAtoms = null;
}
if (CurveIngredientsAtomCount != null)
{
CurveIngredientsAtomCount.Release(); CurveIngredientsAtomCount = null;
}
if (CurveIngredientsAtomStart != null)
{
CurveIngredientsAtomStart.Release(); CurveIngredientsAtomStart = null;
}
if (CurveControlPointsInfos != null)
{
CurveControlPointsInfos.Release(); CurveControlPointsInfos = null;
}
if (CurveControlPointsNormals != null)
{
CurveControlPointsNormals.Release(); CurveControlPointsNormals = null;
}
if (CurveControlPointsPositions != null)
{
CurveControlPointsPositions.Release(); CurveControlPointsPositions = null;
}
}
protected override void Init()
{
base.Init();
_screenPosLeftDown = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, Z - Camera.main.transform.position.z));
_screenPosLeftUp = Camera.main.ScreenToWorldPoint(new Vector3(0, Height, Z - Camera.main.transform.position.z));
_screenPosRightDown = Camera.main.ScreenToWorldPoint(new Vector3(Width, 0, Z - Camera.main.transform.position.z));
_screenPosRightUp = Camera.main.ScreenToWorldPoint(new Vector3(Width, Height, Z - Camera.main.transform.position.z));
int HorizontalColumn = TextureInstanced.Instance.HorizontalColumn;
int InstanceCount = TextureInstanced.Instance.InstanceCount;
float SizeWidth = TextureInstanced.Instance.SizeWidth;
float SizeHeight = TextureInstanced.Instance.SizeHeight;
//拿到实际上得到的最大横数，因为 Mathf.ClosestPowerOfTwo(InstanceCount);已经约束为2的N次方
int maxRow = InstanceCount / HorizontalColumn;
float rectangleWidth = (HorizontalColumn) * 0.1f + (HorizontalColumn) * SizeWidth;
float rectangleHeight = maxRow * 0.1f + maxRow * SizeHeight;
PosAndDir[] datas = new PosAndDir[ComputeBuffer.count];
ComputeBuffer.GetData(datas);
int rows = 0;//横列个数 y轴改变
//使面片排列成阵列
for (int i = 0; i < InstanceCount; i++)
{
if (i != 0 && i % HorizontalColumn == 0)
{
rows++;
}
int column = i - rows * HorizontalColumn;//竖列个数 x轴概念
//0.1f，为两面片间的间隙参数
Vector3 pos = new Vector3(0.1f * column, 0.1f * rows) + new Vector3(SizeWidth * column + SizeWidth / 2, SizeHeight * rows + SizeHeight / 2f);
//+左下角基准点
Vector4 temp = new Vector4(pos.x, pos.y, pos.z, 1f) + new Vector4(_screenPosLeftDown.x, _screenPosLeftDown.y, _screenPosLeftDown.z, 0);
// datas[i].position = temp;
datas[i].originalPos = datas[i].position;//存储变换前的位置
datas[i].moveTarget = temp;
datas[i].moveDir = Vector3.zero;
// if (i == 0) colors[i] = Color.white;//Color.red;
//else colors[i] = Random.ColorHSV();
datas[i].indexRC = new Vector2(rows, column);
datas[i].uvOffset = new Vector4(1f, 1f, 0f, 0f);
datas[i].uv2Offset = new Vector4(1f, 1f, 0f, 0f);
datas[i].picIndex = i % TextureInstanced.Instance.TexArr.depth;
datas[i].bigIndex = i % TextureInstanced.Instance.TexArr.depth;
Vector4 posTemp = datas[i].position;
datas[i].position = new Vector4(posTemp.x, posTemp.y, posTemp.z, 1f);
if (i == 0)
{
_originalPosLeftDown = temp; //保存面片坐标点原点位置
}
if (i == HorizontalColumn - 1) //右下角的索引
{
//colors[i] = Color.white;//颜色标记
_originalPosRightDown = temp;
}
if (rows + 1 == maxRow && i % HorizontalColumn == 0)//左上角倒数第二排第一个索引
{
//colors[i] = Color.white;//颜色标记
_originalPosLeftUp = temp;
}
if (rows + 1 == maxRow && i % HorizontalColumn == HorizontalColumn - 1)//右上角倒数第二排最后一个索引
{
// colors[i] = Color.white;//颜色标记
_originalPosRightUp = temp;
}
}
ComputeBuffer.SetData(datas);
int stride = Marshal.SizeOf(typeof(PosAndDir));
//点击缓存
_clickPointBuff = new ComputeBuffer(1, stride);
PosAndDir[] clickPoint = { new PosAndDir(-1) };
_clickPointBuff.SetData(clickPoint);
ComputeShader.SetBuffer(dispatchID, "positionBuffer", ComputeBuffer);
ComputeShader.SetBuffer(dispatchID, "clickPointsBuff", _clickPointBuff);
ComputeShader.SetBuffer(InitID, "positionBuffer", ComputeBuffer);
ComputeShader.SetFloat("rectangleWidth", rectangleWidth);
ComputeShader.SetFloat("rectangleHeight", rectangleHeight);
ComputeShader.SetFloat("MoveSpeed", MoveSpeed);
TextureInstanced.Instance.ChangeInstanceMat(null);
TextureInstanced.Instance.CurMaterial.SetVector("_WHScale", new Vector4(1, 1, 1, 1));
}
