VertexBuffers.BufferRenderer IModel.GetPositionBufferRenderer(string varNameInShader)
{
using (var buffer = new PositionBuffer(varNameInShader))
{
buffer.Alloc(positionArray.Length);
unsafe
{
vec3 *array = (vec3 *)buffer.FirstElement();
for (int i = 0; i < positionArray.Length; i++)
{
array[i] = positionArray[i];
}
}
return(buffer.GetRenderer());
}
}
CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetNormalBufferRenderer(string varNameInShader)
{
using (var buffer = new SphereModelNormalBuffer(varNameInShader))
{
buffer.Alloc(normals.Length);
unsafe
{
vec3 *array = (vec3 *)buffer.FirstElement();
for (int i = 0; i < normals.Length; i++)
{
array[i] = normals[i];
}
}
return(buffer.GetRenderer());
}
}
CSharpGL.Objects.VertexBuffers.BufferPointer IModel.GetNormalBufferRenderer(string varNameInShader)
{
using (var buffer = new ObjModelNormalBuffer(varNameInShader))
{
buffer.Alloc(model.normalList.Count);
unsafe
{
vec3 *array = (vec3 *)buffer.FirstElement();
for (int i = 0; i < model.normalList.Count; i++)
{
array[i] = model.normalList[i];
}
}
return(buffer.GetRenderer());
}
}
VertexBuffers.BufferPointer IModel.GetNormalBufferRenderer(string varNameInShader)
{
using (var buffer = new NormalBuffer(varNameInShader))
{
buffer.Alloc(this.normals.Length);
unsafe
{
vec3 *array = (vec3 *)buffer.FirstElement();
for (int i = 0; i < this.normals.Length; i++)
{
array[i] = this.normals[i];
}
}
return(buffer.GetRenderer());
}
}
CSharpGL.Objects.VertexBuffers.BufferRenderer IModel.GetPositionBufferRenderer(string varNameInShader)
{
using (var buffer = new ObjModelPositionBuffer(varNameInShader))
{
buffer.Alloc(positions.Count);
unsafe
{
vec3 *array = (vec3 *)buffer.FirstElement();
for (int i = 0; i < positions.Count; i++)
{
array[i] = positions[i];
}
}
return(buffer.GetRenderer());
}
}
CSharpGL.Objects.VertexBuffers.BufferPointer IModel.GetColorBufferRenderer(string varNameInShader)
{
using (var colorBuffer = new IceCreamModelColorBuffer(varNameInShader))
{
colorBuffer.Alloc(colors.Length);
unsafe
{
vec3 *array = (vec3 *)colorBuffer.FirstElement();
for (int i = 0; i < colors.Length; i++)
{
array[i] = colors[i];
}
}
return(colorBuffer.GetRenderer());
}
}
CSharpGL.Objects.VertexBuffers.BufferPointer IModel.GetPositionBufferRenderer(string varNameInShader)
{
using (var positionBuffer = new IceCreamModelPositionBuffer(varNameInShader))
{
positionBuffer.Alloc(positions.Length);
unsafe
{
vec3 *array = (vec3 *)positionBuffer.FirstElement();
for (int i = 0; i < positions.Length; i++)
{
array[i] = positions[i];
}
}
return(positionBuffer.GetRenderer());
}
}
public CSharpGL.Objects.VertexBuffers.BufferRenderer GetColorBufferRenderer(string varNameInShader)
{
using (var buffer = new ColorBuffer(varNameInShader))
{
vec3[] colors = this.model.colors;
buffer.Alloc(colors.Length);
unsafe
{
vec3 *header = (vec3 *)buffer.FirstElement();
for (int i = 0; i < colors.Length; i++)
{
header[i] = colors[i];
}
}
return(buffer.GetRenderer());
}
}
public CSharpGL.Objects.VertexBuffers.BufferRenderer GetPositionBufferRenderer(string varNameInShader)
{
using (var buffer = new PositionBuffer(varNameInShader))
{
vec3[] positions = this.model.positions;
buffer.Alloc(positions.Length);
unsafe
{
vec3 *header = (vec3 *)buffer.FirstElement();
for (int i = 0; i < positions.Length; i++)
{
header[i] = positions[i];
}
}
return(buffer.GetRenderer());
}
}
public static void TypicalScene()
{
const int count = 1000000;
long startTick = 0;
long interval, interval2;
// 测试float类型
{
var floatArray = new UnmanagedArray <float>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
floatArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = floatArray[i];
if (item != i)
{
throw new Exception();
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
float *header = (float *)floatArray.FirstElement();
float *last = (float *)floatArray.LastElement();
float *tailAddress = (float *)floatArray.TailAddress();
int value = 0;
for (float *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = value++;
}
int i = 0;
for (float *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
if (item != i)
{
throw new Exception();
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 测试decimal类型
{
var decimalArray = new UnmanagedArray <decimal>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
decimalArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = decimalArray[i];
if (item != i)
{
throw new Exception();
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
decimal *header = (decimal *)decimalArray.FirstElement();
decimal *last = (decimal *)decimalArray.LastElement();
decimal *tailAddress = (decimal *)decimalArray.TailAddress();
int value = 0;
for (decimal *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = value++;
}
int i = 0;
for (decimal *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
if (item != i)
{
throw new Exception();
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 测试int类型
{
var intArray = new UnmanagedArray <int>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
intArray[i] = i;
}
for (int i = 0; i < count; i++)
{
var item = intArray[i];
if (item != i)
{
throw new Exception();
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
int *header = (int *)intArray.FirstElement();
int *last = (int *)intArray.LastElement();
int *tailAddress = (int *)intArray.TailAddress();
int value = 0;
for (int *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = value++;
}
int i = 0;
for (int *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
if (item != i)
{
throw new Exception();
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 测试bool类型
{
var boolArray = new UnmanagedArray <bool>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
boolArray[i] = i % 2 == 0;
}
for (int i = 0; i < count; i++)
{
var item = boolArray[i];
if (item != (i % 2 == 0))
{
throw new Exception();
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
bool *header = (bool *)boolArray.FirstElement();
bool *last = (bool *)boolArray.LastElement();
bool *tailAddress = (bool *)boolArray.TailAddress();
int value = 0;
for (bool *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = (value % 2 == 0);
value++;
}
int i = 0;
for (bool *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
if (item != (i % 2 == 0))
{
throw new Exception();
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 测试vec3类型
{
var vec3Array = new UnmanagedArray <vec3>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
vec3Array[i] = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
}
for (int i = 0; i < count; i++)
{
var item = vec3Array[i];
var old = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
if (item.x != old.x || item.y != old.y || item.z != old.z)
{
throw new Exception();
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
vec3 *header = (vec3 *)vec3Array.FirstElement();
vec3 *last = (vec3 *)vec3Array.LastElement();
vec3 *tailAddress = (vec3 *)vec3Array.TailAddress();
int i = 0;
for (vec3 *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
i++;
}
i = 0;
for (vec3 *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
var old = new vec3(i * 3 + 0, i * 3 + 1, i * 3 + 2);
if (item.x != old.x || item.y != old.y || item.z != old.z)
{
throw new Exception();
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 测试mat4类型
{
var vec3Array = new UnmanagedArray <mat4>(count);
startTick = DateTime.Now.Ticks;
for (int i = 0; i < count; i++)
{
vec3Array[i] = new mat4(new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3));
}
for (int i = 0; i < count; i++)
{
var item = vec3Array[i];
var old = new mat4(new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3));
for (int col = 0; col < 4; col++)
{
for (int row = 0; row < 4; row++)
{
if (item[col][row] != old[col][row])
{
throw new Exception();
}
}
}
}
interval = DateTime.Now.Ticks - startTick;
unsafe
{
startTick = DateTime.Now.Ticks;
mat4 *header = (mat4 *)vec3Array.FirstElement();
mat4 *last = (mat4 *)vec3Array.LastElement();
mat4 *tailAddress = (mat4 *)vec3Array.TailAddress();
int i = 0;
for (mat4 *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++)
{
*ptr = new mat4(new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3));
i++;
}
i = 0;
for (mat4 *ptr = header; ptr <= last /*or: ptr < tailAddress*/; ptr++, i++)
{
var item = *ptr;
var old = new mat4(new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3), new vec4(i, i + 1, i + 2, i + 3));
for (int col = 0; col < 4; col++)
{
for (int row = 0; row < 4; row++)
{
if (item[col][row] != old[col][row])
{
throw new Exception();
}
}
}
}
interval2 = DateTime.Now.Ticks - startTick;
}
Console.WriteLine("Ticks: safe: {0} vs unsafe: {1}", interval, interval2);
}
// 立即释放所有非托管数组占用的内存，任何之前创建的UnmanagedBase数组都不再可用了。
UnmanagedArray <int> .FreeAll();
}
/// <summary>
/// 用随机颜色更新当前的颜色。
/// </summary>
public void UpdateColorBuffer()
{
{
// update buffer object.
GL.BindBuffer(BufferTarget.ArrayBuffer, this.colorBuffer[0]);
IntPtr destColors = GL.MapBuffer(BufferTarget.ArrayBuffer, MapBufferAccess.ReadWrite);
//colorArray.CopyTo(destColors);
unsafe
{
vec3 *array = (vec3 *)destColors.ToPointer();
int index = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
for (int k = 0; k < size; k++)
{
//vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
{
vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
array[index++] = color;
}
}
}
}
}
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
}
//// This do the same thing: update buffer object
//using (var mappingBuffer = new MappingBuffer(BufferTarget.ArrayBuffer, this.colorBuffer[0], MapBufferAccess.ReadWrite))
//{
// //colorArray.CopyTo(mappingBuffer.BufferPointer);
// unsafe
// {
// vec3* array = (vec3*)mappingBuffer.BufferPointer.ToPointer();
// int index = 0;
// for (int i = 0; i < size; i++)
// {
// for (int j = 0; j < size; j++)
// {
// for (int k = 0; k < size; k++)
// {
// //vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
// for (int cubeIndex = 0; cubeIndex < 8; cubeIndex++)
// {
// vec3 color = new vec3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
// array[index++] = color;
// }
// }
// }
// }
// }
//}
//colorArray.Dispose();
}
unsafe void InitializeVAO()
{
vec3[] colors = new vec3[] { new vec3(1, 0, 0), new vec3(0, 1, 0), new vec3(0, 0, 1) };
// 计算三个坐标轴
for (int axisIndex = 0; axisIndex < 3; axisIndex++)
{
var axisVertexCount = faceCount * 2;
// Create a vertex buffer for the vertex data.
using (var positionBuffer = new AxisPositionBuffer(strin_Position, BufferUsage.StaticDraw))
{
positionBuffer.Alloc(axisVertexCount);
vec3 *positionArray = (vec3 *)positionBuffer.FirstElement();
for (int i = 0; i < axisVertexCount; i++)
{
int face = i / 2;
float[] components = new float[] {
i % 2 == 1 ? 0 : this.axisLength,
(float)(this.radius * Math.Cos(face * (Math.PI * 2) / faceCount)),
(float)(this.radius * Math.Sin(face * (Math.PI * 2) / faceCount))
};
positionArray[i] = new vec3(
components[(0 + axisIndex) % 3], components[(2 + axisIndex) % 3], components[(4 + axisIndex) % 3]);
}
this.positionBufferRenderers[axisIndex] = positionBuffer.GetRenderer();
}
// Now do the same for the color data.
using (var colorBuffer = new AxisColorBuffer(strin_Color, BufferUsage.StaticDraw))
{
colorBuffer.Alloc(axisVertexCount);
vec3 *colorArray = (vec3 *)colorBuffer.FirstElement();
for (int i = 0; i < axisVertexCount; i++)
{
colorArray[i] = colors[axisIndex];
}
this.colorBufferRenderers[axisIndex] = colorBuffer.GetRenderer();
}
// Now for the index data.
using (var indexBuffer = new AxisIndexBuffer())
{
int indexLength = axisVertexCount + 2;
indexBuffer.Alloc(indexLength);
byte *cylinderIndex = (byte *)indexBuffer.FirstElement();
for (int i = 0; i < indexLength - 2; i++)
{
cylinderIndex[i] = (byte)i;
}
cylinderIndex[indexLength - 2] = 0;
cylinderIndex[indexLength - 1] = 1;
this.indexBufferRenderers[axisIndex] = indexBuffer.GetRenderer() as IndexBufferPointerBase;
}
}
// 计算XZ平面
{
int planVertexCount = 4;
// Create a vertex buffer for the vertex data.
using (var positionBuffer = new AxisPositionBuffer(strin_Position, BufferUsage.StaticDraw))
{
positionBuffer.Alloc(planVertexCount);
vec3 *plan = (vec3 *)positionBuffer.FirstElement();
{
float length = this.axisLength;
plan[0] = new vec3(-length, 0, -length);
plan[1] = new vec3(-length, 0, length);
plan[2] = new vec3(length, 0, length);
plan[3] = new vec3(length, 0, -length);
}
this.planPositionBufferRenderer = positionBuffer.GetRenderer();
}
// Now do the same for the colour data.
using (var colorBuffer = new AxisColorBuffer(strin_Color, BufferUsage.StaticDraw))
{
colorBuffer.Alloc(planVertexCount);
vec3 *colorArray = (vec3 *)colorBuffer.FirstElement();
{
for (int i = 0; i < planVertexCount; i++)
{
colorArray[i] = this.planColor;
}
}
this.planColorBufferRenderer = colorBuffer.GetRenderer();
}
using (var indexBuffer = new ZeroIndexBuffer(DrawMode.LineLoop, 0, planVertexCount))
{
indexBuffer.Alloc(planVertexCount);//这句话实际上什么都没有做。
this.planIndexBufferRenderer = indexBuffer.GetRenderer() as IndexBufferPointerBase;
}
}
}
/// <summary>
/// main slicing function
/// </summary>
private unsafe void SliceVolume(vec3 viewDir, int num_slices)
{
//get the max and min distance of each vertex of the unit cube
//in the viewing direction
float max_dist = viewDir.dot(vertexList[0]);
float min_dist = max_dist;
int max_index = 0;
int count = 0;
for (int i = 1; i < 8; i++)
{
//get the distance between the current unit cube vertex and
//the view vector by dot product
float dist = viewDir.dot(vertexList[i]);
//if distance is > max_dist, store the value and index
if (dist > max_dist)
{
max_dist = dist;
max_index = i;
}
//if distance is < min_dist, store the value
if (dist < min_dist)
{
min_dist = dist;
}
}
//find tha abs maximum of the view direction vector
int max_dim = FindAbsMax(viewDir);
//expand it a little bit
min_dist -= EPSILON;
max_dist += EPSILON;
//local variables to store the start, direction vectors,
//lambda intersection values
vec3[] vecStart = new vec3[12];
vec3[] vecDir = new vec3[12];
float[] lambda = new float[12];
float[] lambda_inc = new float[12];
float denom = 0;
//set the minimum distance as the plane_dist
//subtract the max and min distances and divide by the
//total number of slices to get the plane increment
float plane_dist = min_dist;
float plane_dist_inc = (max_dist - min_dist) / ((float)num_slices);
//for all edges
for (int i = 0; i < 12; i++)
{
//get the start position vertex by table lookup
vecStart[i] = vertexList[edges[edgeList[max_index][i]][0]];
//get the direction by table lookup
vecDir[i] = vertexList[edges[edgeList[max_index][i]][1]] - vecStart[i];
//do a dot of vecDir with the view direction vector
denom = vecDir[i].dot(viewDir);
//determine the plane intersection parameter (lambda) and
//plane intersection parameter increment (lambda_inc)
if (1.0 + denom != 1.0)
{
lambda_inc[i] = plane_dist_inc / denom;
lambda[i] = (plane_dist - vecStart[i].dot(viewDir)) / denom;
}
else
{
lambda[i] = -1.0f;
lambda_inc[i] = 0.0f;
}
}
//local variables to store the intesected points
//note that for a plane and sub intersection, we can have
//a minimum of 3 and a maximum of 6 vertex polygon
vec3[] intersection = new vec3[6];
float[] dL = new float[12];
vec3 *vTextureSlices = (vec3 *)this.vVertexBuffer.MapBuffer(MapBufferAccess.WriteOnly);
//loop through all slices
for (int i = num_slices - 1; i >= 0; i--)
{
//determine the lambda value for all edges
for (int e = 0; e < 12; e++)
{
dL[e] = lambda[e] + i * lambda_inc[e];
}
//if the values are between 0-1, we have an intersection at the current edge
//repeat the same for all 12 edges
if ((dL[0] >= 0.0) && (dL[0] < 1.0))
{
intersection[0] = vecStart[0] + dL[0] * vecDir[0];
}
else if ((dL[1] >= 0.0) && (dL[1] < 1.0))
{
intersection[0] = vecStart[1] + dL[1] * vecDir[1];
}
else if ((dL[3] >= 0.0) && (dL[3] < 1.0))
{
intersection[0] = vecStart[3] + dL[3] * vecDir[3];
}
else
{
continue;
}
if ((dL[2] >= 0.0) && (dL[2] < 1.0))
{
intersection[1] = vecStart[2] + dL[2] * vecDir[2];
}
else if ((dL[0] >= 0.0) && (dL[0] < 1.0))
{
intersection[1] = vecStart[0] + dL[0] * vecDir[0];
}
else if ((dL[1] >= 0.0) && (dL[1] < 1.0))
{
intersection[1] = vecStart[1] + dL[1] * vecDir[1];
}
else
{
intersection[1] = vecStart[3] + dL[3] * vecDir[3];
}
if ((dL[4] >= 0.0) && (dL[4] < 1.0))
{
intersection[2] = vecStart[4] + dL[4] * vecDir[4];
}
else if ((dL[5] >= 0.0) && (dL[5] < 1.0))
{
intersection[2] = vecStart[5] + dL[5] * vecDir[5];
}
else
{
intersection[2] = vecStart[7] + dL[7] * vecDir[7];
}
if ((dL[6] >= 0.0) && (dL[6] < 1.0))
{
intersection[3] = vecStart[6] + dL[6] * vecDir[6];
}
else if ((dL[4] >= 0.0) && (dL[4] < 1.0))
{
intersection[3] = vecStart[4] + dL[4] * vecDir[4];
}
else if ((dL[5] >= 0.0) && (dL[5] < 1.0))
{
intersection[3] = vecStart[5] + dL[5] * vecDir[5];
}
else
{
intersection[3] = vecStart[7] + dL[7] * vecDir[7];
}
if ((dL[8] >= 0.0) && (dL[8] < 1.0))
{
intersection[4] = vecStart[8] + dL[8] * vecDir[8];
}
else if ((dL[9] >= 0.0) && (dL[9] < 1.0))
{
intersection[4] = vecStart[9] + dL[9] * vecDir[9];
}
else
{
intersection[4] = vecStart[11] + dL[11] * vecDir[11];
}
if ((dL[10] >= 0.0) && (dL[10] < 1.0))
{
intersection[5] = vecStart[10] + dL[10] * vecDir[10];
}
else if ((dL[8] >= 0.0) && (dL[8] < 1.0))
{
intersection[5] = vecStart[8] + dL[8] * vecDir[8];
}
else if ((dL[9] >= 0.0) && (dL[9] < 1.0))
{
intersection[5] = vecStart[9] + dL[9] * vecDir[9];
}
else
{
intersection[5] = vecStart[11] + dL[11] * vecDir[11];
}
//after all 6 possible intersection vertices are obtained,
//we calculated the proper polygon indices by using indices of a triangular fan
int[] indices = new int[] { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5 };
//Using the indices, pass the intersection vertices to the vTextureSlices vector
for (int t = 0; t < 12; t++)
{
vTextureSlices[count++] = intersection[indices[t]];
}
}
////update buffer object with the new vertices
this.vVertexBuffer.UnmapBuffer();
}
/// <summary>
/// main slicing function
/// </summary>
private unsafe void SliceVolume(vec3 cameraFront, int num_slices)
{
float maxCos, minCos; int maxCosIndex;
FindMaxMin(out maxCos, out minCos, out maxCosIndex);
//local variables to store the start, direction vectors,
//lambda intersection values
vec3[] vStart = new vec3[12];
vec3[] vDirection = new vec3[12];
float[] lambda = new float[12];
float[] lambda_inc = new float[12];
float denom = 0;
//set the minimum distance as the plane_dist
//subtract the max and min distances and divide by the
//total number of slices to get the plane increment
float plane_dist_inc = (maxCos - minCos) / ((float)num_slices);
//for all edges
for (int i = 0; i < 12; i++)
{
//get the start position vertex by table lookup
int[] group = edgeGroups[maxCosIndex];
int edgeIndex = group[i];
int[] edge = edgeList[edgeIndex];
int v0Index = edge[0];
vStart[i] = vertexList[v0Index];
//get the direction by table lookup
int v1Index = edge[1];
vDirection[i] = vertexList[v1Index] - vertexList[v0Index];
//do a dot of vDirection with the view direction vector
denom = vDirection[i].dot(cameraFront);
//determine the plane intwction parameter (lambda) and
//plane intersection parameter increment (lambda_inc)
if (1.0 + denom != 1.0)
{
lambda_inc[i] = plane_dist_inc / denom;
lambda[i] = (minCos - vStart[i].dot(cameraFront)) / denom;
}
else
{
lambda[i] = -1.0f;
lambda_inc[i] = 0.0f;
}
}
//local variables to store the intesected points
//note that for a plane and sub intersection, we can have
//a minimum of 3 and a maximum of 6 vertex polygon
vec3[] intersection = new vec3[6];
float[] dL = new float[12];
int count = 0;
vec3* vTextureSlices = (vec3*)this.vVertexBuffer.MapBuffer(MapBufferAccess.WriteOnly);
//loop through all slices
for (int i = num_slices - 1; i >= 0; i--)
{
//determine the lambda value for all edges
for (int e = 0; e < 12; e++)
{
dL[e] = lambda[e] + i * lambda_inc[e];
}
//if the values are between 0-1, we have an intersection at the current edge
//repeat the same for all 12 edges
if ((dL[0] >= 0.0) && (dL[0] < 1.0))
{
intersection[0] = vStart[0] + dL[0] * vDirection[0];
}
else if ((dL[1] >= 0.0) && (dL[1] < 1.0))
{
intersection[0] = vStart[1] + dL[1] * vDirection[1];
}
else if ((dL[3] >= 0.0) && (dL[3] < 1.0))
{
intersection[0] = vStart[3] + dL[3] * vDirection[3];
}
else continue;
if ((dL[2] >= 0.0) && (dL[2] < 1.0))
{
intersection[1] = vStart[2] + dL[2] * vDirection[2];
}
else if ((dL[0] >= 0.0) && (dL[0] < 1.0))
{
intersection[1] = vStart[0] + dL[0] * vDirection[0];
}
else if ((dL[1] >= 0.0) && (dL[1] < 1.0))
{
intersection[1] = vStart[1] + dL[1] * vDirection[1];
}
else
{
intersection[1] = vStart[3] + dL[3] * vDirection[3];
}
if ((dL[4] >= 0.0) && (dL[4] < 1.0))
{
intersection[2] = vStart[4] + dL[4] * vDirection[4];
}
else if ((dL[5] >= 0.0) && (dL[5] < 1.0))
{
intersection[2] = vStart[5] + dL[5] * vDirection[5];
}
else
{
intersection[2] = vStart[7] + dL[7] * vDirection[7];
}
if ((dL[6] >= 0.0) && (dL[6] < 1.0))
{
intersection[3] = vStart[6] + dL[6] * vDirection[6];
}
else if ((dL[4] >= 0.0) && (dL[4] < 1.0))
{
intersection[3] = vStart[4] + dL[4] * vDirection[4];
}
else if ((dL[5] >= 0.0) && (dL[5] < 1.0))
{
intersection[3] = vStart[5] + dL[5] * vDirection[5];
}
else
{
intersection[3] = vStart[7] + dL[7] * vDirection[7];
}
if ((dL[8] >= 0.0) && (dL[8] < 1.0))
{
intersection[4] = vStart[8] + dL[8] * vDirection[8];
}
else if ((dL[9] >= 0.0) && (dL[9] < 1.0))
{
intersection[4] = vStart[9] + dL[9] * vDirection[9];
}
else
{
intersection[4] = vStart[11] + dL[11] * vDirection[11];
}
if ((dL[10] >= 0.0) && (dL[10] < 1.0))
{
intersection[5] = vStart[10] + dL[10] * vDirection[10];
}
else if ((dL[8] >= 0.0) && (dL[8] < 1.0))
{
intersection[5] = vStart[8] + dL[8] * vDirection[8];
}
else if ((dL[9] >= 0.0) && (dL[9] < 1.0))
{
intersection[5] = vStart[9] + dL[9] * vDirection[9];
}
else
{
intersection[5] = vStart[11] + dL[11] * vDirection[11];
}
//after all 6 possible intersection vertices are obtained,
//we calculated the proper polygon indices by using indices of a triangular fan
int[] indices = new int[] { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5 };
//Using the indices, pass the intersection vertices to the vTextureSlices vector
for (int t = 0; t < 12; t++)
{
vTextureSlices[count++] = intersection[indices[t]];
}
}
////update buffer object with the new vertices
this.vVertexBuffer.UnmapBuffer();
}
