public void ExampleCreateArrayBufferObject(GraphicsContext ctx)
{
using (ArrayBuffer <Vertex3f> vertexPosition = new ArrayBuffer <Vertex3f>(BufferUsage.StaticDraw)) {
// Define CPU data
vertexPosition.Create(new Vertex3f[] {
Vertex3f.UnitX, Vertex3f.UnitY, Vertex3f.UnitZ
});
// Create GPU data
vertexPosition.Create(ctx);
}
using (ArrayBuffer <ColorRGBAF> vertexColor = new ArrayBuffer <ColorRGBAF>(BufferUsage.StaticDraw)) {
// Define GPU items count
vertexColor.Create(256);
// Reserve GPU memory
vertexColor.Create(ctx);
// Update
vertexColor.Create(ctx, new ColorRGBAF[] { ColorRGBAF.ColorRed, ColorRGBAF.ColorGreen, ColorRGBAF.ColorBlue });
}
// By ArrayBufferItemType
using (ArrayBuffer buffer = ArrayBuffer.CreateArrayObject(ArrayBufferItemType.Float3x3, BufferUsage.StaticDraw)) {
// ...
}
}
public void ArrayBuffer_TestCreateImmutable()
{
using (ArrayBuffer arrayBuffer = new ArrayBuffer(ArrayBufferItemType.Float4, MapBufferUsageMask.DynamicStorageBit)) {
// Using MapBufferUsageMask constructor make array buffer immutable
Assert.IsTrue(arrayBuffer.Immutable);
// Create on-line
Assert.DoesNotThrow(() => arrayBuffer.Create(_Context, 16));
// Being immutable, it cannot change size
Assert.Throws <GlException>(() => arrayBuffer.Create(_Context, 32));
}
}
public void ArrayBuffer_TestCreateNonImmutable()
{
using (ArrayBuffer arrayBuffer = new ArrayBuffer(ArrayBufferItemType.Float4, BufferUsage.DynamicDraw)) {
// Using BufferUsage constructor make array buffer mutable
Assert.IsFalse(arrayBuffer.Immutable);
// Create on-line
Assert.DoesNotThrow(() => arrayBuffer.Create(_Context, 16));
// Being mutable, is can be reset even if size
Assert.DoesNotThrow(() => arrayBuffer.Create(_Context, 32));
}
}
public static VertexArrays CreateCone(float radius, float height, uint dr)
{
VertexArrays vertexArray = new VertexArrays();
// Vertex generation
Vertex3f[] position = new Vertex3f[dr + 2];
int positionIndex = 0;
position[positionIndex++] = new Vertex3f(0.0f, 0.0f, -height);
double angleStep = Math.PI * 2.0 / dr;
for (double angle = 0.0f; angle <= Math.PI * 2.0; angle += angleStep)
{
float x = radius * (float)Math.Cos(angle);
float y = radius * (float)Math.Sin(angle);
Debug.Assert(positionIndex < position.Length);
position[positionIndex++] = new Vertex3f(x, y, 0.0f);
}
position[positionIndex++] = position[1];
// Buffer definition
ArrayBuffer <Vertex3f> positionBuffer = new ArrayBuffer <Vertex3f>();
positionBuffer.Create(position);
vertexArray.SetArray(positionBuffer, VertexArraySemantic.Position);
vertexArray.SetElementArray(PrimitiveType.TriangleFan);
return(vertexArray);
}
/// <summary>
/// Create a sphere.
/// </summary>
/// <param name="radius">
/// A <see cref="Single"/> that specifies the radius of the sphere.
/// </param>
/// <param name="slices">
/// A <see cref="Int32"/> that specifies the number of horizontal subdivisions of the sphere.
/// </param>
/// <param name="stacks">
/// A <see cref="Int32"/> that specifies the number of vertical subdivisions of the sphere.
/// </param>
/// <returns>
/// It returns a <see cref="Objects.VertexArrays"/> defining the following semantics:
/// - Positions
/// - Normals
/// </returns>
public static VertexArrays CreateSphere(float radius, int slices, int stacks)
{
VertexArrays vertexArray = new VertexArrays();
// Vertex generation
Vertex3f[] position, normal;
ushort[] indices;
int vertexCount;
GenerateSphere(radius, slices, stacks, out position, out normal, out indices, out vertexCount);
// Buffer definition
ArrayBuffer <Vertex3f> positionBuffer = new ArrayBuffer <Vertex3f>();
positionBuffer.Create(position);
vertexArray.SetArray(positionBuffer, VertexArraySemantic.Position);
ArrayBuffer <Vertex3f> normalBuffer = new ArrayBuffer <Vertex3f>();
normalBuffer.Create(normal);
vertexArray.SetArray(normalBuffer, VertexArraySemantic.Normal);
ElementBuffer <ushort> elementBuffer = new ElementBuffer <ushort>();
elementBuffer.Create(indices);
vertexArray.SetElementArray(PrimitiveType.TriangleStrip, elementBuffer);
return(vertexArray);
}
protected override void CreateGpuBuffer(Buffer buffer)
{
ArrayBuffer arrayBuffer = (ArrayBuffer)buffer;
// Create CPU buffer with 16 elements
arrayBuffer.Create(_Context, 16);
}
/// <summary>
/// Create vertex arrays representing the bounding box, using lines delimiting the box volume.
/// </summary>
/// <returns>
/// It returns a <see cref="VertexArrays"/> representing a normalized bounding box volume.
/// </returns>
private static VertexArrays CreateBoundingBoxArrays()
{
VertexArrays bboxArray = new VertexArrays();
ArrayBuffer <Vertex3f> bboxVPositionArray = new ArrayBuffer <Vertex3f>();
bboxVPositionArray.Create(new Vertex3f[] {
// Lower
new Vertex3f(-0.5f, -0.5f, -0.5f), new Vertex3f(+0.5f, -0.5f, -0.5f),
new Vertex3f(+0.5f, -0.5f, -0.5f), new Vertex3f(+0.5f, -0.5f, +0.5f),
new Vertex3f(+0.5f, -0.5f, +0.5f), new Vertex3f(-0.5f, -0.5f, +0.5f),
new Vertex3f(-0.5f, -0.5f, +0.5f), new Vertex3f(-0.5f, -0.5f, -0.5f),
// Upper
new Vertex3f(-0.5f, +0.5f, -0.5f), new Vertex3f(+0.5f, +0.5f, -0.5f),
new Vertex3f(+0.5f, +0.5f, -0.5f), new Vertex3f(+0.5f, +0.5f, +0.5f),
new Vertex3f(+0.5f, +0.5f, +0.5f), new Vertex3f(-0.5f, +0.5f, +0.5f),
new Vertex3f(-0.5f, +0.5f, +0.5f), new Vertex3f(-0.5f, +0.5f, -0.5f),
// Verticals
new Vertex3f(-0.5f, -0.5f, -0.5f), new Vertex3f(-0.5f, +0.5f, -0.5f),
new Vertex3f(+0.5f, -0.5f, -0.5f), new Vertex3f(+0.5f, +0.5f, -0.5f),
new Vertex3f(+0.5f, -0.5f, +0.5f), new Vertex3f(+0.5f, +0.5f, +0.5f),
new Vertex3f(-0.5f, -0.5f, +0.5f), new Vertex3f(-0.5f, +0.5f, +0.5f),
});
bboxArray.SetArray(bboxVPositionArray, VertexArraySemantic.Position);
bboxArray.SetElementArray(PrimitiveType.Lines);
return(bboxArray);
}
private SceneObjectGeometry CreateCubeGeometry()
{
SceneObjectGeometry cubeGeometry = new SceneObjectGeometry("Cube");
#region State
cubeGeometry.ObjectState.DefineState(new CullFaceState(FrontFaceDirection.Ccw, CullFaceMode.Back));
cubeGeometry.ObjectState.DefineState(new TransformState());
MaterialState cubeMaterialState = new MaterialState();
cubeMaterialState.FrontMaterial = new MaterialState.Material(ColorRGBAF.ColorWhite * 0.5f);
cubeMaterialState.FrontMaterial.Ambient = ColorRGBAF.ColorBlack;
cubeMaterialState.FrontMaterial.Diffuse = ColorRGBAF.ColorWhite * 0.5f;
cubeMaterialState.FrontMaterial.Specular = ColorRGBAF.ColorWhite * 0.5f;
cubeMaterialState.FrontMaterial.Shininess = 10.0f;
cubeGeometry.ObjectState.DefineState(cubeMaterialState);
#endregion
#region Vertex Arrays
if (_CubeArrayPosition == null)
{
_CubeArrayPosition = new ArrayBuffer <Vertex3f>();
_CubeArrayPosition.Create(ArrayPosition);
}
if (_CubeArrayColor == null)
{
_CubeArrayColor = new ArrayBuffer <ColorRGBF>();
_CubeArrayColor.Create(ArrayColors);
}
if (_CubeArrayNormal == null)
{
_CubeArrayNormal = new ArrayBuffer <Vertex3f>();
_CubeArrayNormal.Create(ArrayNormals);
}
if (_CubeArrays == null)
{
_CubeArrays = new VertexArrays();
_CubeArrays.SetArray(_CubeArrayPosition, VertexArraySemantic.Position);
_CubeArrays.SetArray(_CubeArrayColor, VertexArraySemantic.Color);
_CubeArrays.SetArray(_CubeArrayNormal, VertexArraySemantic.Normal);
_CubeArrays.SetElementArray(PrimitiveType.Triangles);
}
cubeGeometry.VertexArray = _CubeArrays;
#endregion
#region Program
cubeGeometry.BoundingVolume = new BoundingBox(-Vertex3f.One * _CubeSize, Vertex3f.One * _CubeSize);
#endregion
return(cubeGeometry);
}
private SceneObjectGeometry CreateSphere(string material)
{
SceneObjectGeometry sphereGeometry = new SceneObjectGeometry("Sphere");
sphereGeometry.ObjectState.DefineState(new CullFaceState(FrontFaceDirection.Ccw, CullFaceMode.Back));
sphereGeometry.ObjectState.DefineState(new TransformState());
sphereGeometry.LocalModelView = Matrix4x4f.Translated(0.0f, 4.0f, 0.0f);
sphereGeometry.VertexArray = VertexArrays.CreateSphere(4.0f, 32, 32);
ArrayBuffer <Vertex2f> texCoordBuffer = new ArrayBuffer <Vertex2f>();
texCoordBuffer.Create(sphereGeometry.VertexArray.ArrayLength);
sphereGeometry.VertexArray.SetArray(texCoordBuffer, VertexArraySemantic.TexCoord);
ArrayBuffer <Vertex3f> tanCoordBuffer = new ArrayBuffer <Vertex3f>();
tanCoordBuffer.Create(sphereGeometry.VertexArray.ArrayLength);
sphereGeometry.VertexArray.SetArray(tanCoordBuffer, VertexArraySemantic.Tangent);
ArrayBuffer <Vertex3f> bitanCoordBuffer = new ArrayBuffer <Vertex3f>();
bitanCoordBuffer.Create(sphereGeometry.VertexArray.ArrayLength);
sphereGeometry.VertexArray.SetArray(bitanCoordBuffer, VertexArraySemantic.Bitangent);
sphereGeometry.VertexArray.GenerateTexCoords(new VertexArrayTexGen.Sphere());
sphereGeometry.VertexArray.GenerateTangents();
sphereGeometry.ProgramTag = ShadersLibrary.Instance.CreateProgramTag("OpenGL.Standard+PhongFragment");
SetSphereMaterial(sphereGeometry, material);
return(sphereGeometry);
}
/// <summary>
///
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
public static VertexArrays CreatePlane(float x, float y, float z, uint dx, uint dy)
{
VertexArrays vertexArray = new VertexArrays();
// Vertex generation
Vertex3f[] position = new Vertex3f[(dx + 1) * (dy + 1)];
float x2 = x / 2.0f, y2 = y / 2.0f;
float vdx = x / dx, vdy = y / dy;
int vidx = 0;
for (float vy = -y2; vy <= y2; vy += vdy)
{
for (float vx = -x2; vx <= x2; vx += vdx)
{
Debug.Assert(vidx < position.Length);
position[vidx++] = new Vertex3f(vx, vy, z);
}
}
// Elements generation
List <uint> indices = new List <uint>();
uint restartIndex = ElementBuffer <uint> .DefaultRestartIndex;
uint vstride = dx + 1;
for (uint i = 0; i < dy; i++)
{
uint yoffset = i * vstride;
// Triangle strip start
indices.Add(yoffset + vstride);
for (uint ix = 0; ix < dx; ix++)
{
uint xoffset = yoffset + ix;
indices.Add(xoffset);
indices.Add(xoffset + vstride + 1);
}
indices.Add(yoffset + vstride - 1);
indices.Add(restartIndex);
}
// Buffer definition
ArrayBuffer <Vertex3f> positionBuffer = new ArrayBuffer <Vertex3f>();
positionBuffer.Create(position);
vertexArray.SetArray(positionBuffer, VertexArraySemantic.Position);
ElementBuffer <uint> elementBuffer = new ElementBuffer <uint>();
elementBuffer.Create(indices.ToArray());
elementBuffer.RestartIndexEnabled = true;
vertexArray.SetElementArray(PrimitiveType.TriangleStrip, elementBuffer);
return(vertexArray);
}
private void LinkShadowMapResources(GraphicsContext ctx)
{
LinkResource(_ShadowMapQuad = new VertexArrays());
ArrayBuffer <Vertex2f> positionArray = new ArrayBuffer <Vertex2f>(BufferUsage.StaticDraw);
positionArray.Create(new Vertex2f[] {
new Vertex2f(0.0f, 0.0f), new Vertex2f(1.0f, 0.0f), new Vertex2f(1.0f, 1.0f),
new Vertex2f(0.0f, 1.0f), new Vertex2f(0.0f, 0.0f), new Vertex2f(1.0f, 1.0f),
});
positionArray.Create(ctx);
_ShadowMapQuad.SetArray(positionArray, VertexArraySemantic.Position);
_ShadowMapQuad.SetArray(positionArray, VertexArraySemantic.TexCoord);
_ShadowMapQuad.SetElementArray(PrimitiveType.Triangles);
_ShadowMapQuad.Create(ctx);
LinkResource(_ShadowMapDebugProgram = ctx.CreateProgram("OpenGL.Specialized+Depth"));
}
/// <summary>
/// Create a <see cref="ArrayBufferBase"/> for testing.
/// </summary>
/// <returns>
/// It returns the <see cref="ArrayBufferBase"/> instance to test.
/// </returns>
private void CreateClientInstance(Buffer buffer)
{
if (buffer.GetType() == typeof(ArrayBuffer))
{
ArrayBuffer arrayBufferObject = (ArrayBuffer)buffer;
arrayBufferObject.Create(CreateTestArray());
}
else if (buffer.GetType() == typeof(ElementBuffer))
{
ElementBuffer elementBufferObject = (ElementBuffer)buffer;
elementBufferObject.Create(CreateTestArray());
}
}
public VertexArrays CreateArrays(ObjContext objContext)
{
if (objContext == null)
{
throw new ArgumentNullException("objContext");
}
VertexArrays vertexArray = new VertexArrays();
List <ObjFaceCoord> coords = new List <ObjFaceCoord>();
bool hasTexCoord = Material.DiffuseTexture != null;
bool hasNormals = false;
bool hasTanCoord = hasTexCoord && Material.NormalTexture != null;
foreach (ObjFace f in Faces)
{
hasTexCoord |= f.HasTexCoord;
hasNormals |= f.HasNormal;
coords.AddRange(f.Triangulate());
}
uint vertexCount = (uint)coords.Count;
Vertex4f[] position = new Vertex4f[vertexCount];
Vertex3f[] normal = hasNormals ? new Vertex3f[vertexCount] : null;
Vertex2f[] texcoord = new Vertex2f[vertexCount];
for (int i = 0; i < position.Length; i++)
{
Debug.Assert(coords[i].VertexIndex < objContext.Vertices.Count);
position[i] = objContext.Vertices[coords[i].VertexIndex];
if (hasTexCoord)
{
Debug.Assert(coords[i].TexCoordIndex < objContext.TextureCoords.Count);
texcoord[i] = objContext.TextureCoords[coords[i].TexCoordIndex];
}
if (hasNormals)
{
Debug.Assert(coords[i].NormalIndex < objContext.Normals.Count);
normal[i] = objContext.Normals[coords[i].NormalIndex];
}
}
// Position (mandatory)
ArrayBuffer <Vertex4f> positionBuffer = new ArrayBuffer <Vertex4f>();
positionBuffer.Create(position);
vertexArray.SetArray(positionBuffer, VertexArraySemantic.Position);
// Layout (triangles)
vertexArray.SetElementArray(PrimitiveType.Triangles);
// Texture
if (hasTexCoord)
{
ArrayBuffer <Vertex2f> texCoordBuffer = new ArrayBuffer <Vertex2f>();
texCoordBuffer.Create(texcoord);
vertexArray.SetArray(texCoordBuffer, VertexArraySemantic.TexCoord);
}
// Normals
if (hasNormals)
{
ArrayBuffer <Vertex3f> normalBuffer = new ArrayBuffer <Vertex3f>();
normalBuffer.Create(normal);
vertexArray.SetArray(normalBuffer, VertexArraySemantic.Normal);
}
else
{
ArrayBuffer <Vertex3f> normalBuffer = new ArrayBuffer <Vertex3f>();
normalBuffer.Create(vertexCount);
vertexArray.SetArray(normalBuffer, VertexArraySemantic.Normal);
// XXX vertexArray.GenerateNormals();
}
// Tangents
if (hasTanCoord)
{
ArrayBuffer <Vertex3f> tanCoordBuffer = new ArrayBuffer <Vertex3f>();
tanCoordBuffer.Create(vertexCount);
vertexArray.SetArray(tanCoordBuffer, VertexArraySemantic.Tangent);
ArrayBuffer <Vertex3f> bitanCoordBuffer = new ArrayBuffer <Vertex3f>();
bitanCoordBuffer.Create(vertexCount);
vertexArray.SetArray(bitanCoordBuffer, VertexArraySemantic.Bitangent);
// XXX vertexArray.GenerateTangents();
}
return(vertexArray);
}
/// <summary>
/// Create a <see cref="VertexArrays"/> for rendering glyphs.
/// </summary>
private void LinkSharedResources(GraphicsContext ctx)
{
CheckCurrentContext(ctx);
string resourceClassId = "OpenGL.Objects.FontPatch";
string resourceBaseId = String.Format("{0}.{1}-{2}-{3}", resourceClassId, Family, Size, Style);
string vertexArrayId = resourceBaseId + ".VertexArray";
string glyphDbId = resourceBaseId + ".GlyphDb";
#region Vertex Arrays
_VertexArrays = (VertexArrays)ctx.GetSharedResource(vertexArrayId);
Dictionary <char, Glyph> glyphsDb = null;
if (_VertexArrays == null)
{
_VertexArrays = new VertexArrays();
List <GlyphPolygons> glyphPolygons = GenerateGlyphs(Family, Size, Style);
List <Vertex2f> glyphsVertices = new List <Vertex2f>();
GlyphPolygons gGlyph = null;
uint gVertexIndex = 0;
glyphsDb = new Dictionary <char, Glyph>();
using (Tessellator tessellator = new Tessellator()) {
tessellator.Begin += delegate(object sender, TessellatorBeginEventArgs e) {
gVertexIndex = (uint)glyphsVertices.Count;
};
tessellator.End += delegate(object sender, EventArgs e) {
// Create element (range)
int glyphIndex = _VertexArrays.SetElementArray(PrimitiveType.Triangles, gVertexIndex, (uint)glyphsVertices.Count - gVertexIndex);
glyphsDb.Add(gGlyph.GlyphChar, new Glyph(gGlyph.GlyphChar, gGlyph.GlyphSize, glyphIndex));
};
tessellator.Vertex += delegate(object sender, TessellatorVertexEventArgs e) {
glyphsVertices.Add((Vertex2f)e.Vertex);
};
// Tessellate all glyphs
foreach (GlyphPolygons glyph in glyphPolygons)
{
gGlyph = glyph;
if (glyph.Contours.Count == 0)
{
glyphsDb.Add(gGlyph.GlyphChar, new Glyph(gGlyph.GlyphChar, gGlyph.GlyphSize, -1));
continue;
}
tessellator.BeginPolygon();
foreach (List <Vertex2f> countour in glyph.Contours)
{
tessellator.AddContour(countour.ToArray(), Vertex3f.UnitZ);
}
tessellator.EndPolygon();
}
}
// Element vertices
ArrayBuffer <Vertex2f> gVertexPosition = new ArrayBuffer <Vertex2f>();
gVertexPosition.Create(glyphsVertices.ToArray());
_VertexArrays.SetArray(gVertexPosition, VertexArraySemantic.Position);
// Share
ctx.SetSharedResource(vertexArrayId, _VertexArrays);
}
LinkResource(_VertexArrays);
#endregion
#region Glyph Metadata
_Glyphs = (Dictionary <char, Glyph>)ctx.GetSharedResource(glyphDbId);
if (glyphsDb != null)
{
_Glyphs = glyphsDb;
}
if (_Glyphs == null)
{
throw new InvalidProgramException("no glyph metadata");
}
// Share
ctx.SetSharedResource(glyphDbId, _Glyphs);
#endregion
}
/// <summary>
/// Create resources for rendering glyphs.
/// </summary>
/// <param name="ctx"></param>
private void LinkSharedResources(GraphicsContext ctx)
{
CheckCurrentContext(ctx);
StringFormat stringFormat = StringFormat.GenericTypographic;
// Font-wide resources
string resourceClassId = "OpenGL.Objects.FontTextureArray2d";
string resourceBaseId = String.Format("{0}.{1}-{2}-{3}", resourceClassId, Family, Size, Style);
#region Instanced Arrays
if (ctx.Extensions.InstancedArrays)
{
string instanceArrayId = resourceClassId + ".InstanceArray";
_GlyphInstances = (ArrayBufferObjectInterleaved <GlyphInstance>)ctx.GetSharedResource(instanceArrayId);
if (_GlyphInstances == null)
{
_GlyphInstances = new ArrayBufferObjectInterleaved <GlyphInstance>(MapBufferUsageMask.MapWriteBit);
_GlyphInstances.Create(256);
// Share
ctx.SetSharedResource(instanceArrayId, _GlyphInstances);
}
LinkResource(_GlyphInstances);
}
else
{
_GlyphInstances = null;
}
#endregion
#region Vertex Array
string vertexArrayId = resourceClassId + ".VertexArray";
_VertexArrays = (VertexArrays)ctx.GetSharedResource(vertexArrayId);
if (_VertexArrays == null)
{
_VertexArrays = new VertexArrays();
ArrayBuffer <Vertex2f> arrayPosition = new ArrayBuffer <Vertex2f>();
arrayPosition.Create(new Vertex2f[] {
new Vertex2f(0.0f, 1.0f),
new Vertex2f(0.0f, 0.0f),
new Vertex2f(1.0f, 1.0f),
new Vertex2f(1.0f, 0.0f),
});
_VertexArrays.SetArray(arrayPosition, VertexArraySemantic.Position);
if (ctx.Extensions.InstancedArrays)
{
_VertexArrays.SetInstancedArray(_GlyphInstances, 0, 1, "glo_GlyphModelViewProjection");
_VertexArrays.SetInstancedArray(_GlyphInstances, 1, 1, "glo_GlyphVertexParams");
_VertexArrays.SetInstancedArray(_GlyphInstances, 2, 1, "glo_GlyphTexParams");
}
_VertexArrays.SetElementArray(PrimitiveType.TriangleStrip);
// Share
ctx.SetSharedResource(vertexArrayId, _VertexArrays);
}
LinkResource(_VertexArrays);
#endregion
#region Glyphs Metadata
string glyphDbId = resourceBaseId + ".GlyphDb";
_GlyphMetadata = (Dictionary <char, Glyph>)ctx.GetSharedResource(glyphDbId);
if (_GlyphMetadata == null)
{
_GlyphMetadata = new Dictionary <char, Glyph>();
char[] fontChars = GetFontCharacters().ToCharArray();
uint layer = 0;
using (Bitmap bitmap = new Bitmap(1, 1))
using (Graphics g = Graphics.FromImage(bitmap))
using (System.Drawing.Font font = new System.Drawing.Font(Family, Size, Style))
{
// Avoid grid fitting
g.TextRenderingHint = TextRenderingHint.AntiAlias;
float glyphHeight = font.GetHeight();
foreach (char c in fontChars)
{
SizeF glyphSize;
switch (c)
{
case ' ':
glyphSize = g.MeasureString(c.ToString(), font, 0, StringFormat.GenericDefault);
break;
default:
glyphSize = g.MeasureString(c.ToString(), font, 0, stringFormat);
break;
}
Glyph glyph = new Glyph(c, glyphSize, layer++, new SizeF(1.0f, 1.0f));
_GlyphMetadata.Add(c, glyph);
}
}
// Share
ctx.SetSharedResource(glyphDbId, _GlyphMetadata);
}
#endregion
#region Glyph Sampler
string samplerId = resourceBaseId + ".Sampler";
Sampler sampler = (Sampler)ctx.GetSharedResource(samplerId);
if (sampler == null)
{
sampler = new Sampler();
sampler.Parameters.MinFilter = TextureMinFilter.Linear;
}
#endregion
#region Glyph Texture
string textureId = resourceBaseId + ".Texture";
_FontTexture = (TextureArray2d)ctx.GetSharedResource(textureId);
if (_FontTexture == null)
{
// Get the size required for all glyphs
float w = 0.0f, h = 0.0f;
uint z = 0;
foreach (Glyph glyph in _GlyphMetadata.Values)
{
w = Math.Max(w, glyph.GlyphSize.Width);
h = Math.Max(h, glyph.GlyphSize.Height);
z = Math.Max(z, glyph.Layer);
}
// Create texture
_FontTexture = new TextureArray2d();
_FontTexture.Sampler = sampler;
_FontTexture.Create(ctx, (uint)Math.Ceiling(w), (uint)Math.Ceiling(h), z + 1, PixelLayout.R8, 1);
using (System.Drawing.Font font = new System.Drawing.Font(Family, Size, Style))
using (Brush brush = new SolidBrush(Color.White))
{
foreach (Glyph glyph in _GlyphMetadata.Values)
{
using (Bitmap bitmap = new Bitmap((int)_FontTexture.Width, (int)_FontTexture.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb))
using (Graphics g = Graphics.FromImage(bitmap)) {
// Recompute texture scaling
glyph.TexScale = new SizeF(
glyph.GlyphSize.Width / bitmap.Width,
glyph.GlyphSize.Height / bitmap.Height
);
// Avoid grid fitting
g.TextRenderingHint = TextRenderingHint.AntiAlias;
g.Clear(Color.Black);
g.DrawString(glyph.GlyphChar.ToString(), font, brush, 0.0f, 0.0f, stringFormat);
_FontTexture.Create(ctx, PixelLayout.R8, bitmap, glyph.Layer);
}
}
}
// Share
ctx.SetSharedResource(textureId, _FontTexture);
}
LinkResource(_FontTexture);
#endregion
}
private void VisionControl_ContextCreated(object sender, OpenGL.GlControlEventArgs e)
{
// Create GL context abstraction
_GraphicsContext = new GraphicsContext(e.DeviceContext, e.RenderContext);
// Create texture
_FramebufferTexture = new Texture2d(1024, 1024, PixelLayout.RGB24);
_FramebufferTexture.SamplerParams.MagFilter = TextureMagFilter.Linear;
_FramebufferTexture.SamplerParams.MinFilter = TextureMinFilter.Linear;
_FramebufferTexture.Create(_GraphicsContext);
// Create framebuffer
_Framebuffer = new Framebuffer();
_Framebuffer.AttachColor(0, _FramebufferTexture);
_Framebuffer.Create(_GraphicsContext);
// Create shader (standard)
_ProgramStd = _GraphicsContext.CreateProgram("OpenGL.Standard");
_ProgramStd.Create(_GraphicsContext);
// Create program (standard + texture)
_ProgramStdTex = _GraphicsContext.CreateProgram("OpenGL.Standard+Texture");
_ProgramStdTex.Create(_GraphicsContext);
// Create vertex arrays (square)
ArrayBuffer <Vertex2f> quadBuffer = new ArrayBuffer <Vertex2f>(BufferUsage.StaticDraw);
quadBuffer.Create(new Vertex2f[] {
new Vertex2f(-0.5f, +0.5f),
new Vertex2f(-0.5f, -0.5f),
new Vertex2f(+0.5f, +0.5f),
new Vertex2f(+0.5f, -0.5f),
});
_ArraysQuad = new VertexArrays();
_ArraysQuad.SetArray(quadBuffer, VertexArraySemantic.Position);
_ArraysQuad.SetElementArray(PrimitiveType.TriangleStrip);
_ArraysQuad.Create(_GraphicsContext);
// Create vertex arrays (square)
ArrayBuffer <Vertex2f> postquadBuffer = new ArrayBuffer <Vertex2f>(BufferUsage.StaticDraw);
postquadBuffer.Create(new Vertex2f[] {
new Vertex2f(0.0f, 1.0f),
new Vertex2f(0.0f, 0.0f),
new Vertex2f(1.0f, 1.0f),
new Vertex2f(1.0f, 0.0f),
});
_ArraysPostQuad = new VertexArrays();
_ArraysPostQuad.SetArray(postquadBuffer, VertexArraySemantic.Position);
_ArraysPostQuad.SetArray(postquadBuffer, VertexArraySemantic.TexCoord);
_ArraysPostQuad.SetElementArray(PrimitiveType.TriangleStrip);
_ArraysPostQuad.Create(_GraphicsContext);
// Create vertex arrays (optical markers)
_BufferOpticalMarkers = new ArrayBuffer <Vertex2f>(BufferUsage.DynamicDraw);
_BufferOpticalMarkers.Create(10000 * 2);
_ArraysOpticalMarkers = new VertexArrays();
_ArraysOpticalMarkers.SetArray(_BufferOpticalMarkers, VertexArraySemantic.Position);
_ArraysOpticalMarkers.SetElementArray(PrimitiveType.Lines);
_ArraysOpticalMarkers.Create(_GraphicsContext);
}
