public CricleDataBase(int size = 1, S para = default)
{
LogTool.LogAssertIsTrue(size > 0, "size should be bigger than 0");
this.cricleIndexer = new CricleIndexer(size, 0);
var c = 0;
while (c++ < size)
{
this.dataList.Add(this.OnCreate(para));
}
}
public void Sort(ref GPUBufferVariable <T> source)
{
LogTool.LogAssertIsTrue(Mathf.IsPowerOfTwo(source.Size), "num of source should be power of 2");
LogTool.LogAssertIsTrue(source.Size >= BITONIC_BLOCK_SIZE * TRANSPOSE_BLOCK_SIZE, "source size must bigger than " + (BITONIC_BLOCK_SIZE * TRANSPOSE_BLOCK_SIZE));
if (this.tempBuffer == null || this.tempBuffer.Size != source.Size)
{
this.tempBuffer.InitBuffer(source.Size);
}
ComputeShader sortCS = this.bitonicCS;
int KERNEL_ID_BITONICSORT = sortCS.FindKernel("BitonicSort");
int KERNEL_ID_TRANSPOSE = sortCS.FindKernel("MatrixTranspose");
uint NUM_ELEMENTS = (uint)source.Size;
uint MATRIX_WIDTH = BITONIC_BLOCK_SIZE;
uint MATRIX_HEIGHT = (uint)NUM_ELEMENTS / BITONIC_BLOCK_SIZE;
for (uint level = 2; level <= BITONIC_BLOCK_SIZE; level <<= 1)
{
SetGPUSortConstants(sortCS, level, level, MATRIX_HEIGHT, MATRIX_WIDTH);
// Sort the row data
sortCS.SetBuffer(KERNEL_ID_BITONICSORT, "Data", source);
sortCS.Dispatch(KERNEL_ID_BITONICSORT, (int)(NUM_ELEMENTS / BITONIC_BLOCK_SIZE), 1, 1);
}
// Then sort the rows and columns for the levels > than the block size
// Transpose. Sort the Columns. Transpose. Sort the Rows.
for (uint level = (BITONIC_BLOCK_SIZE << 1); level <= NUM_ELEMENTS; level <<= 1)
{
// Transpose the data from buffer 1 into buffer 2
SetGPUSortConstants(sortCS, level / BITONIC_BLOCK_SIZE, (level & ~NUM_ELEMENTS) / BITONIC_BLOCK_SIZE, MATRIX_WIDTH, MATRIX_HEIGHT);
sortCS.SetBuffer(KERNEL_ID_TRANSPOSE, "Input", source);
sortCS.SetBuffer(KERNEL_ID_TRANSPOSE, "Data", tempBuffer);
sortCS.Dispatch(KERNEL_ID_TRANSPOSE, (int)(MATRIX_WIDTH / TRANSPOSE_BLOCK_SIZE), (int)(MATRIX_HEIGHT / TRANSPOSE_BLOCK_SIZE), 1);
// Sort the transposed column data
sortCS.SetBuffer(KERNEL_ID_BITONICSORT, "Data", tempBuffer);
sortCS.Dispatch(KERNEL_ID_BITONICSORT, (int)(NUM_ELEMENTS / BITONIC_BLOCK_SIZE), 1, 1);
// Transpose the data from buffer 2 back into buffer 1
SetGPUSortConstants(sortCS, BITONIC_BLOCK_SIZE, level, MATRIX_HEIGHT, MATRIX_WIDTH);
sortCS.SetBuffer(KERNEL_ID_TRANSPOSE, "Input", tempBuffer);
sortCS.SetBuffer(KERNEL_ID_TRANSPOSE, "Data", source);
sortCS.Dispatch(KERNEL_ID_TRANSPOSE, (int)(MATRIX_HEIGHT / TRANSPOSE_BLOCK_SIZE), (int)(MATRIX_WIDTH / TRANSPOSE_BLOCK_SIZE), 1);
// Sort the row data
sortCS.SetBuffer(KERNEL_ID_BITONICSORT, "Data", source);
sortCS.Dispatch(KERNEL_ID_BITONICSORT, (int)(NUM_ELEMENTS / BITONIC_BLOCK_SIZE), 1, 1);
}
}
public static Vector <T> Sub(int from, int to, Vector <T> src)
{
LogTool.LogAssertIsTrue(to > from && from >= 0, "Vector index Error");
var ret = new Vector <T>(to - from);
var count = 0;
for (var i = from; i < to; ++i)
{
ret[count++] = src[i];
}
return(ret);
}
public static Vector <T> operator /(Vector <T> a, float b)
{
dynamic rhs = b;
LogTool.LogAssertIsTrue(rhs != 0, "Vector size is not same");
var ret = new Vector <T>(a.Size);
for (var i = 0; i < a.Size; ++i)
{
dynamic lhs = a[i];
ret[i] = lhs / rhs;
}
return(ret);
}
public static Vector <T> operator -(Vector <T> a, Vector <T> b)
{
LogTool.LogAssertIsTrue(a.Size == b.Size, "Vector size is not same");
var ret = new Vector <T>(a.Size);
for (var i = 0; i < a.Size; ++i)
{
dynamic lhs = a[i];
dynamic rhs = b[i];
ret[i] = lhs - rhs;
}
return(ret);
}
protected void Start()
{
this.function = this.GetComponentInChildren <IFunctionProvider>()?.Function;
LogTool.LogAssertIsTrue(this.function != null, "Cannot find function");
this.matrial = new DisposableMaterial(new Material(Shader.Find("Diffuse")));
this.matrial.Data.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
var meshFiter = this.gameObject.FindOrAddTypeInComponentsAndChildren <MeshFilter>();
var meshRender = this.gameObject.FindOrAddTypeInComponentsAndChildren <MeshRenderer>();
meshRender.material = this.matrial;
var mesh = FunctionTool.GenerateFunctionMesh(this.function);
meshFiter.mesh = mesh;
}
public override ISolution Solve(IProblem problem)
{
LogTool.LogAssertIsTrue(this.dt != null, "Dt is null");
var sol = new Solution();
var p = this.problem as Problem;
p.Next.Generate(null);
var current = p.Current.Evaluate(null);
var next = p.Next.Evaluate(null);
var useNext = this.ShouldUseNext(current, next);
if (useNext)
{
p.MoveToNext();
}
p.Cool(useNext);
sol.Current = p.Current;
return(sol);
}
public CricleIndexer(int size, int current)
{
LogTool.LogAssertIsTrue(size > 0, "size should be bigger than 0");
this.size = size;
this.current = this.GetIndex(current);
}
public CricleIndexer(int size)
{
LogTool.LogAssertIsTrue(size > 0, "size should be bigger than 0");
this.size = size;
this.current = -1;
}
