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