public static void ClusterSort(NativeArray <Fragment> fragments, NativeArray <float> distances)
{
if (fragments.Length == 0)
{
return;
}
NativeArray <Element> elements = new NativeArray <Element>(fragments.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
Element * elementsPtr = (Element *)elements.GetUnsafePtr();
Fragment *fragmentsPtr = (Fragment *)fragments.GetUnsafePtr();
float * distancePtr = (float *)distances.GetUnsafePtr();
Element newElement;
newElement.sign = 0;
newElement.policy = new Fragment();
newElement.leftValue = -1;
newElement.rightValue = -1;
for (int i = 0; i < elements.Length; ++i)
{
newElement.sign = distancePtr[i];
newElement.policy = fragmentsPtr[i];
elementsPtr[i] = newElement;
}
for (int i = 1; i < fragments.Length; ++i)
{
int currentIndex = 0;
STARTFIND:
Element * currentIndexValue = elementsPtr + currentIndex;
if ((elementsPtr + i)->sign < currentIndexValue->sign)
{
if (currentIndexValue->leftValue < 0)
{
currentIndexValue->leftValue = i;
}
else
{
currentIndex = currentIndexValue->leftValue;
goto STARTFIND;
}
}
else
{
if (currentIndexValue->rightValue < 0)
{
currentIndexValue->rightValue = i;
}
else
{
currentIndex = currentIndexValue->rightValue;
goto STARTFIND;
}
}
}
int start = 0;
Iterate(0, ref start, elements, fragments);
elements.Dispose();
}
public void Execute(int index)
{
NativeArray <Fragment> fragments = allFragments[index];
Fragment * fragPtr = (Fragment *)fragments.GetUnsafePtr();
ClusterMeshData data = new ClusterMeshData();
NativeArray <Point> allPoints = pointsArray[index];
for (int i = 0, pointCount = 0; i < fragments.Length - 1; ++i)
{
int *indices = (int *)&fragPtr[i].indices;
for (int a = 0; a < 4; ++a)
{
ref Point p = ref pointsFromMesh[indices[a]];
allPoints[pointCount] = p;
pointCount++;
}
}
public unsafe RenderBuffer <float> Draw <T>(RenderEntity[] entities, T camera) where T : ICamera
{
Clear();
int entityCount = entities.Length;
BeginRasterize();
SetPerRenderValues(camera);
for (int i = 0; i < entityCount; i++)
{
RenderEntity currentEntity = entities[i];
SetPerObjectValues(currentEntity);
Material material = currentEntity.Material ?? DEFAULT_MATERIAL;
Model model = currentEntity.Model;
#region Vertex Stage
//Prepare vertex shader
VertexInvoker.ChangeActiveShader(material.ShaderType, material.Shader);
//Invoke vertex shader
int vertexCount = model.Vertices.Length;
Vector2 *coordsOutput = stackalloc Vector2[vertexCount];
ShaderInOutPatternDefault *inoutPtr = stackalloc ShaderInOutPatternDefault[1];
for (int j = 0; j < vertexCount; j++)
{
VertexInvoker.Invoke(model.ReadVerticesDataAsPattern(j));
VertexInvoker.ActiveOutputMap.Write(inoutPtr);
coordsOutput[j] = *(Vector2 *)&inoutPtr->Vertex;
}
#endregion
#region Fragment Stage
FragmentInvoker.ChangeActiveShader(material.ShaderType, material.Shader);
//Primitive assemble
int newPrimitiveCount = AssemblePrimitive(model, coordsOutput);
_rasterizedFragments.AddEmpty(newPrimitiveCount);
switch (_assembleMode)
{
case PrimitiveAssembleMode.Line:
case PrimitiveAssembleMode.LineTriangle:
Rasterize <LinePrimitive, Line>(_linePrimitives.GetPointer(_linePrimitives.Count - newPrimitiveCount), newPrimitiveCount, _rasterizedFragments.GetPointer(_rasterizedFragments.Count - newPrimitiveCount));
break;
case PrimitiveAssembleMode.Triangle:
Rasterize <TrianglePrimitive, Triangle>(_trianglePrimitives.GetPointer(_trianglePrimitives.Count - newPrimitiveCount), newPrimitiveCount, _rasterizedFragments.GetPointer(_rasterizedFragments.Count - newPrimitiveCount));
break;
}
for (int j = _rasterizedFragments.Count - newPrimitiveCount; j < _rasterizedFragments.Count; j++)
{
Fragment *fragment = _rasterizedFragments.GetPointer(j);
for (int k = 0; k < fragment->PixelCount; k++)
{
//Fragment.FragmentData has been tailored to a proper size
FragmentInvoker.Invoke((byte *)fragment->FragmentData[k]);
FragmentInvoker.ActiveOutputMap.Write(inoutPtr);
_renderedColors.Add(inoutPtr->Color);
}
fragment->FragmentColor = _renderedColors.ArchivePointer();
}
#endregion
}
EndRasterize();
//Octree is so annoying
//TODO: View frustum clip, triangle clip, pixel clip
//Clipping();
//This is not the proper way to output, rather for debugging
for (int i = 0; i < _rasterizedFragments.Count; i++)
{
Fragment *fragmentPtr = _rasterizedFragments.GetPointer(i);
RenderTarget.WritePixel(fragmentPtr->Rasterization, fragmentPtr->PixelCount, fragmentPtr->FragmentColor);
}
return(RenderTarget);
}
public unsafe RenderBuffer <float> Draw(RenderEntity[] entities, ICamera camera)
{
RenderTarget.Clear();
int entityCount = entities.Length;
Fragment **rasterizedFragments = stackalloc Fragment *[entityCount];
int * primitiveCounts = stackalloc int[entityCount];
BeginRasterize();
ShaderValue.WorldToView = camera.WorldToView;
ShaderValue.Time = CRenderer.CurrentSecond;
ShaderValue.SinTime = MathF.Sin(ShaderValue.Time);
for (int i = 0; i < entityCount; i++)
{
RenderEntity instanceCopy = entities[i].GetInstanceToApply();
IMaterial material = instanceCopy.Material ?? DEFAULT_MATERIAL;
Vector4[] vertices = instanceCopy.Model.Vertices;
IPrimitive[] primitives = instanceCopy.Model.Primitives;
ShaderValue.ObjectToWorld = instanceCopy.Transform.LocalToWorld;
ShaderValue.ObjectToView = ShaderValue.WorldToView * ShaderValue.ObjectToWorld;
ShaderInvoker <IVertexShader> .ChangeActiveShader(material.ShaderType, material.Shader);
int vertexCount = vertices.Length;
Vector2 *coordsOutput = stackalloc Vector2[vertexCount];
Vector4 *vertexOutput = stackalloc Vector4[vertexCount];
for (int j = 0; j < vertexCount; j++)
{
ShaderInOutMap outputMap = ShaderInvoker <IVertexShader> .Invoke(j, vertices);
vertexOutput[j] = *outputMap.VertexPtr;
coordsOutput[j] = ViewToScreen(*outputMap.VertexPtr);
}
Fragment *fragments = stackalloc Fragment[primitives.Length];
primitiveCounts[i] = primitives.Length;
for (int j = 0; j < primitives.Length; j++)
{
Rasterize(coordsOutput, primitives[j], fragments + j);
}
rasterizedFragments[i] = fragments;
}
EndRasterize();
//Octree is so annoying
//TODO: View frustum clip, triangle clip, pixel clip
//Clipping();
//This is not the proper way to output, just to check result as soon as possible
GenericVector <float> white = new GenericVector <float>(3)
{
1, 1, 1
};
for (int i = 0; i < entityCount; i++)
{
for (int j = 0; j < primitiveCounts[i]; j++)
{
RenderTarget.WritePixel(rasterizedFragments[i][j].Rasterization, rasterizedFragments[i][j].PixelCount, white);
}
}
return(RenderTarget);
}
public static void ContriveResult(Fragment *result)
{
result->PixelCount = RasterizedPixelCount;
result->Rasterization = _pixelCoords.ArchivePointer();
result->FragmentData = _fragmentData.Count > 0 ? (float **)_fragmentData.ArchivePointer() : null;
}
