internal GLBuffer(int bufferHandle, BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, int size)
{
Handle = bufferHandle;
Target = bufferTarget;
UsageHint = bufferUsageHint;
Size = size;
}
public void SetData(TriangleBuffer triangles, BufferUsageHint usageHint)
{
_indexCount = triangles.IndexCount;
if (_indexCount % 3 != 0) throw new IndexOutOfRangeException("Number of index entries must be divisible by 3.");
if (_indexCount == 0)
{
Dispose();
return;
}
if (_vertexArray == 0)
{
_vertexArray = GL.GenVertexArray();
_elementArrayBuffer = GL.GenBuffer();
_arrayBuffer = GL.GenBuffer();
GL.BindVertexArray(_vertexArray);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _elementArrayBuffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, _arrayBuffer);
_specification.Bind();
}
else
{
GL.BindBuffer(BufferTarget.ElementArrayBuffer, _elementArrayBuffer);
GL.BindBuffer(BufferTarget.ArrayBuffer, _arrayBuffer);
}
triangles.UploadData(usageHint);
}
public VertexBuffer(IGraphicsContext context, BufferUsageHint hint)
{
this.GraphicsContext = context;
this.hint = hint;
this.GraphicsContext.GenBuffers(1, out Handle);
}
public static IBuffer Buffer(this IContextObjectFactory factory, BufferTarget creationTarget, int sizeInBytes, BufferUsageHint usageHint, Array initialData)
{
var handle = GCHandle.Alloc(initialData, GCHandleType.Pinned);
var result = factory.Buffer(creationTarget, sizeInBytes, usageHint, handle.AddrOfPinnedObject());
handle.Free();
return result;
}
public static int CreateBuffer(ushort[] data, BufferTarget target = BufferTarget.ArrayBuffer, BufferUsageHint hint = BufferUsageHint.StaticDraw)
{
var buffer = GenBuffer(target);
var size = data.Length * sizeof(ushort);
GL.BufferData(target, new IntPtr(size), data, hint);
return buffer;
}
public static int CreateBuffer(Vertex[] data, BufferTarget target = BufferTarget.ArrayBuffer, BufferUsageHint hint = BufferUsageHint.StaticDraw)
{
var buffer = GenBuffer(target);
var size = data.Length * Vertex.SizeInBytes;
GL.BufferData(target, new IntPtr(size), data, hint);
return buffer;
}
public VertexBufferObject(VertexBufferType type, VertexBufferUsageHint hint)
{
GL.GenBuffers(1, out buffer_id);
buffer_target = (BufferTarget)type;
buffer_hint = (BufferUsageHint)hint;
}
public static GLBuffer Allocate(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, byte[] data)
{
int handle = GL.GenBuffer();
GL.BindBuffer(bufferTarget, handle);
GL.BufferData(bufferTarget, (IntPtr)data.Length, data, bufferUsageHint);
GL.BindBuffer(bufferTarget, 0);
return new GLBuffer(handle, bufferTarget, bufferUsageHint, data.Length);
}
public static GLBuffer Allocate(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, int size)
{
int handle = GL.GenBuffer();
GL.BindBuffer(bufferTarget, handle);
GL.BufferData(bufferTarget, (IntPtr)size, IntPtr.Zero, bufferUsageHint);
GL.BindBuffer(bufferTarget, 0);
return new GLBuffer(handle, bufferTarget, bufferUsageHint, size);
}
/// <summary>
/// Initializes a new instance of the <see cref="VBO"/> class.
/// </summary>
/// <param name="bufferTarget">Logical type of data in VBO</param>
/// <param name="bufferUsageHint">The buffer usage hint.</param>
/// <param name="size">The size.</param>
internal VBO(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint = BufferUsageHint.DynamicDraw, int size = 0)
{
GL.GenBuffers(1, out _vbo);
_bufferTarget = bufferTarget;
GL.BindBuffer(_bufferTarget, _vbo);
GL.BufferData(_bufferTarget, new IntPtr(size), new IntPtr(0), bufferUsageHint);
GL.BindBuffer(_bufferTarget, 0);
_currentSize = size;
_bufferUsageHint = bufferUsageHint;
}
public void SetData(ref byte[] data, BufferUsageHint usageHint)
{
if (Disposed)
throw new ObjectDisposedException(ToString());
UsageHint = usageHint;
GL.BindBuffer(Target, Handle);
GL.BufferData(Target, (IntPtr)data.Length, data, UsageHint);
GL.BindBuffer(Target, 0);
}
/// <summary>
/// Copies the given data into a buffer object on the GPU.
/// </summary>
/// <typeparam name="DataType">The value data type of each array element</typeparam>
/// <param name="data">The data array</param>
/// <param name="usageHint">How will this buffer object be used</param>
public void Set <DataType>(DataType[] data, BufferUsageHint usageHint = BufferUsageHint.StaticDraw) where DataType : struct
{
if (0 == data.Length)
{
throw new ArgumentException("Empty array");
}
var elementSize = Marshal.SizeOf(data[0]);
var byteSize = elementSize * data.Length;
GL.NamedBufferData(Handle, byteSize, data, usageHint); //copy data over to GPU
}
public Buffer(BufferTarget type, int size, IntPtr data, BufferUsageHint usageHint)
{
BufferType = type;
BufferSize = size;
BufferHint = usageHint;
this.data = data;
BufferId = GL.GenBuffer();
GL.BindBuffer(type, BufferId);
GL.BufferData(type, (int)size, data, usageHint);
}
public void BufferData <T>(
BufferTarget target,
T[] data,
int totalSizeInBytes,
BufferUsageHint usageHint = BufferUsageHint.DynamicDraw)
where T : struct
{
GL.BindBuffer(target, Handle);
GL.BufferData <T>(target, new IntPtr(totalSizeInBytes), data, usageHint);
GL.BindBuffer(target, 0);
}
public GLBuffer(BufferTarget target, T[] array, int stride, BufferUsageHint usageHint)
{
Array = array;
ID = GL.GenBuffer();
Target = target;
UsageHint = usageHint;
Stride = stride;
GL.BindBuffer(Target, ID);
GL.BufferData(Target, Length * Stride, Array, UsageHint);
}
public VertexBufferObject(T[] vertexData, int vectorLength, BufferTarget bufferTarget, BufferUsageHint bufferUsageHint)
{
Handle = GL.GenBuffer();
this.VertexData = vertexData;
this.vectorLength = vectorLength;
this.bufferUsageHint = bufferUsageHint;
this.bufferTarget = bufferTarget;
BindBuffer();
BufferData();
}
public void BufferData <T>([NotNull] T[] data, BufferUsageHint usage)
where T : struct
{
EnsureNotDisposed();
var dataSize = Marshal.SizeOf(typeof(T)) * data.Length;
Activate();
GL.BufferData(BufferTarget.ArrayBuffer, dataSize, data, usage);
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
public VertexBufferObjectWithVAO(bool isStatic, int numVerticies, VertexAttributes attributes)
{
this.isStatic = isStatic;
this.attributes = attributes;
this.vertices = new float[numVerticies];
bufferHandle = GL.GenBuffer();
usage = isStatic ? BufferUsageHint.StaticDraw : BufferUsageHint.DynamicDraw;
createVAO();
}
public override void CreateOrUpdateMesh(BufferUsageHint bufferUsage)
{
if (Mesh == null)
{
Mesh = new VoxelMesh(bufferUsage, backMeshBuilder);
}
else
{
Mesh.Update(backMeshBuilder);
}
}
/// <summary>
/// Sets the specified data.
/// </summary>
/// <typeparam name="DATA_ELEMENT_TYPE">The type of the ata element type.</typeparam>
/// <param name="data">The data.</param>
/// <param name="usageHint">The usage hint.</param>
public void Set <DATA_ELEMENT_TYPE>(DATA_ELEMENT_TYPE[] data, BufferUsageHint usageHint) where DATA_ELEMENT_TYPE : struct
{
Activate();
int elementBytes = Marshal.SizeOf(typeof(DATA_ELEMENT_TYPE));
int bufferByteSize = data.Length * elementBytes;
// set buffer data
GL.BufferData(BufferTarget, bufferByteSize, data, usageHint);
//cleanup state
Deactivate();
}
public void Set <TDataElement>(TDataElement[] data, BufferUsageHint usageHint) where TDataElement : struct
{
Activate();
int elementBytes = Marshal.SizeOf(typeof(TDataElement));
int bufferByteSize = data.Length * elementBytes;
// set buffer data
GL.BufferData(BufferTarget, (IntPtr)bufferByteSize, data, usageHint);
//cleanup state
Deactive();
}
private void Initialize()
{
GLTarget = GetGLBufferTarget(BufferType);
GLUsage = Dynamic ? BufferUsageHint.DynamicDraw : BufferUsageHint.StaticDraw;
GLBuffer = GL.GenBuffer();
GLHelper.CheckGLErrors();
GL.BindBuffer(GLTarget, GLBuffer);
GLHelper.CheckGLErrors();
GL.BufferData(GLTarget, Size, IntPtr.Zero, GLUsage);
GLHelper.CheckGLErrors();
Context.InvalidateBufferBinding(BufferType);
}
public VertexBufferObject(EnableCap arrayType,
BufferTarget target,
BufferUsageHint usage,
VertexPointerInfo pointer)
{
Buffer = new List <T>();
this.ArrayType = arrayType;
this.BufferTarget = target;
this.Pointer = pointer;
this.Usage = usage;
}
/// <summary>
/// Reserve a number of bytes in GPU memory for this vertex buffer.
/// </summary>
/// <remarks>
/// This is useful for advanced features like transform feedback.
/// </remarks>
/// <param name="vertexCount">The amount of vertices reserved.</param>
/// <param name="target">The target.</param>
/// <param name="usageHint">The usage hin.t</param>
/// <param name="setVertexCount">Whether to set the given vertex count as size of this vertex buffer.</param>
public void BufferNoData(
int vertexCount,
BufferTarget target = BufferTarget.ArrayBuffer,
BufferUsageHint usageHint = BufferUsageHint.StreamDraw,
bool setVertexCount = false)
{
GL.BufferData(target, (IntPtr)(VertexSize * vertexCount), IntPtr.Zero, usageHint);
if (setVertexCount)
{
Count = (ushort)vertexCount;
}
}
public VertexBuffer(float[] data, BufferUsageHint usage, VertexBufferLayout layout)
{
Layout = layout ?? throw new ArgumentNullException(nameof(layout));
Id = GL.GenBuffer();
Logger.Trace("Generated buffer: {0}", Id);
Bind();
GL.BufferData(BufferTarget.ArrayBuffer, data.Length * sizeof(float), data, usage);
Logger.Trace("Set buffer data: {1} bytes ({0})", usage, data.Length * sizeof(float));
Unbind();
}
///<summary>Allocate or reallocate buffer size. Call first to set buffer size. Allow for alignment in your size</summary>
public void AllocateBytes(int bytessize, BufferUsageHint hint = BufferUsageHint.StaticDraw)
{
System.Diagnostics.Debug.Assert(context == GLStatics.GetContext(), "Context incorrect"); // safety
if (bytessize > 0) // can call twice - get fresh buffer each time
{
Length = bytessize;
GL.NamedBufferData(Id, Length, (IntPtr)0, hint); // set buffer size
var err = GL.GetError();
System.Diagnostics.Debug.Assert(err == ErrorCode.NoError, $"GL NamedBuffer error {err}"); // check for any errors, always.
ResetPositions();
}
}
public unsafe void Init(TDataType[] data, int elementCount, BufferTarget bufferType,
BufferUsageHint bufferUsage)
{
BufferType = bufferType;
Handle = GL.GenBuffer();
ElementCount = elementCount;
int fullSize = ElementCount * sizeof(TDataType);
Bind();
GL.BufferData(bufferType, (IntPtr)fullSize, data, bufferUsage);
CheckBufferSize(bufferType, fullSize);
}
private void GeneratePixelBufferObject(BufferTarget target, BufferUsageHint bufferUsage)
{
GL.GenBuffers(1, out pixelBufferObjectId);
GL.BindBuffer(target, pixelBufferObjectId);
if (RowPitch < 4)
{
GL.PixelStore(PixelStoreParameter.PackAlignment, 1);
}
GL.BufferData(target, (IntPtr)DepthPitch, IntPtr.Zero, bufferUsage);
GL.BindBuffer(target, 0);
}
//internal void GenerateBuffer<T>() where T : struct, IVertexType
internal void GenerateBuffer <T> () where T : struct
{
var vd = VertexDeclaration.FromType(_type);
_size = vd.VertexStride * ((T[])_buffer).Length;
BufferUsageHint bufferUsage = (_bufferUsage == BufferUsage.WriteOnly) ? BufferUsageHint.StaticDraw : BufferUsageHint.DynamicDraw;
GL.GenBuffers(1, out _bufferStore);
GL.BindBuffer(BufferTarget.ArrayBuffer, _bufferStore);
GL.BufferData <T> (BufferTarget.ArrayBuffer, (IntPtr)_size, (T[])_buffer, bufferUsage);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="VertexData">An array containing the actual vertex coordinates and texture coordinates as X, Y, Z, U, V</param>
/// <param name="DrawType">The hint representing how the object is to be used and therefore guides OpenGL's optimization of the object</param>
public VertexBufferObject(LibRenderVertex[] VertexData, BufferUsageHint DrawType)
{
GL.GenBuffers(1, out handle);
vertexData = VertexData;
drawType = DrawType;
/*
* Getting the size of the vertex type using marshal is slow, so cache it here
* This allows us to meddle with the vertex contents without having to remember to update a const
*/
vertexSize = LibRenderVertex.SizeInBytes;
}
public void BuildMeshFromGeometry(
BufferUsageHint bufferUsageHint,
NormalStyle normalStyle
)
{
var attributePosition = new Attribute(VertexUsage.Position, VertexAttribPointerType.Float, 0, 3);
var attributeNormal = new Attribute(VertexUsage.Normal, VertexAttribPointerType.Float, 0, 3); /* content normals */
var attributeNormalFlat = new Attribute(VertexUsage.Normal, VertexAttribPointerType.Float, 1, 3); /* flat normals */
var attributeNormalSmooth = new Attribute(VertexUsage.Normal, VertexAttribPointerType.Float, 2, 3); /* smooth normals */
var attributeColor = new Attribute(VertexUsage.Color, VertexAttribPointerType.Float, 0, 4);
var attributeIdVec3 = new Attribute(VertexUsage.Id, VertexAttribPointerType.Float, 0, 3);
var attributeIdUInt = (RenderStack.Graphics.Configuration.useIntegerPolygonIDs)
? new Attribute(VertexUsage.Id, VertexAttribPointerType.UnsignedInt, 0, 1)
: null;
VertexFormat vertexFormat = new VertexFormat();
vertexFormat.Add(attributePosition);
vertexFormat.Add(attributeNormal);
vertexFormat.Add(attributeNormalFlat);
vertexFormat.Add(attributeNormalSmooth);
Dictionary <Corner, Vector2> cornerTexcoords = null;
Dictionary <Point, Vector2> pointTexcoords = null;
if (Geometry.CornerAttributes.Contains <Vector2>("corner_texcoords"))
{
cornerTexcoords = Geometry.CornerAttributes.Find <Vector2>("corner_texcoords");
}
if (Geometry.PointAttributes.Contains <Vector2>("point_texcoords"))
{
pointTexcoords = Geometry.PointAttributes.Find <Vector2>("point_texcoords");
}
if (cornerTexcoords != null || pointTexcoords != null)
{
var attributeTexcoord = new Attribute(VertexUsage.TexCoord, VertexAttribPointerType.Float, 0, 2);
vertexFormat.Add(attributeTexcoord);
}
// \todo When do we want color attribute and when we don't?
//if(cornerColors != null || pointColors != null)
//{
vertexFormat.Add(attributeColor);
//}
vertexFormat.Add(attributeIdVec3);
if (RenderStack.Graphics.Configuration.useIntegerPolygonIDs)
{
vertexFormat.Add(attributeIdUInt);
}
BuildMeshFromGeometry(bufferUsageHint, normalStyle, vertexFormat);
}
public VertexBuffer(T[] data, Action prep, BufferUsageHint bufferUsageHint = BufferUsageHint.DynamicDraw)
{
if (data == null)
{
return;
}
GL.GenBuffers(1, out _id);
GL.BindBuffer(BufferTarget.ArrayBuffer, _id);
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(data.Length * BlittableValueType.StrideOf(data)), data, bufferUsageHint);
Length = data.Length;
_prep = prep;
}
/// <summary>
/// Sets the data for this VBO. This will take effect once the resource is first
/// loaded into GPU memory, or (if it's already loaded) upon the next RenderContext
/// resource cycle.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="bufferUsageHint"></param>
public void SetData <T>(T[] data, BufferUsageHint bufferUsageHint) where T : struct
{
// Must be captured in a closure because it's a generic type.
_bufferAction = () =>
{
Bind();
GL.BufferData(_target, (IntPtr)(Marshal.SizeOf(typeof(T)) * data.Length), data, bufferUsageHint);
};
if (GLHandle != -1)
{
RenderContext.Active.AddResourceLoadAction(_bufferAction);
}
}
public void BufferData <T>(T data, BufferUsageHint usage)
where T : struct
{
EnsureNotDisposed();
var dataSize = Marshal.SizeOf(typeof(T));
Activate();
GL.BufferData(BufferTarget.ElementArrayBuffer, dataSize, ref data, usage);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
_itemCount = 1;
}
public void SetData <T>(T[] data, int size, BufferUsageHint hint = BufferUsageHint.StaticDraw)
where T : struct, IComparable
{
if (!_built)
{
BuildLayout();
}
GL.BindBuffer(BufferTarget.ArrayBuffer, _vbo);
GL.BufferData(BufferTarget.ArrayBuffer, size, data, hint);
_vtxCount = size / GetStride();
}
public void BufferSubData <T>(
BufferTarget target,
T[] data,
int totalSizeInBytes,
IntPtr offset,
BufferUsageHint usageHint = BufferUsageHint.DynamicDraw
)
where T : struct
{
GL.BindBuffer(target, Handle);
GL.BufferSubData <T>(target, offset, totalSizeInBytes, data);
GL.BindBuffer(target, 0);
}
public unsafe GLBuffer(BufferTarget target, T[] array, BufferUsageHint usageHint)
{
Array = array;
Id = GL.GenBuffer();
Target = target;
UsageHint = usageHint;
Stride = sizeof(T);
GL.BindBuffer(Target, Id);
GL.BufferData(Target, Length * Stride, Array, UsageHint);
GC.AddMemoryPressure(Stride * Array.Length);
}
private BufferStorageFlags BufferUsageToStorageFlags(BufferUsageHint hint)
{
switch (hint)
{
case BufferUsageHint.StaticCopy:
case BufferUsageHint.StaticRead:
case BufferUsageHint.StaticDraw:
return(BufferStorageFlags.None);
default:
return(BufferStorageFlags.DynamicStorageBit);
}
}
public static IBuffer Create(DrawElementsType indexType, BufferUsageHint usageHint)
{
#if false
if (Configuration.useOpenRL)
{
return(new BufferGLRL(indexType, usageHint));
}
else
#endif
{
return(new BufferGL(indexType, usageHint));
}
}
public PersistentBufferObject(BufferUsageHint hint, UInt32 size)
: base(BufferTarget.ArrayBuffer, hint)
{
mySize = size;
bind();
BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit;
GL.BufferStorage(BufferTarget.ArrayBuffer, new IntPtr(size), IntPtr.Zero, flags);
BufferAccessMask flags2 = BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit | BufferAccessMask.MapCoherentBit;
myPtr = GL.MapBufferRange(BufferTarget.ArrayBuffer, IntPtr.Zero, new IntPtr(size), flags2);
unbind();
}
public static IBuffer Create(VertexFormat vertexFormat, BufferUsageHint usageHint)
{
#if false
if (Configuration.useOpenRL)
{
return(new BufferGLRL(vertexFormat, usageHint));
}
else
#endif
{
return(new BufferGL(vertexFormat, usageHint));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VAO"/> class.
/// </summary>
/// <param name="bufferTargets">The VBO data types.</param>
/// <param name="VBObufferUsageHint">The VBO buffer usage hint.</param>
/// <param name="VBOsize">The VBO size.</param>
public VAO(BufferTarget[] bufferTargets = null, BufferUsageHint VBObufferUsageHint = BufferUsageHint.DynamicDraw,
int VBOsize = 0)
{
GL.GenVertexArrays(1, out _vao);
GL.BindVertexArray(_vao);
if(bufferTargets != null)
{
foreach(var buffer in bufferTargets.Where(x => !VBOobjects.ContainsKey(x)))
{
VBOobjects.Add(buffer, new VBO(buffer, VBObufferUsageHint, VBOsize));
}
}
GL.BindVertexArray(0);
}
public Buffer(IContext context, BufferTarget target, int sizeInBytes, BufferUsageHint usage, IntPtr initialData)
{
this.context = context;
this.target = target;
this.sizeInBytes = sizeInBytes;
this.usage = usage;
uint handleProxy;
GL.GenBuffers(1, &handleProxy);
handle = handleProxy;
context.Bindings.Buffers.ByTarget(target).Set(this);
GL.BufferData((int)target, (IntPtr)sizeInBytes, initialData, (int)usage);
}
public SentanceBlockStorageBuffer(SentanceBlock[] blocks, BufferUsageHint hint)
{
// Buffer for the linked list.
BufferId = GL.GenBuffer();
// manually set
const int BUFFER_INDEX = 0;
Index = BUFFER_INDEX;
GL.BindBuffer(BufferTarget.ShaderStorageBuffer, BufferId);
GL.BindBufferBase(BufferRangeTarget.ShaderStorageBuffer, Index, BufferId);
var structSize = Marshal.SizeOf (typeof(SentanceBlock));
var bufferSize = (IntPtr) (blocks.Length * structSize);
GL.BufferData<SentanceBlock>(BufferTarget.ShaderStorageBuffer, bufferSize, blocks, hint);
GL.BindBuffer(BufferTarget.ShaderStorageBuffer, 0);
}
public void UploadData(List<Vertex> vertices, BufferUsageHint usageHint)
{
this.size = vertices.Count;
VBOVertex[] data = new VBOVertex[vertices.Count];
for (int i = 0; i < vertices.Count; ++i)
{
if (vertices[i].Location != null)
{
data[i].x = vertices[i].Location.X;
data[i].y = vertices[i].Location.Y;
data[i].z = vertices[i].Location.Z;
}
if (vertices[i].Normal != null)
{
data[i].nx = vertices[i].Normal.X;
data[i].ny = vertices[i].Normal.Y;
data[i].nz = vertices[i].Normal.Z;
}
if (vertices[i].TexCoord != null)
{
data[i].s0 = vertices[i].TexCoord.S;
data[i].t0 = vertices[i].TexCoord.T;
}
}
Activate();
{
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(data.Length * VBOVertex.Stride),
data, usageHint);
GL.VertexPointer(3, VertexPointerType.Float, VBOVertex.Stride, 0);
GL.NormalPointer(NormalPointerType.Float, VBOVertex.Stride, sizeof(float) * 3);
GL.TexCoordPointer(2, TexCoordPointerType.Float, VBOVertex.Stride, sizeof(float) * 3);
}
Deactivate();
}
public SplineTubesTess(string shaderPath, TessTubeShadingStyle shadingStyle, TessTubeRenderSetting renderSettings, BufferUsageHint bufferUsageHintType, int bufferMaxElementCount, int[] nodeCount, int vertexRingCount, int vertexRingVertexCount)
: base(renderSettings.HasFlag(TessTubeRenderSetting.ShaderBufferTypeIsSSBO) ? ShaderBufferType.SSBO : ShaderBufferType.UBO, bufferUsageHintType, bufferMaxElementCount, nodeCount, 1 + vertexRingCount / 2)
{
this.shadingStyle = shadingStyle;
this.renderSettings = renderSettings;
this.vertexRingVertexCount = vertexRingVertexCount;
this.vertexRingCount = vertexRingCount;
this.maxLayerId = vertexRingCount - 1;
if (shadingStyle == TessTubeShadingStyle.HardNormalWF || shadingStyle == TessTubeShadingStyle.BlueWF)
renderSettings |= TessTubeRenderSetting.UseGeoShader;
if (renderSettings.HasFlag(TessTubeRenderSetting.UseCaps))
cylIB = IndexBuffer.CreateClosedQuadCylinder(vertexRingVertexCount, vertexRingCount);
else
cylIB = IndexBuffer.CreateQuadCylinder(vertexRingVertexCount, vertexRingCount);
var definesStr = shadingStyle.ToDefineString() + renderSettings.ToDefineString();
definesStr += "#define TUBES_BUFFER_SIZE " + this.shaderBuffer.Float4BlockCount.ToString();
definesStr += Environment.NewLine;
definesStr += "#define VRING_VERTEX_COUNT " + vertexRingVertexCount.ToString();
definesStr += Environment.NewLine;
definesStr += "#define VRING_COUNT " + vertexRingCount.ToString();
definesStr += Environment.NewLine;
if (renderSettings.HasFlag(TessTubeRenderSetting.UseGeoShader))
{
shader = new Shader(
"#version 440",
definesStr,
shaderPath + ".defs",
new Shader.Desc(ShaderType.VertexShader, shaderPath + ".vs"),
new Shader.Desc(ShaderType.TessControlShader, shaderPath + ".tc"),
new Shader.Desc(ShaderType.TessEvaluationShader, shaderPath + ".te"),
new Shader.Desc(ShaderType.GeometryShader, shaderPath + ".gs"),
new Shader.Desc(ShaderType.FragmentShader, shaderPath + ".fs"));
}
else
{
shader = new Shader(
"#version 440",
definesStr,
shaderPath + ".defs",
new Shader.Desc(ShaderType.VertexShader, shaderPath + ".vs"),
new Shader.Desc(ShaderType.TessControlShader, shaderPath + ".tc"),
new Shader.Desc(ShaderType.TessEvaluationShader, shaderPath + ".te"),
new Shader.Desc(ShaderType.FragmentShader, shaderPath + ".fs"));
}
}
public void SetDataUint( BufferTarget Target, BufferUsageHint Hint, uint[] Data )
{
GL.BindBuffer( Target, ID );
GL.BufferData( Target, (IntPtr)( Data.Length * sizeof( uint ) ), Data, Hint );
Length = Data.Length;
}
public void BufferData(BufferTarget target, BufferUsageHint usage, Vector3[] vertices)
{
Bind(target);
GL.BufferData<Vector3>(target, new IntPtr(vertices.Length * Vector3.SizeInBytes), vertices, usage);
}
public void UploadData(BufferUsageHint usageHint)
{
GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)_indices.ByteCount, _indices.Ptr, usageHint);
GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)_vertices.ByteCount, _vertices.Ptr, usageHint);
}
public static void BufferData(BufferTarget target, int size, IntPtr data, BufferUsageHint usage)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
if(glHasBufferObjects)
{
OpenTK.Graphics.OpenGL.GL.BufferData((OpenTK.Graphics.OpenGL.BufferTarget)target, (IntPtr)size, data, (OpenTK.Graphics.OpenGL.BufferUsageHint)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte*)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if(currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if(currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
}
#else
if (glHasBufferObjects)
{
OpenTK.Graphics.ES11.GL.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, data, (OpenTK.Graphics.ES11.All)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte*)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if (currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if (currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
#endif
}
public SplineTubesRaycast(string shaderPath, RaycastTubeShadingStyle shadingStyle, RaycastTubeRenderSetting renderSettings, BufferUsageHint bufferUsageHintType, int bufferMaxElementCount, int[] nodeCount)
: base(renderSettings.HasFlag(RaycastTubeRenderSetting.ShaderBufferTypeIsSSBO) ? ShaderBufferType.SSBO : ShaderBufferType.UBO, bufferUsageHintType, bufferMaxElementCount, nodeCount, 1)
{
this.shadingStyle = shadingStyle;
this.renderSettings = renderSettings;
cube = new Mesh<Vector3>(
new[]
{
new VertexAttribute()
{
Index = 0,
Size = 3,
Type = VertexAttribPointerType.Float,
Normalized = false,
Stride = Vector3.SizeInBytes,
Offset = 0,
}
},
new[]
{
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)
},
new uint[]
{
0, 1, 2,
2, 1, 3,
3, 4, 2,
2, 4, 5,
5, 4, 6,
6, 4, 7,
7, 1, 0,
0, 6, 7,
7, 4, 3,
3, 1, 7,
6, 0, 2,
2, 5, 6,
});
if (renderSettings.HasFlag(RaycastTubeRenderSetting.SplitIn4Segments))
qSegmentCount = 4;
else
qSegmentCount = 2;
var definesStr = shadingStyle.ToDefineString() + renderSettings.ToDefineString();
definesStr += "#define TUBES_BUFFER_SIZE " + this.shaderBuffer.Float4BlockCount.ToString();
definesStr += Environment.NewLine;
shader = new Shader(
"#version 440",
definesStr,
shaderPath + ".defs",
new Shader.Desc(ShaderType.VertexShader, shaderPath + ".vs"),
new Shader.Desc(ShaderType.FragmentShader, shaderPath + ".fs"));
}
//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);
}
/// <summary>
/// Generates a buffer object from the specified parameters, which can be accessed trough this object.
/// </summary>
/// <param name="data">The data to be stored in the VBO</param>
/// <param name="dataSize">The amount of vertices each data block contains</param>
/// <param name="bufferTarget">Specifies the buffer type</param>
/// <param name="bufferUsageHint">Specifies how the buffer should be used</param>
/// <param name="genAO">Should an Array Object be generated for this Buffer Object?</param>
public void Generate(float[] data, int dataSize, BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, bool genAO)
{
this.BufferTarget = bufferTarget;
// Set up some additional local variables:
int i = 0;
while (UsedIds[i]) {
i++;
}
UsedIds[i] = true;
// The vertex attribute Id
vertexAttribId = i;
// The amount of buffer objects that should be generated
int amount = 1;
int var;
if (genAO) {
GL.GenVertexArrays(amount, out var);
arrayObjectId = var;
GL.BindVertexArray(arrayObjectId);
}
GL.GenBuffers(amount, out var);
bufferObjectId = var;
GL.BindBuffer(bufferTarget, bufferObjectId);
GL.BufferData(bufferTarget, (IntPtr)(data.Length * FloatSize), data, bufferUsageHint);
GL.VertexAttribPointer(vertexAttribId, dataSize, VertexAttribPointerType.Float, false, 0, 0);
GL.EnableVertexAttribArray(vertexAttribId);
}
/// <summary>
/// Uploads the index buffer to the GPU.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="usageHint">The usage hint.</param>
public void BufferData(BufferTarget target = BufferTarget.ElementArrayBuffer, BufferUsageHint usageHint = BufferUsageHint.StreamDraw)
{
GL.BufferData(target, (IntPtr)(sizeof(ushort) * this.count), this.indices, usageHint);
}
public SSIndexBuffer(ISSVertexBuffer vbo, BufferUsageHint hint = BufferUsageHint.DynamicDraw)
{
m_vbo = vbo;
m_usageHint = hint;
}
public SSIndexBuffer(UInt16[] indices, ISSVertexBuffer vbo, BufferUsageHint hint = BufferUsageHint.StaticDraw)
: this(vbo, hint)
{
UpdateBufferData(indices);
}
public IBuffer Buffer(BufferTarget creationTarget, int sizeInBytes, BufferUsageHint usage, IntPtr initialData = default(IntPtr))
{
return new Buffer(context, creationTarget, sizeInBytes, usage, initialData);
}
//Methods
//-Public
public static int AddVBO(uint size, BufferUsageHint buh = BufferUsageHint.StaticDraw)
{
int itemp;
VBODataInfo vbodinfo;
GL.GenBuffers(1, out itemp);
#if DEBUG
Misc.GLError("(VBOHandler - GenBuffer)");
#endif
vbodinfo = new VBODataInfo(itemp, size);
vBOs_DicIVdi.Add(itemp, vbodinfo);
GL.BindBuffer(BufferTarget.ArrayBuffer, itemp);
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(vbodinfo.Size), IntPtr.Zero, buh);
#if DEBUG
Misc.GLError("(VBOHandler - BufferData)");
#endif
//GL.BindBuffer(BufferTarget.ArrayBuffer, 0); //Remove?
currentBuffer_I = itemp; //Change to = uitemp (if previous line is removed!)
if(defaultBuffer_I == 0) {
defaultBuffer_I = itemp;
#if DEBUG
Console.WriteLine("Default VBO: " + defaultBuffer_I);
#endif
}
return itemp;
}
public VBO(BufferUsageHint usage)
{
this.usage = usage;
}
public static Buffer CreateBuffer(this Context context, int size, IntPtr data, BufferUsageHint bufferUsage)
{
return new Buffer(NativeMethods.cgGLCreateBuffer(context.Handle, size, data, bufferUsage), true);
}
