public void Unserialize(GMDataReader reader, int endPos)
{
Name = reader.ReadStringPointerObject();
Type = (ShaderType)(reader.ReadUInt32() & 0x7FFFFFFF);
GLSL_ES_Vertex = reader.ReadStringPointerObject();
GLSL_ES_Fragment = reader.ReadStringPointerObject();
GLSL_Vertex = reader.ReadStringPointerObject();
GLSL_Fragment = reader.ReadStringPointerObject();
HLSL9_Vertex = reader.ReadStringPointerObject();
HLSL9_Fragment = reader.ReadStringPointerObject();
int ptr1 = reader.ReadInt32();
HLSL11_VertexBuffer = reader.ReadPointer <ShaderBuffer>(ptr1);
int ptr2 = reader.ReadInt32();
HLSL11_PixelBuffer = reader.ReadPointer <ShaderBuffer>(ptr2);
VertexAttributes = new List <GMString>();
for (int i = reader.ReadInt32(); i > 0; i--)
{
VertexAttributes.Add(reader.ReadStringPointerObject());
}
if (reader.ReadInt32() != 2)
{
reader.Warnings.Add(new GMWarning("expected 2 in SHDR"));
}
int ptr3 = reader.ReadInt32();
PSSL_VertexBuffer = reader.ReadPointer <ShaderBuffer>(ptr3);
ReadShaderData(reader, PSSL_VertexBuffer, ptr3, reader.ReadInt32());
int currPtr = reader.ReadInt32();
PSSL_PixelBuffer = reader.ReadPointer <ShaderBuffer>(currPtr);
ReadShaderData(reader, PSSL_PixelBuffer, currPtr, reader.ReadInt32());
currPtr = reader.ReadInt32();
CG_PSV_VertexBuffer = reader.ReadPointer <ShaderBuffer>(currPtr);
ReadShaderData(reader, CG_PSV_VertexBuffer, currPtr, reader.ReadInt32());
currPtr = reader.ReadInt32();
CG_PSV_PixelBuffer = reader.ReadPointer <ShaderBuffer>(currPtr);
ReadShaderData(reader, CG_PSV_PixelBuffer, currPtr, reader.ReadInt32());
currPtr = reader.ReadInt32();
CG_PS3_VertexBuffer = reader.ReadPointer <ShaderBuffer>(currPtr);
ReadShaderData(reader, CG_PSV_VertexBuffer, currPtr, reader.ReadInt32());
currPtr = reader.ReadInt32();
CG_PS3_PixelBuffer = reader.ReadPointer <ShaderBuffer>(currPtr);
ReadShaderData(reader, CG_PSV_PixelBuffer, currPtr, reader.ReadInt32());
ReadShaderData(reader, HLSL11_VertexBuffer, ptr1, -1, ptr2 == 0 ? endPos : ptr2);
ReadShaderData(reader, HLSL11_PixelBuffer, ptr2, -1, ptr3 == 0 ? endPos : ptr3);
}
private void ReadShaderData(GMDataReader reader, ShaderBuffer buf, int ptr, int length = -1, int end = -1)
{
if (buf == null)
{
return;
}
int returnTo = reader.Offset;
reader.Offset = ptr;
if (length == -1)
{
buf.Unserialize(reader, end - ptr);
}
else
{
buf.Unserialize(reader, length);
}
reader.Offset = returnTo;
}
//public int GetNodeId(int bufferId, int localNodeId)
//{
// return cummNodeCount[bufferId] + localNodeId;
//}
public SplineTubes(ShaderBufferType shaderBufferType, BufferUsageHint bufferUsageHintType, int bufferMaxElementCount, int[] nodeCount, int segmentElementCount)
{
Utils.Assert(bufferElementSize == 1 || bufferElementSize == 2 || bufferElementSize == 4 || bufferElementSize == 8,
"bufferElementSize == 1 || bufferElementSize == 2 || bufferElementSize == 4 || bufferElementSize == 8");
Utils.Assert(nodeCount.Length > 0,
"nodeCount.Length > 0");
if (shaderBufferType == ShaderBufferType.UBO)
{
if(bufferMaxElementCount > 0)
bufferMaxElementCount = Math.Min(bufferMaxElementCount, GL.GetInteger(GetPName.MaxUniformBlockSize) / sizeof(float) / bufferElementSize);
else
bufferMaxElementCount = GL.GetInteger(GetPName.MaxUniformBlockSize) / sizeof(float) / bufferElementSize;
}
else
{
if (bufferMaxElementCount > 0)
bufferMaxElementCount = Math.Min(bufferMaxElementCount, GL.GetInteger((GetPName)All.MaxShaderStorageBlockSize) / sizeof(float) / bufferElementSize);
else
bufferMaxElementCount = GL.GetInteger((GetPName)All.MaxShaderStorageBlockSize) / sizeof(float) / bufferElementSize;
}
//if(bufferMaxElementCount < 0)
//{
// if(shaderBufferType == ShaderBufferType.UBO)
// bufferMaxElementCount = GL.GetInteger(GetPName.MaxUniformBlockSize) / sizeof(float) / bufferElementSize;
// else
// bufferMaxElementCount = GL.GetInteger((GetPName)All.MaxShaderStorageBlockSize) / sizeof(float) / bufferElementSize;
//}
this.bufferMaxElementCount = bufferMaxElementCount;
//this.bufferElementSize = bufferElementSize;
this.nodeElementCount = TubeNode.Size / bufferElementSize;
this.segmentElementCount = segmentElementCount;
Utils.Assert(bufferMaxElementCount >= (nodeElementCount + segmentElementCount) * 2,
"bufferMaxElementCount >= (nodeElementCount + segmentElementCount) * 2");
this.tubeCount = nodeCount.Length;
var nodeCountCapacity = new int[tubeCount];
this.cummNodeCount = new int[tubeCount + 1];
this.nodeCount = new int[tubeCount];
for (int i = 0; i < tubeCount; ++i)
{
Utils.Assert(nodeCount[i] > 1,
"nodeCount[i] > 1");
cummNodeCount[i] = totalNodeCount;
totalNodeCount += nodeCount[i];
nodeCountCapacity[i] = nodeCount[i];
this.nodeCount[i] = nodeCount[i];
}
cummNodeCount[tubeCount] = totalNodeCount;
var totalNodeCountCapacity = totalNodeCount;
var tubeId = 0;
var bufferId = 0;
var bufferCapacity = bufferMaxElementCount;
var currSegmentCount = 0;
var currNodeCount = 0;
var maxBufferSize = 0;
var dublicatedNode = false;
while (totalNodeCountCapacity > 0)
{
var currNodeCountCapacity = nodeCountCapacity[tubeId];
var firstNode = currNodeCountCapacity == nodeCount[tubeId];
var lastNode = currNodeCountCapacity == 1;
var secondlastNode = currNodeCountCapacity == 2;
var currElementSize = nodeElementCount;
var nextElementSize = nodeElementCount;
if (!lastNode)
currElementSize += segmentElementCount;
if (!secondlastNode)
nextElementSize += segmentElementCount;
var currFits = bufferCapacity >= currElementSize;
var nextFits = bufferCapacity >= currElementSize + nextElementSize;
var addNewNode = currFits && (!firstNode || nextFits);
if (addNewNode)
{
bufferCapacity -= currElementSize;
if (nextFits || lastNode)
{
NodeMappingData mapping;
mapping.BufferId = bufferId;
mapping.Offset = currNodeCount * nodeElementCount;// not finalized
mapping.SegmentOffset = -1;
mapping.Dublicated = dublicatedNode;
mapping.EndNode = lastNode;
mapping.StartNode = firstNode;
idToMemMap.Add(mapping);
if (!lastNode)
++currSegmentCount;
++currNodeCount;
--totalNodeCountCapacity;
--nodeCountCapacity[tubeId];
if (lastNode) ++tubeId;
dublicatedNode = false;
}
else
dublicatedNode = true;
}
if (!addNewNode || totalNodeCountCapacity == 0)
{
var bufferSize = bufferMaxElementCount - bufferCapacity;
Utils.Assert(bufferSize != 0,
"bufferSize != 0");
tubesBufferContent.Add(new ShaderBufferContent(bufferSize));
segmentCount.Add(currSegmentCount);
if (bufferSize > maxBufferSize) maxBufferSize = bufferSize;
bufferCapacity = bufferMaxElementCount;
currSegmentCount = 0;
currNodeCount = 0;
++bufferId;
}
}
shaderBufferCount = tubesBufferContent.Count;
var bId = -1;
var bOff = 0;
var addOffset = 0;
for (var nId = 0; nId < totalNodeCount; ++nId)
{
var mapping = idToMemMap[nId];
if (mapping.BufferId > bId)
{
bId = mapping.BufferId;
bOff = 0;
addOffset = segmentCount[bId] * segmentElementCount;
}
mapping.Offset += addOffset;
mapping.SegmentOffset = bOff;
idToMemMap[nId] = mapping;
if (!mapping.EndNode)
{
tubesBufferContent[bId].Fill(bOff, 0, (float)mapping.Offset);
bOff += segmentElementCount;
}
}
shaderBuffer = new ShaderBuffer(shaderBufferType, maxBufferSize, bufferUsageHintType);
}
public void BindShaderBuffer(ShaderBuffer buffer, string uniformBlockName)
{
var binding = new ShaderBufferBinding()
{
Buffer = buffer,
BlockName = uniformBlockName,
};
shaderBufferBindings.Add(binding);
rebindShaderBufferBinding(binding);
}
protected override void OnLoad(EventArgs e)
{
GL.ClearColor(Color4.Brown);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Less);
//GL.Enable(EnableCap.CullFace);
//GL.CullFace(CullFaceMode.Back);
vertexBuffer = new VertexBuffer<Vector3>
(
new Vector3(-1f, +1f, +1f),
new Vector3(-1f, -1f, +1f),
new Vector3(+1f, +1f, +1f),
new Vector3(+1f, -1f, +1f),
new Vector3(+1f, -1f, -1f),
new Vector3(+1f, +1f, -1f),
new Vector3(-1f, +1f, -1f),
new Vector3(-1f, -1f, -1f)
);
//indexBuffer = new IndexBuffer
//(
// 0, 1, 3, 2,
// 2, 3, 4, 5,
// 5, 4, 7, 6,
// 6, 7, 1, 0,
// 0, 2, 5, 6,
// 1, 7, 4, 3
//);
indexBuffer = IndexBuffer.CreateQuadCylinder(8, 16);
string shaderPath = projectPath + "TessTriCube";
string shaderPath2 = projectPath + "TessQuadCube";
string shaderPath3 = projectPath + "TessCyl";
shader = new Shader(
new Shader.Desc(ShaderType.VertexShader, shaderPath3 + ".vs"),
new Shader.Desc(ShaderType.TessControlShader, shaderPath2 + ".tc"),
//new Shader.Desc(ShaderType.TessControlShader, shaderPath + ".tc"),
new Shader.Desc(ShaderType.TessEvaluationShader, shaderPath3 + ".te"),
//new Shader.Desc(ShaderType.TessEvaluationShader, shaderPath + ".te"),
new Shader.Desc(ShaderType.FragmentShader, shaderPath + ".ps"));
shader.Bind();
//uniformScale = GL.GetUniformLocation(shaderProgramHandle, "scale");
//uniformMatViewProj = GL.GetUniformLocation(shader.Handle, "viewProjMat");
ubuffer = new ShaderBuffer(ShaderBufferType.UBO, 4, BufferUsageHint.StreamDraw);
ubuffer.BindToIndex(0);
//ubuffer.BindToProgram(shader.Handle, "shader_data");
shader.BindShaderBuffer(ubuffer, "shader_data");
query = new PerfQuery();
projMat = Matrix4.CreatePerspectiveFieldOfView((float)Math.PI * 0.25f, Width / (float)Height, 1f, 5000f);
}
