private void VertexAttribLPointer(uint index, int size, VertexAttribLType type, int stride, IntPtr pointer) { // TODO: GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS. if (size != 1 && size != 2 && size != 3 && size != 4) { SetLastError(ErrorCode.InvalidValue); return; } if (!Enum.IsDefined(typeof(VertexAttribLType), type)) { SetLastError(ErrorCode.InvalidEnum); return; } if (stride < 0) { SetLastError(ErrorCode.InvalidValue); return; } VertexArrayObject vao = this.currentVertexArrayObject; if (vao == null) { SetLastError(ErrorCode.InvalidOperation); return; } GLBuffer buffer = this.currentBufferDict[BindBufferTarget.ArrayBuffer]; // GL_INVALID_OPERATION is generated if zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL. // TODO: why only when "pointer argument is not NULL"? if (buffer == null) { SetLastError(ErrorCode.InvalidOperation); return; } VertexAttribDesc desc = null; if (!vao.LocVertexAttribDict.TryGetValue(index, out desc)) { desc = new VertexAttribDesc(); vao.LocVertexAttribDict.Add(index, desc); } desc.inLocation = index; desc.vbo = buffer; desc.dataSize = size; desc.dataType = (uint)type; //desc.normalize = false; // not needed. desc.startPos = (uint)pointer.ToInt32(); desc.stride = (uint)stride; }
private uint GetVertexCount(VertexArrayObject vao, GLBuffer indexBuffer, DrawElementsType type) { uint vertexCount = 0; VertexAttribDesc[] descs = vao.LocVertexAttribDict.Values.ToArray(); if (descs.Length > 0) { int c = descs[0].GetVertexCount(); if (c >= 0) { vertexCount = (uint)c; } } else { uint maxvertexID = GetMaxVertexID(indexBuffer.Data, type); uint vertexIDCount = GetVertexIDCount(indexBuffer.Data, type); vertexCount = Math.Min(maxvertexID, vertexIDCount); } return(vertexCount); }
private void BufferData(BindBufferTarget target, int size, IntPtr data, Usage usage) { if (!Enum.IsDefined(typeof(BindBufferTarget), target)) { SetLastError(ErrorCode.InvalidEnum); return; } if (!Enum.IsDefined(typeof(Usage), usage)) { SetLastError(ErrorCode.InvalidEnum); return; } if (size < 0) { SetLastError(ErrorCode.InvalidValue); return; } GLBuffer buffer = this.currentBufferDict[target]; if (buffer == null) { SetLastError(ErrorCode.InvalidOperation); return; } // TODO: GL_OUT_OF_MEMORY is generated if the GL is unable to create a data store with the specified size. buffer.SetData(size, data, usage); }
private unsafe List <Fragment> LinearInterpolationLineLoop(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer, PassBuffer[] passBuffers) { var result = new List <Fragment>(); var gl_PositionArray = (vec4 *)passBuffers[0].Mapbuffer().ToPointer(); var pointers = new void *[passBuffers.Length - 1]; for (int i = 0; i < pointers.Length; i++) { pointers[i] = passBuffers[i + 1].Mapbuffer().ToPointer(); } byte[] indexData = indexBuffer.Data; int indexLength = indexData.Length / ByteLength(type); GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned); IntPtr pointer = pin.AddrOfPinnedObject(); var groupList = new List <LinearInterpolationInfoGroup>(); ivec4 viewport = this.viewport; // ivec4(x, y, width, height) for (int indexID = indices.ToInt32() / ByteLength(type), c = 0; c < count && indexID < indexLength; indexID++, c++) { var group = new LinearInterpolationInfoGroup(2); for (int i = 0; i < 2; i++) { uint gl_VertexID = GetVertexID(pointer, type, (indexID + i) % count);//TODO: line-loop vs indices & count. vec4 gl_Position = gl_PositionArray[gl_VertexID]; vec3 fragCoord = new vec3((gl_Position.x + 1) / 2.0f * viewport.z + viewport.x, (gl_Position.y + 1) / 2.0f * viewport.w + viewport.y, (gl_Position.z + 1) / 2.0f * (float)(this.depthRangeFar - this.depthRangeNear) + (float)this.depthRangeNear); group.array[i] = new LinearInterpolationInfo(gl_VertexID, fragCoord); } if (groupList.Contains(group)) { continue; } // discard the same line. else { groupList.Add(group); } vec3 fragCoord0 = group.array[0].fragCoord, fragCoord1 = group.array[1].fragCoord; { vec3 diff = (fragCoord0 - fragCoord1); // discard line that is too small. if (Math.Abs(diff.x) < epsilon && Math.Abs(diff.y) < epsilon && Math.Abs(diff.z) < epsilon ) { continue; } } FindFragmentsInLine(fragCoord0, fragCoord1, pointers, group, passBuffers, result); } for (int i = 0; i < passBuffers.Length; i++) { passBuffers[i].Unmapbuffer(); } return(result); }
private unsafe PassBuffer[] VertexShaderStage(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer) { PassBuffer[] passBuffers = null; VertexShader vs = program.VertexShader; if (vs == null) { return(passBuffers); } // init pass-buffers to record output from vertex shader. FieldInfo[] outFieldInfos = (from item in vs.outVariableDict select item.Value.fieldInfo).ToArray(); uint vertexCount = GetVertexCount(vao, indexBuffer, type); //int vertexSize = GetVertexSize(outFieldInfos); passBuffers = new PassBuffer[1 + outFieldInfos.Length]; void *[] pointers = new void *[1 + outFieldInfos.Length]; { // the first pass-buffer stores gl_Position. var passBuffer = new PassBuffer(PassType.Vec4, (int)vertexCount); pointers[0] = (void *)passBuffer.Mapbuffer(); passBuffers[0] = passBuffer; } for (int i = 1; i < passBuffers.Length; i++) { var outField = outFieldInfos[i - 1]; PassType passType = outField.FieldType.GetPassType(); var passBuffer = new PassBuffer(passType, (int)vertexCount); pointers[i] = (void *)passBuffer.Mapbuffer(); passBuffers[i] = passBuffer; } // execute vertex shader for each vertex. byte[] indexData = indexBuffer.Data; int indexLength = indexData.Length / ByteLength(type); GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned); IntPtr pointer = pin.AddrOfPinnedObject(); var gl_VertexIDList = new List <uint>(); for (int indexID = indices.ToInt32() / ByteLength(type), c = 0; c < count && indexID < indexLength; indexID++, c++) { uint gl_VertexID = GetVertexID(pointer, type, indexID); if (gl_VertexIDList.Contains(gl_VertexID)) { continue; } else { gl_VertexIDList.Add(gl_VertexID); } var instance = vs.CreateCodeInstance() as VertexCodeBase; // an executable vertex shader. instance.gl_VertexID = (int)gl_VertexID; // setup gl_VertexID. // setup "in SomeType varName;" vertex attributes. Dictionary <uint, VertexAttribDesc> locVertexAttribDict = vao.LocVertexAttribDict; foreach (InVariable inVar in vs.inVariableDict.Values) // Dictionary<string, InVariable>.Values { VertexAttribDesc desc = null; if (locVertexAttribDict.TryGetValue(inVar.location, out desc)) { byte[] dataStore = desc.vbo.Data; int byteIndex = desc.GetDataIndex(gl_VertexID); VertexAttribType vertexAttribType = (VertexAttribType)desc.dataType; object value = dataStore.ToStruct(inVar.fieldInfo.FieldType, byteIndex); inVar.fieldInfo.SetValue(instance, value); } } // setup "uniform SomeType varName;" in vertex shader. Dictionary <string, UniformValue> nameUniformDict = program.nameUniformDict; foreach (UniformVariable uniformVar in vs.UniformVariableDict.Values) { string name = uniformVar.fieldInfo.Name; UniformValue obj = null; if (nameUniformDict.TryGetValue(name, out obj)) { if (obj.value != null) { uniformVar.fieldInfo.SetValue(instance, obj.value); } } } instance.main(); // execute vertex shader code. // copy data to pass-buffer. { PassBuffer passBuffer = passBuffers[0]; var array = (vec4 *)pointers[0]; array[gl_VertexID] = instance.gl_Position; } for (int i = 1; i < passBuffers.Length; i++) { var outField = outFieldInfos[i - 1]; var obj = outField.GetValue(instance); switch (outField.FieldType.GetPassType()) { case PassType.Float: { var array = (float *)pointers[i]; array[gl_VertexID] = (float)obj; } break; case PassType.Vec2: { var array = (vec2 *)pointers[i]; array[gl_VertexID] = (vec2)obj; } break; case PassType.Vec3: { var array = (vec3 *)pointers[i]; array[gl_VertexID] = (vec3)obj; } break; case PassType.Vec4: { var array = (vec4 *)pointers[i]; array[gl_VertexID] = (vec4)obj; } break; case PassType.Mat2: { var array = (mat2 *)pointers[i]; array[gl_VertexID] = (mat2)obj; } break; case PassType.Mat3: { var array = (mat3 *)pointers[i]; array[gl_VertexID] = (mat3)obj; } break; case PassType.Mat4: { var array = (mat4 *)pointers[i]; array[gl_VertexID] = (mat4)obj; } break; default: throw new NotImplementedException(); } // a general way to do this: //var obj = outField.GetValue(instance); //byte[] bytes = obj.ToBytes(); //PassBuffer passBuffer = passBuffers[i]; //var array = (byte*)passBuffer.AddrOfPinnedObject(); //for (int t = 0; t < bytes.Length; t++) //{ // array[gl_VertexID * vertexSize + t] = bytes[t]; //} } } pin.Free(); for (int i = 0; i < passBuffers.Length; i++) { passBuffers[i].Unmapbuffer(); } return(passBuffers); }
private unsafe List <Fragment> LinearInterpolationQuads(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer, PassBuffer[] passBuffers) { var result = new List <Fragment>(); var gl_PositionArray = (vec4 *)passBuffers[0].Mapbuffer().ToPointer(); var pointers = new void *[passBuffers.Length - 1]; for (int i = 0; i < pointers.Length; i++) { pointers[i] = passBuffers[i + 1].Mapbuffer().ToPointer(); } byte[] indexData = indexBuffer.Data; int indexLength = indexData.Length / ByteLength(type); GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned); IntPtr pointer = pin.AddrOfPinnedObject(); var groupList = new List <LinearInterpolationInfoGroup>(); ivec4 viewport = this.viewport; // ivec4(x, y, width, height) count = (count - count % 4); for (int indexID = indices.ToInt32() / ByteLength(type), c = 0; c < count - 3 && indexID < indexLength - 3; indexID += 4, c += 4) { var group = new LinearInterpolationInfoGroup(4); for (int i = 0; i < 4; i++) { uint gl_VertexID = GetVertexID(pointer, type, indexID + i); vec4 gl_Position = gl_PositionArray[gl_VertexID]; vec3 fragCoord = new vec3((gl_Position.x + 1) / 2.0f * viewport.z + viewport.x, (gl_Position.y + 1) / 2.0f * viewport.w + viewport.y, (gl_Position.z + 1) / 2.0f * (float)(this.depthRangeFar - this.depthRangeNear) + (float)this.depthRangeNear); group.array[i] = new LinearInterpolationInfo(gl_VertexID, fragCoord); } if (groupList.Contains(group)) { continue; } // discard the same line. else { groupList.Add(group); } vec3 fragCoord0 = group.array[0].fragCoord; vec3 fragCoord1 = group.array[1].fragCoord; vec3 fragCoord2 = group.array[2].fragCoord; vec3 fragCoord3 = group.array[3].fragCoord; FindFragmentsInTriangle(fragCoord0, fragCoord1, fragCoord3, pointers, group, passBuffers, result); FindFragmentsInTriangle(fragCoord1, fragCoord2, fragCoord3, pointers, group, passBuffers, result); } for (int i = 0; i < passBuffers.Length; i++) { passBuffers[i].Unmapbuffer(); } return(result); }
private unsafe List <Fragment> LinearInterpolationPoints(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer, PassBuffer[] passBuffers) { var result = new List <Fragment>(); int attributeCount = passBuffers.Length - 1; var gl_PositionArray = (vec4 *)passBuffers[0].Mapbuffer().ToPointer(); var pointers = new void *[passBuffers.Length - 1]; for (int i = 0; i < pointers.Length; i++) { pointers[i] = passBuffers[i + 1].Mapbuffer().ToPointer(); } byte[] indexData = indexBuffer.Data; int indexLength = indexData.Length / ByteLength(type); GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned); IntPtr pointer = pin.AddrOfPinnedObject(); var gl_VertexIDList = new List <uint>(); ivec4 viewport = this.viewport; for (int indexID = indices.ToInt32() / ByteLength(type), c = 0; c < count && indexID < indexLength; indexID++, c++) { uint gl_VertexID = GetVertexID(pointer, type, indexID); if (gl_VertexIDList.Contains(gl_VertexID)) { continue; } else { gl_VertexIDList.Add(gl_VertexID); } vec3 fragCoord = new vec3((gl_PositionArray[gl_VertexID].x + 1) / 2.0f * viewport.z + viewport.x, (gl_PositionArray[gl_VertexID].y + 1) / 2.0f * viewport.w + viewport.y, (gl_PositionArray[gl_VertexID].z + 1) / 2.0f * (float)(this.depthRangeFar - this.depthRangeNear) + (float)this.depthRangeNear); var fragment = new Fragment(fragCoord, attributeCount); for (int i = 0; i < attributeCount; i++) // new pass-buffer objects. { PassType passType = passBuffers[i].elementType; fragment.attributes[i] = new PassBuffer(passType, 1); // only one element. } for (int attrIndex = 0; attrIndex < attributeCount; attrIndex++) // fill data in pass-buffer. { PassBuffer attribute = fragment.attributes[attrIndex]; void * fragmentAttribute = attribute.Mapbuffer().ToPointer(); switch (attribute.elementType) { case PassType.Float: { var fAttr = (float *)fragmentAttribute; var array = (float *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Vec2: { var fAttr = (vec2 *)fragmentAttribute; var array = (vec2 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Vec3: { var fAttr = (vec3 *)fragmentAttribute; var array = (vec3 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Vec4: { var fAttr = (vec4 *)fragmentAttribute; var array = (vec4 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Mat2: { var fAttr = (mat2 *)fragmentAttribute; var array = (mat2 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Mat3: { var fAttr = (mat3 *)fragmentAttribute; var array = (mat3 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; case PassType.Mat4: { var fAttr = (mat4 *)fragmentAttribute; var array = (mat4 *)pointers[attrIndex]; fAttr[0] = array[gl_VertexID]; } break; default: throw new NotDealWithNewEnumItemException(typeof(PassType)); } attribute.Unmapbuffer(); } result.Add(fragment); } for (int i = 0; i < passBuffers.Length; i++) { passBuffers[i].Unmapbuffer(); } return(result); }
private List <Fragment> LinearInterpolationPatches(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer, PassBuffer[] passBuffers) { var result = new List <Fragment>(); FragmentShader fs = program.FragmentShader; if (fs == null) { return(result); } return(result); }
private List <Fragment> LinearInterpolation(DrawTarget mode, int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer, PassBuffer[] passBuffers) { List <Fragment> result = null; switch (mode) { case DrawTarget.Points: result = LinearInterpolationPoints(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.Lines: result = LinearInterpolationLines(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.LineLoop: result = LinearInterpolationLineLoop(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.LineStrip: result = LinearInterpolationLineStrip(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.Triangles: result = LinearInterpolationTriangles(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.TriangleStrip: result = LinearInterpolationTriangleStrip(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.TriangleFan: result = LinearInterpolationTriangleFan(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.Quads: result = LinearInterpolationQuads(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.QuadStrip: result = LinearInterpolationQuadStrip(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.Polygon: result = LinearInterpolationPolygon(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.LinesAdjacency: result = LinearInterpolationLinesAdjacency(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.LineStripAdjacency: result = LinearInterpolationLineStripAdjacency(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.TrianglesAdjacency: result = LinearInterpolationTrianglesAdjacency(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.TriangleStripAdjacency: result = LinearInterpolationTriangleStripAdjacency(count, type, indices, vao, program, indexBuffer, passBuffers); break; case DrawTarget.Patches: result = LinearInterpolationPatches(count, type, indices, vao, program, indexBuffer, passBuffers); break; default: throw new NotDealWithNewEnumItemException(typeof(DrawTarget)); } return(result); }
private void DrawElements(DrawTarget mode, int count, DrawElementsType type, IntPtr indices) { if (!Enum.IsDefined(typeof(DrawTarget), mode) || !Enum.IsDefined(typeof(DrawElementsType), type)) { SetLastError(ErrorCode.InvalidEnum); return; } if (count < 0) { SetLastError(ErrorCode.InvalidValue); return; } // TODO: GL_INVALID_OPERATION is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object. // TODO: GL_INVALID_OPERATION is generated if a non-zero buffer object name is bound to an enabled array or the element array and the buffer object's data store is currently mapped. VertexArrayObject vao = this.currentVertexArrayObject; // data structure. if (vao == null) { return; } ShaderProgram program = this.currentShaderProgram; // algorithm. if (program == null) { return; } GLBuffer indexBuffer = this.currentBufferDict[BindBufferTarget.ElementArrayBuffer]; if (indexBuffer == null) { return; } // execute vertex shader for each vertex! // This is a low effetient implementation. // passBuffers is input for the next stage: linear interpolation. // passBuffers[0] is gl_Position. // passBuffers[others] are attributes of vertexes. PassBuffer[] passBuffers = VertexShaderStage(count, type, indices, vao, program, indexBuffer); if (passBuffers == null) { return; } // this stage failed. Framebuffer framebuffer = this.currentFramebuffer; if (framebuffer == null) { throw new Exception("This should not happen!"); } ClipSpace2NormalDeviceSpace(passBuffers[0]); // linear interpolation. List <Fragment> fragmentList = LinearInterpolation(mode, count, type, indices, vao, program, indexBuffer, passBuffers); // execute fargment shader for each fragment! // This is a low effetient implementation. FragmentShaderStage(program, fragmentList); { int index = 0; while (index < fragmentList.Count) { if (fragmentList[index].discard) { fragmentList.RemoveAt(index); } else { index++; } } } // Scissor test // Multisampel fragment operations // Stencil test // Depth test DepthTest(fragmentList); //Blending // Dithering // Logical operations // write fragments to framebuffer's colorbuffer attachment(s). { uint[] drawBufferIndexes = framebuffer.DrawBuffers.ToArray(); foreach (var fragment in fragmentList) { if (fragment.depthTestFailed) { continue; } for (int i = 0; i < fragment.outVariables.Length && i < drawBufferIndexes.Length; i++) { PassBuffer outVar = fragment.outVariables[i]; IAttachable attachment = framebuffer.ColorbufferAttachments[drawBufferIndexes[i].ToIndex()]; attachment.Set((int)fragment.gl_FragCoord.x, (int)fragment.gl_FragCoord.y, outVar); } } } }