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