protected virtual void InitializeKernels() { if (sumCalculateFunction != null) { sumCalculate = GPUHelper.CreateKernel(sumCalculateFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } if (sumErrorFunction != null) { if (nextLayer != null) { sumForError = GPUHelper.CreateKernel(sumErrorFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } else { sumForError = GPUHelper.CreateKernel(sumErrorFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } } if (adjustWheigtsFunction != null) { adjustWheigts = GPUHelper.CreateKernel(adjustWheigtsFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView3D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } if (activationFunction != null) { activation = GPUHelper.CreateKernel(activationFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } if (derivationFunction != null) { derivation = GPUHelper.CreateKernel(derivationFunction).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } }
protected void SetupSkin() { var mesh = skinnedRenderer.sharedMesh; var vertices = mesh.vertices; var weights = mesh.boneWeights; var indices = new int[weights.Length]; for (int i = 0, n = weights.Length; i < n; i++) { indices[i] = weights[i].boneIndex0; } using ( ComputeBuffer vertBuffer = new ComputeBuffer(vertices.Length, Marshal.SizeOf(typeof(Vector3))), boneBuffer = new ComputeBuffer(weights.Length, Marshal.SizeOf(typeof(uint))) ) { vertBuffer.SetData(vertices); boneBuffer.SetData(indices); var kernel = compute.FindKernel("SetupSkin"); compute.SetBuffer(kernel, "_Vertices", vertBuffer); compute.SetBuffer(kernel, "_Bones", boneBuffer); compute.SetBuffer(kernel, "_Attractions", attractionBuffer); GPUHelper.Dispatch1D(compute, kernel, attractionBuffer.count); } }
protected Layer2D(Layer2D prevLayer, string activationFunction, int sliceCount) { SetPrevious(prevLayer); if (prevLayer != null) { prevLayer.SetNext(this); } this.function = activationFunction; variable = new MemoryBuffer <float> [sliceCount]; activated = new MemoryBuffer2D <float> [sliceCount]; sumInput = new MemoryBuffer2D <float> [sliceCount]; error = new MemoryBuffer2D <float> [sliceCount]; weight = new MemoryBuffer3D <float> [sliceCount]; bias = new MemoryBuffer2D <float> [sliceCount]; derived = new MemoryBuffer2D <float> [sliceCount]; for (int i = 0; i < sliceCount; i++) { float[] source = { Config.learningRate, 0f }; this.variable[i] = GPUHelper.CreateBuffer(source, source.Length); activated[i] = GPUHelper.dummyBuffer2D; sumInput[i] = GPUHelper.dummyBuffer2D; error[i] = GPUHelper.dummyBuffer2D; weight[i] = GPUHelper.dummyBuffer3D; bias[i] = GPUHelper.dummyBuffer2D; derived[i] = GPUHelper.dummyBuffer2D; } }
public void Clear() { var kernel = compute.FindKernel("Clear"); compute.SetTexture(kernel, "_Volume", buffer); GPUHelper.Dispatch3D(compute, kernel, size, size, size); }
public void Unload() { for (int i = 0; i < inputsOnGPU.Length; i++) { GPUHelper.ScrapInputBuffer(inputsOnGPU[i]); } }
protected void SetupAttractions() { var kernel = compute.FindKernel("SetupAttractions"); compute.SetBuffer(kernel, "_Attractions", attractionBuffer); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void DepthKernel(float dt) { var kernel = new Kernel(voxelControl, "Depth"); SetupControlKernel(kernel, dt); voxelControl.SetVector("_TileOffset", tileOffset); var instance = CityGlobal.Instance; if (instance.Tiles.ContainsKey(tileTag)) { var u = instance.Tiles[tileTag]; var tb = BoundsWorldToLocal(u.WBounds, transform); voxelControl.SetVector("_TileBoundsMin", tb.min); voxelControl.SetVector("_TileBoundsMax", tb.max); var wb = BoundsWorldToLocal(instance.WholeBounds, transform); voxelControl.SetVector("_WholeBoundsMin", wb.min); voxelControl.SetVector("_WholeBoundsMax", wb.max); // uv (xy : scale, wz : offset) voxelControl.SetVector( "_Tile", new Vector4( tb.size.x / wb.size.x, tb.size.y / wb.size.y, (tb.min.x - wb.min.x) / wb.size.x, (tb.min.y - wb.min.y) / wb.size.y ) ); } GPUHelper.Dispatch3D(voxelControl, kernel, data.Width, data.Height, data.Depth); }
public void LoadShoulds() { for (int i = 0; i < shoulds.Length; i++) { shouldsOnGPU[i] = GPUHelper.GetOutputBuffer(); shouldsOnGPU[i].CopyFrom(this.shoulds[i], Index2.Zero, Index2.Zero, shouldsOnGPU[i].Extent); } }
public void Load() { for (int i = 0; i < inputsOnGPU.Length; i++) { inputsOnGPU[i] = GPUHelper.GetInputBuffer(); inputsOnGPU[i].CopyFrom(inputs[i], Index2.Zero, Index2.Zero, inputsOnGPU[i].Extent); } }
/// <summary> /// Creates a new Layer. /// </summary> /// <param name="inputSize"></param> public Dave(Size inputSize, int sliceCount = 1, bool debuggingToggle = false) { PreInit(); Config.inputSize = inputSize; Config.DebuggingToggle = debuggingToggle; GPUHelper.CreateAccelerator(debuggingToggle); layers.Add(new InputLayer2D(inputSize, null, sliceCount, "ByteToByteFraction")); }
protected void Invalidate(PointCloudGrid grid) { var kernel = compute.FindKernel("Invalidate"); compute.SetBuffer(kernel, "_PointBuffer", grid.PointBuffer); compute.SetInt("_InstancesCount", grid.PointBuffer.count); GPUHelper.Dispatch1D(compute, kernel, grid.PointBuffer.count); }
protected void Search() { var kernel = compute.FindKernel("Search"); compute.SetBuffer(kernel, "_Attractions", attractionBuffer); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); compute.SetFloat("_InfluenceDistance", unitDistance * influenceDistance); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void Remove() { var kernel = compute.FindKernel("Remove"); compute.SetBuffer(kernel, "_Attractions", attractionBuffer); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); compute.SetFloat("_KillDistance", unitDistance * killDistance); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void Init() { var kernel = compute.FindKernel("Init"); compute.SetBuffer(kernel, "_Crowd", crowdBuffer.Read); compute.SetBuffer(kernel, "_EmitBounds", emitBoundsBuffer); compute.SetFloat("_Size", size); compute.SetVector("_ScaleRange", scaleRange); SetupGradient(kernel); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void CalculateNormal() { var kernel = compute.FindKernel("CalculateNormal"); compute.SetInt("_Width", N); compute.SetInt("_Height", N); compute.SetInt("_Depth", N); compute.SetFloat("_Inv", 1f / N); compute.SetTexture(kernel, "_Volume", volume.Tex); compute.SetTexture(kernel, "_Result", normalBuffer); GPUHelper.Dispatch3D(compute, kernel, N, N, N); }
protected void FloorKernel(float dt) { gridUnitLength = 0f; var kernel = new Kernel(voxelControl, "FloorGrid"); SetupControlKernel(kernel, dt); voxelControl.SetInt("_GridResolution", gridResolution); GPUHelper.Dispatch1D(voxelControl, kernel, data.Buffer.count); }
protected void Grow(float dt) { var kernel = compute.FindKernel("Grow"); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); var delta = dt * growthSpeed; compute.SetFloat("_DT", delta); GPUHelper.Dispatch1D(compute, kernel, count); }
internal MemoryBuffer2D <float>[] GetShouldsActivated(InputLayer2D inputLayer) { LoadShoulds(); var buffer = inputLayer.SwapInputs(shouldsOnGPU); inputLayer.CalculateOutput(); for (int i = 0; i < buffer.Length; i++) { GPUHelper.ScrapOutputBuffer(buffer[i]); } return(inputLayer.GetActivatedBuffer()); }
protected void Attract() { var kernel = compute.FindKernel("Attract"); compute.SetBuffer(kernel, "_Attractions", attractionBuffer); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); candidatePoolBuffer.SetCounterValue(0); compute.SetBuffer(kernel, "_CandidatesPoolAppend", candidatePoolBuffer); compute.SetFloat("_GrowthDistance", unitDistance * growthDistance); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void Update(float t, float dt) { var kernel = compute.FindKernel("Update"); compute.SetBuffer(kernel, "_Crowd", crowdBuffer.Read); compute.SetFloat("_Throttle", Mathf.Lerp(-0.01f, 1f, _throttle)); compute.SetFloat("_Time", t); compute.SetFloat("_DT", dt); compute.SetFloat("_Decay", decay); compute.SetVector("_Center", center.position); SetupGradient(kernel); SetupGather(); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void KernelGrids(int kernel) { foreach (var grid in grids) { if (grid.On) { var buffer = grid.PointBuffer; compute.SetBuffer(kernel, "_PointBuffer", buffer); compute.SetBuffer(kernel, "_OriginBuffer", grid.OriginBuffer); compute.SetInt("_InstancesCount", buffer.count); GPUHelper.Dispatch1D(compute, kernel, buffer.count); } } }
protected void Animate() { var bones = skinnedRenderer.bones.Select(bone => bone.localToWorldMatrix).ToArray(); using (ComputeBuffer boneMatrixBuffer = new ComputeBuffer(bones.Length, Marshal.SizeOf(typeof(Matrix4x4)))) { boneMatrixBuffer.SetData(bones); var kernel = compute.FindKernel("Animate"); compute.SetBuffer(kernel, "_BindPoses", bindPoseBuffer); compute.SetBuffer(kernel, "_BoneMatrices", boneMatrixBuffer); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); GPUHelper.Dispatch1D(compute, kernel, count); } }
protected void Wander(float t, float dt) { var kernel = compute.FindKernel("Wander"); compute.SetBuffer(kernel, "_Crowd", crowdBuffer.Read); compute.SetFloat("_Time", t); compute.SetFloat("_DT", dt); SetupGradient(kernel); compute.SetFloat("_WanderRadius", wanderRadius); compute.SetFloat("_WanderDistance", wanderDistance); compute.SetFloat("_WanderWeight", wanderWeight); GPUHelper.Dispatch1D(compute, kernel, count); }
protected void Bake() { var kernel = compute.FindKernel((dendrite.Type == DendriteType.Skinned) ? "BakeSkinned" : "Bake"); compute.SetTexture(kernel, "_Volume", buffer); var max = Mathf.Max(bounds.size.x, bounds.size.y, bounds.size.z); compute.SetVector("_Min", bounds.min + new Vector3(bounds.size.x - max, bounds.size.y - max, bounds.size.z - max) * 0.5f); compute.SetVector("_Size", Vector3.one * max); compute.SetFloat("_Thickness", thickness); compute.SetBuffer(kernel, "_Edges", dendrite.EdgeBuffer); compute.SetBuffer(kernel, "_Nodes", dendrite.NodeBuffer); compute.SetInt("_EdgesCount", dendrite.EdgesCount); GPUHelper.Dispatch1D(compute, kernel, dendrite.EdgesCount); }
protected override void InitializeKernels() { sumCalculateFunction = Type.GetType("DeepDave.Layer.Kernels.SumCalculate").GetMethod("FullyConnectedLayer2D", BindingFlags.NonPublic | BindingFlags.Static); activationFunction = Type.GetType("DeepDave.Layer.Kernels.ActivationFunctions").GetMethod("Softmax", BindingFlags.NonPublic | BindingFlags.Static); sumErrorFunction = Type.GetType("DeepDave.Layer.Kernels.SoftmaxFunctions").GetMethod("Error", BindingFlags.NonPublic | BindingFlags.Static); adjustWheigtsFunction = Type.GetType("DeepDave.Layer.Kernels.WheightAdjustment").GetMethod("FullyConnectedLayer2D", BindingFlags.NonPublic | BindingFlags.Static); var info = Type.GetType("DeepDave.Layer.Kernels.SoftmaxFunctions").GetMethod("SumActivatedOutputs", BindingFlags.NonPublic | BindingFlags.Static); sumActivatedOutputs = GPUHelper.CreateKernel(info).CreateLauncherDelegate <Action <AcceleratorStream, Index1, ArrayView <float>, ArrayView2D <float> > >(); info = Type.GetType("DeepDave.Layer.Kernels.SoftmaxFunctions").GetMethod("DivisionBySumActivatedOutputs", BindingFlags.NonPublic | BindingFlags.Static); divisionBySumActivatedOutputs = GPUHelper.CreateKernel(info).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView <float>, ArrayView2D <float>, ArrayView2D <float> > >(); info = Type.GetType("DeepDave.Layer.Kernels.DerivativeFunctions").GetMethod("Softmax", BindingFlags.NonPublic | BindingFlags.Static); softmaxDerivative = GPUHelper.CreateKernel(info).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float> > >(); info = Type.GetType("DeepDave.Layer.Kernels.SoftmaxFunctions").GetMethod("Normalization", BindingFlags.NonPublic | BindingFlags.Static); softmaxNormalization = GPUHelper.CreateKernel(info).CreateLauncherDelegate <Action <AcceleratorStream, Index1, ArrayView2D <float> > >(); base.InitializeKernels(); }
protected void Build() { var kernel = compute.FindKernel("Build"); compute.SetInt("_Width", N); compute.SetInt("_Height", N); compute.SetInt("_Depth", N); compute.SetInt("_Border", 1); compute.SetFloat("_Inv", 1f / N); compute.SetFloat("_Threshold", threshold); compute.SetTexture(kernel, "_Volume", volume.Tex); compute.SetBuffer(kernel, "_Buffer", vertexBuffer); compute.SetTexture(kernel, "_Normals", normalBuffer); compute.SetBuffer(kernel, "_CubeEdgeFlags", cubeEdgeFlags); compute.SetBuffer(kernel, "_TriangleConnectionTable", triangleConnectionTable); GPUHelper.Dispatch3D(compute, kernel, N, N, N); }
internal InputLayer2D(Size dimensions, Layer2D prevLayer, int sliceCount, string function = null) : base(prevLayer, null, sliceCount) { this.inputs = new MemoryBuffer2D <float> [sliceCount]; var widthOutput = (int)dimensions.Width; var heightOutput = (int)dimensions.Height; for (int i = 0; i < sliceCount; i++) { this.inputs[i] = GPUHelper.CreateBuffer(widthOutput, heightOutput); this.activated[i] = GPUHelper.CreateBuffer(widthOutput, heightOutput); this.sumInput[i] = GPUHelper.CreateBuffer(widthOutput, heightOutput); } if (function != null) { MethodInfo methodInfo = Type.GetType("DeepDave.Layer.Kernels.NormalizationFunctions").GetMethod(function, BindingFlags.NonPublic | BindingFlags.Static); normalize = GPUHelper.CreateKernel(methodInfo).CreateLauncherDelegate <Action <AcceleratorStream, Index2, ArrayView2D <float>, ArrayView2D <float>, ArrayView <float> > >(); } }
public FullyConnectedLayer2D(Size outputSize, int sliceCount, Layer2D prevLayer, string activationFunction) : base(prevLayer, activationFunction, sliceCount) { var x = (int)outputSize.Width; var y = (int)outputSize.Height; var fac = GetSuitableFactorForFunction(function, x * y); for (int i = 0; i < sliceCount; i++) { float[] source = { Config.learningRate, fac }; this.variable[i] = GPUHelper.CreateBuffer(source, 2); this.bias[i] = GPUHelper.CreateBuffer(x, y); this.activated[i] = GPUHelper.CreateBuffer(x, y); this.sumInput[i] = GPUHelper.CreateBuffer(x, y); this.error[i] = GPUHelper.CreateBuffer(x, y); this.weight[i] = GPUHelper.CreateBuffer(x, y, this.GetWeightCount()); this.derived[i] = GPUHelper.CreateBuffer(x, y); } }
protected virtual void Compute(Kernel kernel, float dt) { compute.SetInt(kInstancesCountKey, instancesCount); compute.SetBuffer(kernel.Index, kBonesKey, boneBuffer); compute.SetInt(kBonesCountKey, boneCount); compute.SetFloat(kBonesCountInvKey, 1f / boneCount); var t = Time.timeSinceLevelLoad; compute.SetVector(kTimeKey, new Vector4(t / 20f, t, t * 2f, t * 3f)); compute.SetVector(kDTKey, new Vector2(dt, (dt < float.Epsilon) ? 0f : 1f / dt)); compute.SetMatrix(kWorldToLocalKey, transform.worldToLocalMatrix); compute.SetMatrix(kLocalToWorldKey, transform.localToWorldMatrix); compute.SetMatrix(kBindMatrixKey, material.GetMatrix(kBindMatrixKey)); compute.SetMatrix(kBindMatrixInvKey, material.GetMatrix(kBindMatrixInvKey)); GPUHelper.Dispatch1D(compute, kernel, instancesCount); }
protected void Connect() { var kernel = compute.FindKernel("Connect"); compute.SetFloat("_MassMin", massMin); compute.SetFloat("_MassMax", massMax); compute.SetBuffer(kernel, "_Nodes", nodeBuffer); compute.SetBuffer(kernel, "_NodesPoolConsume", nodePoolBuffer); compute.SetBuffer(kernel, "_EdgesAppend", edgeBuffer); compute.SetBuffer(kernel, "_CandidatesConsume", candidateBuffer); var connectCount = Mathf.Min(nodesCount, CopyCount(candidateBuffer)); if (connectCount > 0) { compute.SetInt("_ConnectCount", connectCount); GPUHelper.Dispatch1D(compute, kernel, connectCount); } }