public void Attach()
{
_renderer.Init();
var vertexBuffer = _factory.Create <IVertexBuffer>();
vertexBuffer.SetData(_vertices);
vertexBuffer.AddLayout <float>(3);
vertexBuffer.AddLayout <float>(2);
var indexBuffer = _factory.Create <IIndexBuffer>();
indexBuffer.AddData(_indices);
_vertexArray = _factory.Create <IVertexArray>();
_vertexArray.VertexBuffer = vertexBuffer;
_vertexArray.IndexBuffer = indexBuffer;
_shader = _factory.Create <IShader>();
_shader.Compile("Assets/shader.vert", "Assets/shader.frag");
_shader.SetInt("texture0", 0);
_texture = _factory.Create <ITexture2D>();
_texture.SetData("Assets/picture.png");
_position = _camera.Position;
}
public static void CopyIndices(this IVertexArray vertexArray, int[] indices, int indexBase, int startIndex = 0)
{
for (int i = 0; i < vertexArray.Length; i++)
{
indices[startIndex + i] = vertexArray.Indices[i] + indexBase;
}
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 3 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex {
Position = new Vector4(-0.5f, -0.5f, 0f, 1f), Color = new Color4(1, 0, 0, 1)
},
new Vertex {
Position = new Vector4(0.0f, 0.5f, 0f, 1f), Color = new Color4(0, 1, 0, 1)
},
new Vertex {
Position = new Vector4(0.5f, -0.5f, 0f, 1f), Color = new Color4(1, 1, 0, 1)
}
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 3 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[] { 0, 1, 2 });
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
IVertexShader vsh = Context.Create.VertexShader(VertexShaderText);
IFragmentShader fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_color" }
});
}
public FullTextureProcessor(IClientSettings settings, IContext context, string fragmentShaderText, string[] samplerNames)
{
var header = settings.IsEs ? EsHeader : DesktopHeader;
var vertexShader = context.Create.VertexShader(header + VertexShaderText);
var decodeFragmentShader = context.Create.FragmentShader(header + fragmentShaderText);
program = context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vertexShader },
FragmentShaders = new[] { decodeFragmentShader },
VertexAttributeNames = new[] { "in_position" },
SamplerNames = samplerNames
});
var vertexBuffer = context.Create.Buffer(BufferTarget.ArrayBuffer, 4 * Vertex.Size, BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, 1f),
new Vertex(1f, 1f),
new Vertex(1f, -1f),
new Vertex(-1f, -1f)
});
var elementArrayBuffer = context.Create.Buffer(BufferTarget.ElementArrayBuffer, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = context.Create.VertexArray();
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.Size, 0);
vertexArray.SetElementArrayBuffer(elementArrayBuffer);
}
public HeadlessMesh(Vertex[] vertices, int[] indices)
{
Verts = new HeadlessVertexArray(vertices, indices);
Transform = new Transform();
Textures = new List <ITexture2D>();
Material = null;
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 12 * Vertex.SizeInBytes, BufferUsageHint.StaticDraw, new Vertex[]
{
new Vertex(-1f, 1 / 3f), new Vertex(4f, 1f), new Vertex(-4f, 1f), new Vertex(1f, 1 / 3f),
new Vertex(-1f, -1 / 3f), new Vertex(4f, 1 / 3f), new Vertex(-4f, 1 / 3f), new Vertex(1f, -1 / 3f),
new Vertex(-1f, -1f), new Vertex(4f, -1 / 3f), new Vertex(-4f, -1 / 3f), new Vertex(1f, -1f)
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
tessFactorBuffer = Context.Create.Buffer(BufferTarget.Uniform, sizeof(int), BufferUsageHint.DynamicDraw);
var vsh = Context.Create.VertexShader(VertexShaderText);
var tcsh = Context.Create.TesselationControlShader(TessControlShaderText);
var tesh = Context.Create.TesselationEvaluationShader(TessEvaluationShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
TesselationControlShaders = new[] { tcsh },
TesselationEvaluationShaders = new[] { tesh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position" },
UniformBufferNames = new[] { "TessFactor" }
});
}
public override void Initialize()
{
var vertexData = new Vertex[ParticleCount];
for (int i = 0; i < vertexData.Length; i++)
{
vertexData[i] = new Vertex((float)i / ParticleCount);
}
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, ParticleCount * Vertex.SizeInBytes, BufferUsageHint.StaticDraw, vertexData);
vertexArray = Context.Create.VertexArray();
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 3 * sizeof(float));
timeBuffer = Context.Create.Buffer(BufferTarget.Uniform, sizeof(float), BufferUsageHint.DynamicDraw);
cameraBuffer = Context.Create.Buffer(BufferTarget.Uniform, sizeof(float), BufferUsageHint.DynamicDraw);
var vsh = Context.Create.VertexShader(VertexShaderText);
var gsh = Context.Create.GeometryShader(GeometryShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
GeometryShaders = new[] { gsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_color" },
UniformBufferNames = new[] { "Time", "Camera" }
});
}
public override void OnLoad()
{
vao = Factory <VertexPositionNormalColor> .CreateVertexArray();
normals_shader = new NormalsProgram();
points_shader = new PointsProgram();
ellipsoids_shader = new EllipsoidsProgram();
}
/// <summary>
/// Submit something to be drawn
/// </summary>
/// <param name="shader"></param>
/// <param name="vertexArray"></param>
/// <param name="transform"></param>
public static void Submit(IShader shader, IVertexArray vertexArray, Matrix4x4 transform)
{
shader.Bind();
shader.SetMat4("u_ViewProjection", sceneData.ViewProjectionMatrix);
shader.SetMat4("u_Transform", transform);
vertexArray.Bind();
RenderingAPI.DrawIndexed(vertexArray);
}
public unsafe HighlightDrawer(IGraphicsInfra infra, IBlurDrawer blurDrawer, IQuadDrawer quadDrawer, IBleedDrawer bleedDrawer, IOffScreenContainer offScreenContainer)
{
this.infra = infra;
this.blurDrawer = blurDrawer;
this.quadDrawer = quadDrawer;
this.bleedDrawer = bleedDrawer;
this.offScreenContainer = offScreenContainer;
#region Shader Text
const string vertexShaderText =
@"#version 150
in vec4 in_position;
void main()
{
gl_Position = in_position;
}
";
const string fragmentShaderText =
@"#version 150
out vec4 out_color;
void main()
{
out_color = vec4(1, 1, 1, 1);
}
";
#endregion
var vs = infra.GlContext.Create.VertexShader(vertexShaderText);
var fs = infra.GlContext.Create.FragmentShader(fragmentShaderText);
program = infra.GlContext.Create.Program(new ShaderProgramDescription
{
VertexShaders = vs.EnumSelf(),
FragmentShaders = fs.EnumSelf(),
VertexAttributeNames = new[] { "in_position" }
});
var vertices = new[]
{
new Vector4(-1, 1, 0.5f, 1),
new Vector4(-1, -1, 0.5f, 1),
new Vector4(1, 1, 0.5f, 1),
new Vector4(1, -1, 0.5f, 1)
};
IBuffer vb;
fixed(Vector4 *pVertices = vertices)
vb = infra.GlContext.Create.Buffer(BufferTarget.Array, vertices.Length * sizeof(Vector4), BufferUsageHint.StaticDraw, (IntPtr)pVertices);
vao = infra.GlContext.Create.VertexArray();
vao.SetVertexAttributeF(0, vb, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, sizeof(Vector4), 0);
drawSpotFramebuffer = infra.GlContext.Create.Framebuffer();
}
public void Submit(IShader shader, IVertexArray vertexArray)
{
shader.Bind();
shader.SetMat4("viewProjection", _viewProjection);
vertexArray.Bind();
_renderContext.Draw(vertexArray);
}
/// <summary>
/// Generate normals for this Element.
/// </summary>
/// <param name="vertexArray">
/// The <see cref="VertexArrayObject"/>
/// </param>
public override void GenerateNormals(VertexArrayObject vertexArray)
{
IVertexArray positionArray = vertexArray.GetVertexArray(VertexArraySemantic.Position);
if (positionArray == null)
{
throw new InvalidOperationException("position semantic not set");
}
IVertexArray normalArray = vertexArray.GetVertexArray(VertexArraySemantic.Normal);
if (normalArray == null)
{
throw new InvalidOperationException("normal semantic not set");
}
if (normalArray.Array == null)
{
throw new InvalidOperationException("normal array not set");
}
if (positionArray.Array != null)
{
positionArray.Array.Map();
}
normalArray.Array.Map();
try {
switch (ElementsMode)
{
case PrimitiveType.Triangles:
switch (positionArray.ArraySection.ItemType)
{
case ArrayBufferItemType.Float3:
GenerateNormalsTriangle3f(positionArray, normalArray);
break;
case ArrayBufferItemType.Float4:
GenerateNormalsTriangle4f(positionArray, normalArray);
break;
default:
throw new NotSupportedException("normals generation not supported for elements of type " + positionArray.ArraySection.ItemType);
}
break;
default:
throw new NotSupportedException("normals generation not supported for primitive " + ElementsMode);
}
} finally {
if (positionArray.Array != null)
{
positionArray.Array.Unmap();
}
normalArray.Array.Unmap();
}
}
/// <summary>
/// Generate texture coordinates for this Element.
/// </summary>
/// <param name="vertexArray">
/// The <see cref="VertexArrayObject"/>
/// </param>
public override void GenerateTexCoord(VertexArrayObject vertexArray, VertexArrayTexGenDelegate genTexCoordCallback)
{
IVertexArray positionArray = vertexArray.GetVertexArray(VertexArraySemantic.Position);
if (positionArray == null)
{
throw new InvalidOperationException("position semantic not set");
}
IVertexArray texArray = vertexArray.GetVertexArray(VertexArraySemantic.TexCoord);
if (texArray == null)
{
throw new InvalidOperationException("texture semantic not set");
}
if (texArray.Array == null)
{
throw new InvalidOperationException("texture array not set");
}
if (positionArray.Array != null)
{
positionArray.Array.Map();
}
texArray.Array.Map();
ArrayIndices.Map();
try {
switch (ElementsMode)
{
case PrimitiveType.Triangles:
case PrimitiveType.TriangleStrip:
switch (positionArray.ArraySection.ItemType)
{
case ArrayBufferItemType.Float3:
GenerateTexCoordsTriangle3f(positionArray, texArray, genTexCoordCallback);
break;
default:
throw new NotSupportedException("normals generation not supported for elements of type " + positionArray.ArraySection.ItemType);
}
break;
default:
throw new NotSupportedException("normals generation not supported for primitive " + ElementsMode);
}
} finally {
if (positionArray.Array != null)
{
positionArray.Array.Unmap();
}
texArray.Array.Unmap();
ArrayIndices.Unmap();
}
}
public void Begin()
{
#if DEBUG
if (actual == this)
{
throw new InvalidOperationException("VAO already in use!");
}
actual = this;
#endif
GL.BindVertexArray(Ptr);
}
public void End()
{
#if DEBUG
if (actual != this)
{
throw new InvalidOperationException("VAO not in use anymore!");
}
actual = null;
#endif
GL.BindVertexArray(0);
}
private void GenerateTexCoordsTriangle3f(IVertexArray positionArray, IVertexArray texArray, VertexArrayTexGenDelegate genTexCoordCallback)
{
for (uint i = 0, v = ElementOffset; i < ArrayIndices.ItemCount; i++, v++)
{
uint vIndex = ArrayIndices.GetIndex(v);
Vertex3f v0 = positionArray.GetElement <Vertex3f>(vIndex);
texArray.SetElement <Vertex2f>(genTexCoordCallback(v0), vIndex);
}
}
private Terrain(IOpenGL33 gl, IVertexArray vertexArray, IVertexBuffer vertexBuffer, IElementArray elementBuffer, TerrainShader shader)
{
_gl = gl;
_vertexArray = vertexArray;
_vertexBuffer = vertexBuffer;
_elementBuffer = elementBuffer;
_shader = shader;
Model = Matrix4f.Identity;
View = Matrix4f.Identity;
Projection = Matrix4f.Identity;
Diffuse = new Vector4f(Color.DodgerBlue.R / 255f, Color.DodgerBlue.G / 255f, Color.DodgerBlue.B / 255f, 1f);
}
public ExampleLayer()
{
//Create camera
cameraController = new OrthographicCameraController(1280.0f / 720.0f);
//Shader library
shaderLibrary = new ShaderLibrary();
// ----------
//Square
// ----------
squareVertexArray = IVertexArray.Create();
float[] squareVertices =
{
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f
};
IVertexBuffer squareVertexBuffer = IVertexBuffer.Create(squareVertices, squareVertices.GetBytes());
BufferLayout squareBufferLayout = new BufferLayout(new[]
{
new BufferElement("a_Position", ShaderDataType.Float3),
new BufferElement("a_TexCoord", ShaderDataType.Float2)
});
squareVertexBuffer.SetLayout(squareBufferLayout);
squareVertexArray.AddVertexBuffer(squareVertexBuffer);
uint[] squareIndices = { 0, 1, 2, 2, 3, 0 };
IIndexBuffer squareIndexBuffer =
IIndexBuffer.Create(squareIndices, squareIndices.GetBytes() / sizeof(uint));
squareVertexArray.SetIndexBuffer(squareIndexBuffer);
//Square shader
shaderLibrary.LoadAndAddShader("Shaders/Square.glsl");
//Texture shader
IShader textureShader = IShader.Create("Shaders/Texture.glsl");
shaderLibrary.AddShader(textureShader);
birdiTexture = I2DTexture.Create("Textures/Birdi.png");
faceTexture = I2DTexture.Create("Textures/Face.png");
textureShader.Bind();
textureShader.SetInt("u_Texture", 0);
}
private void GenerateTangentsTriangle4f(IVertexArray positionArray, IVertexArray normalArray, IVertexArray texArray, IVertexArray tanArray, IVertexArray bitanArray)
{
uint count = (ElementCount != 0 ? ElementCount : _VertexArrayObject.ArrayLength) / 3;
for (uint i = 0, v = ElementOffset; i < count; i++, v += 3)
{
Vertex3f v0 = (Vertex3f)positionArray.GetElement <Vertex4f>(v);
Vertex3f v1 = (Vertex3f)positionArray.GetElement <Vertex4f>(v + 1);
Vertex3f v2 = (Vertex3f)positionArray.GetElement <Vertex4f>(v + 2);
Vertex2f t0 = texArray.GetElement <Vertex2f>(v);
Vertex2f t1 = texArray.GetElement <Vertex2f>(v + 1);
Vertex2f t2 = texArray.GetElement <Vertex2f>(v + 2);
Vertex3f dv1 = v1 - v0, dv2 = v2 - v0;
Vertex2f dt1 = t1 - t0, dt2 = t2 - t0;
float w = 1.0f / (dt1.x * dt2.y - dt1.y * dt2.x);
Vertex3f tgVector, btVector;
if (Single.IsInfinity(w) == false)
{
tgVector = (dv1 * dt2.y - dv2 * dt1.y) * w;
tgVector.Normalize();
btVector = (dv2 * dt1.x - dv1 * dt2.x) * w;
btVector.Normalize();
Vertex3f n = normalArray.GetElement <Vertex3f>(v).Normalized;
n.Normalize();
if (((n ^ tgVector) * btVector) < 0.0f)
{
tgVector = tgVector * -1.0f;
}
}
else
{
// Degenerate triangles does not contribute
tgVector = btVector = Vertex3f.Zero;
}
tanArray.SetElement <Vertex3f>(tgVector, v);
tanArray.SetElement <Vertex3f>(tgVector, v + 1);
tanArray.SetElement <Vertex3f>(tgVector, v + 2);
bitanArray.SetElement <Vertex3f>(btVector, v);
bitanArray.SetElement <Vertex3f>(btVector, v + 1);
bitanArray.SetElement <Vertex3f>(btVector, v + 2);
}
}
public void Init()
{
if (_initialized)
{
return;
}
_renderContext.Init();
_vertices = new[]
{
new Vector3(0.5f, 0.5f, 0), new Vector3(0.5f, -0.5f, 0),
new Vector3(-0.5f, -0.5f, 0), new Vector3(-0.5f, 0.5f, 0)
};
_textureCoordinates = new[] { new Vector2(1, 0), new Vector2(1, 1), new Vector2(0, 1), new Vector2(0, 0) };
var vertexBuffer = _factory.Create <IVertexBuffer>();
vertexBuffer.SetSize <Renderable2DBuffer>(MaxSubmissions * VerticesInSubmission);
vertexBuffer.AddLayout <float>(3);
vertexBuffer.AddLayout <float>(2);
vertexBuffer.AddLayout <float>(4);
vertexBuffer.AddLayout <float>(1);
vertexBuffer.AddLayout <float>(1);
var indices = Enumerable.Range(0, MaxSubmissions)
.SelectMany(i =>
{
var startingIndex = Convert.ToUInt32(i * VerticesInSubmission);
return(new[]
{
0 + startingIndex, 1 + startingIndex, 3 + startingIndex,
1 + startingIndex, 2 + startingIndex, 3 + startingIndex
});
}).ToArray();
var indexBuffer = _factory.Create <IIndexBuffer>();
indexBuffer.AddData(indices);
_vertexArray = _factory.Create <IVertexArray>();
_vertexArray.VertexBuffer = vertexBuffer;
_vertexArray.IndexBuffer = indexBuffer;
_objectShader = _factory.Create <IShader>();
_objectShader.Compile("Pretend.Graphics.Shaders.2DObject.glsl");
_objectShader.SetIntArray("textures[0]", Enumerable.Range(0, 32).ToArray());
_initialized = true;
}
public static void CopyVertices(this IVertexArray vertexArray,
Vertex[] vertices,
int startIndex = 0,
Transform transform = null)
{
for (int i = 0; i < vertexArray.Vertices.Length; i++)
{
vertices[startIndex + i] = vertexArray.Vertices[i];
// if a transform is given, transform the copied vertices with it
if (transform != null)
{
vertices[startIndex + i].Transform(transform);
}
}
}
public IVertexArray GetGlVao()
{
if (!dirty)
{
return(glVertexArray);
}
if (glVertexArray == null)
{
glVertexArray = infra.GlContext.Create.VertexArray();
}
glVertexArray.DisableVertexAttributesStartingFrom(0);
var indexOfPosition = vertexSet.ElementInfos.IndexOf(x => x.CommonSemantic == CommonVertexSemantic.Position);
var indexOfNormal = vertexSet.ElementInfos.IndexOf(x => x.CommonSemantic == CommonVertexSemantic.Normal);
var indexOfTexCoord = vertexSet.ElementInfos.IndexOf(x => x.CommonSemantic == CommonVertexSemantic.TexCoord);
if (indexOfPosition.HasValue)
{
SetVertexAttrF(0, indexOfPosition.Value, VertexAttributeDimension.Three, VertexAttribPointerType.Float);
}
if (indexOfNormal.HasValue)
{
SetVertexAttrF(1, indexOfNormal.Value, VertexAttributeDimension.Three, VertexAttribPointerType.Float);
}
if (indexOfTexCoord.HasValue)
{
SetVertexAttrF(2, indexOfTexCoord.Value, VertexAttributeDimension.Two, VertexAttribPointerType.Float);
}
if (vertexSet.IndicesInfo != null)
{
var arraySubrange = vertexSet.ArraySubranges[vertexSet.IndicesInfo.ArrayIndex];
var rawDataRes = arraySubrange.RawDataResource;
var arrayCache = rawDataRes.CacheContainer.GetOrAddCache(Tuples.Pair(infra, rawDataRes), x => new RawDataResCache(x.First, x.Second));
var glBuffer = arrayCache.GetGlIndexBuffer(arraySubrange.StartOffset);
glVertexArray.SetElementArrayBuffer(glBuffer);
}
else
{
glVertexArray.SetElementArrayBuffer(null);
}
dirty = false;
return(glVertexArray);
}
public override void Initialize()
{
var vertexData = new Vertex[MaxVertices];
vertexData[0] = Vertex.Cannon;
var vertexBufferSource = Context.Create.Buffer(BufferTarget.TransformFeedback, Vertex.SizeInBytes * MaxVertices, BufferUsageHint.StaticDraw, vertexData);
var vertexBufferTarget = Context.Create.Buffer(BufferTarget.TransformFeedback, Vertex.SizeInBytes * MaxVertices, BufferUsageHint.StaticDraw);
vertexArraySource = Context.Create.VertexArray();
vertexArraySource.SetVertexAttributeF(0, vertexBufferSource, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
vertexArraySource.SetVertexAttributeF(1, vertexBufferSource, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 2 * sizeof(float));
vertexArraySource.SetVertexAttributeF(2, vertexBufferSource, VertexAttributeDimension.One, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 4 * sizeof(float));
vertexArraySource.SetVertexAttributeI(3, vertexBufferSource, VertexAttributeDimension.One, VertexAttribIPointerType.Int, Vertex.SizeInBytes, 5 * sizeof(float));
vertexArraySource.SetVertexAttributeF(4, vertexBufferSource, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 6 * sizeof(float));
vertexArrayTarget = Context.Create.VertexArray();
vertexArrayTarget.SetVertexAttributeF(0, vertexBufferTarget, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
vertexArrayTarget.SetVertexAttributeF(1, vertexBufferTarget, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 2 * sizeof(float));
vertexArrayTarget.SetVertexAttributeF(2, vertexBufferTarget, VertexAttributeDimension.One, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 4 * sizeof(float));
vertexArrayTarget.SetVertexAttributeI(3, vertexBufferTarget, VertexAttributeDimension.One, VertexAttribIPointerType.Int, Vertex.SizeInBytes, 5 * sizeof(float));
vertexArrayTarget.SetVertexAttributeF(4, vertexBufferTarget, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 6 * sizeof(float));
transformFeedbackSource = Context.Create.TransformFeedback();
transformFeedbackSource.SetBuffer(0, vertexBufferSource);
transformFeedbackTarget = Context.Create.TransformFeedback();
transformFeedbackTarget.SetBuffer(0, vertexBufferTarget);
timeBuffer = Context.Create.Buffer(BufferTarget.Uniform, 2 * sizeof(float), BufferUsageHint.DynamicDraw);
IVertexShader vsh = Context.Create.VertexShader(VertexShaderText);
IGeometryShader gsh = Context.Create.GeometryShader(GeometryShaderText);
IFragmentShader fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
GeometryShaders = new[] { gsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_velocity", "in_timeToAction", "in_type", "in_color" },
TransformFeedbackAttributeNames = new[] { "g_position", "g_velocity", "g_timeToAction", "g_type", "g_color" },
TransformFeedbackMode = TransformFeedbackMode.InterleavedAttribs,
UniformBufferNames = new[] { "Time" }
});
}
public unsafe IVertexArray GetVao()
{
if (!isDirty && NumPoints == lastPointCount)
{
return(vao);
}
if (aspect.VisualBorderCurve == null || aspect.VisualBorderCurve.Count == 0)
{
return(null);
}
if (vao == null)
{
vao = glContext.Create.VertexArray();
}
var newPointCount = NumPoints;
if (vertexBuffer == null || bufferPointCapacity < newPointCount)
{
vertexBuffer?.Dispose();
while (bufferPointCapacity < newPointCount)
{
bufferPointCapacity *= 2;
}
vertexBuffer = glContext.Create.Buffer(BufferTarget.Array, bufferPointCapacity * sizeof(Vector4), BufferUsageHint.DynamicDraw);
vao.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, sizeof(Vector4), 0);
}
var rawData = aspect.BorderComplete
? aspect.VisualBorderCurve.Concat(aspect.VisualBorderCurve.First().EnumSelf()).Select(xy => new Vector4(xy, 0, 1)).ToArray()
: aspect.VisualBorderCurve.Select(xy => new Vector4(xy, 0, 1)).ToArray();
var sizeInBytes = rawData.Length * sizeof(Vector4);
var dst = vertexBuffer.Map(0, vertexBuffer.SizeInBytes, MapAccess.Write | MapAccess.InvalidateBuffer);
fixed(Vector4 *src = rawData)
PtrHelper.CopyBulk((byte *)dst, (byte *)src, sizeInBytes);
vertexBuffer.Unmap();
lastPointCount = newPointCount;
isDirty = false;
return(vao);
}
private void GenerateNormalsTriangle3f(IVertexArray positionArray, IVertexArray normalArray)
{
uint count = (ElementCount != 0 ? ElementCount : _VertexArrayObject.ArrayLength) / 3;
for (uint i = 0, v = ElementOffset; i < count; i++)
{
Vertex3f v0 = positionArray.GetElement <Vertex3f>(v++);
Vertex3f v1 = positionArray.GetElement <Vertex3f>(v++);
Vertex3f v2 = positionArray.GetElement <Vertex3f>(v++);
Vertex3f n = ((v2 - v0) ^ (v1 - v0)).Normalized;
normalArray.SetElement <Vertex3f>(n, v - 2);
normalArray.SetElement <Vertex3f>(n, v - 1);
normalArray.SetElement <Vertex3f>(n, v - 0);
}
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 4 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, -1f, 0f, 1f),
new Vertex(-1f, 1f, 0f, 0f),
new Vertex(1f, 1f, 1f, 0f),
new Vertex(1f, -1f, 1f, 1f),
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
using (var textureLoader = new TextureLoader("../Textures/Chess256.png"))
{
diffuseMap = Context.Create.Texture2D(textureLoader.Width, textureLoader.Height, TextureHelper.CalculateMipCount(textureLoader.Width, textureLoader.Height, 1), Format.Srgb8Alpha8);
for (int i = 0; i < diffuseMap.MipCount; i++)
{
diffuseMap.SetData(i, textureLoader.GetMipData(i), FormatColor.Rgba, FormatType.UnsignedByte);
}
}
sampler = Context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Linear);
sampler.SetMinFilter(TextureMinFilter.LinearMipmapLinear);
sampler.SetMaxAnisotropy(16f);
var vsh = Context.Create.VertexShader(VertexShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_tex_coord" },
SamplerNames = new[] { "DiffuseMap" }
});
}
public override void Initialize()
{
var vertexData = new Vertex[ParticleCount];
for (int i = 0; i < vertexData.Length; i++)
{
vertexData[i] = new Vertex(i * ParticleTicksDelta);
}
var vertexBufferSource = Context.Create.Buffer(BufferTarget.TransformFeedback, ParticleCount * Vertex.SizeInBytes, BufferUsageHint.StaticDraw, vertexData);
var vertexBufferTarget = Context.Create.Buffer(BufferTarget.TransformFeedback, ParticleCount * Vertex.SizeInBytes, BufferUsageHint.StaticDraw, IntPtr.Zero);
vertexArraySource = Context.Create.VertexArray();
vertexArraySource.SetVertexAttributeF(0, vertexBufferSource, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
vertexArraySource.SetVertexAttributeF(1, vertexBufferSource, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 2 * sizeof(float));
vertexArraySource.SetVertexAttributeF(2, vertexBufferSource, VertexAttributeDimension.One, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 4 * sizeof(float));
vertexArraySource.SetVertexAttributeF(3, vertexBufferSource, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 5 * sizeof(float));
vertexArraySource.SetVertexAttributeF(4, vertexBufferSource, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 7 * sizeof(float));
vertexArrayTarget = Context.Create.VertexArray();
vertexArrayTarget.SetVertexAttributeF(0, vertexBufferTarget, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 0);
vertexArrayTarget.SetVertexAttributeF(1, vertexBufferTarget, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 2 * sizeof(float));
vertexArrayTarget.SetVertexAttributeF(2, vertexBufferTarget, VertexAttributeDimension.One, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 4 * sizeof(float));
vertexArrayTarget.SetVertexAttributeF(3, vertexBufferTarget, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 5 * sizeof(float));
vertexArrayTarget.SetVertexAttributeF(4, vertexBufferTarget, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, Vertex.SizeInBytes, 7 * sizeof(float));
transformFeedbackSource = Context.Create.TransformFeedback();
transformFeedbackSource.SetBuffer(0, vertexBufferSource);
transformFeedbackTarget = Context.Create.TransformFeedback();
transformFeedbackTarget.SetBuffer(0, vertexBufferTarget);
var vsh = Context.Create.VertexShader(VertexShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_velocity", "in_spawn_cooldown", "in_initial_velocity", "in_color" },
TransformFeedbackAttributeNames = new[] { "v_position", "v_velocity", "v_spawn_cooldown", "v_initial_velocity", "v_color" },
TransformFeedbackMode = TransformFeedbackMode.InterleavedAttribs
});
}
private void Initialize()
{
var vertices = new[] {
new VertexPositionColor(new Vector3(-1, -1, 0), new Vector3(1, 0, 0)),
new VertexPositionColor(new Vector3(1, -1, 0), new Vector3(0, 1, 0)),
new VertexPositionColor(new Vector3(-1, 1, 0), new Vector3(0, 0, 1)),
new VertexPositionColor(new Vector3(1, 1, 0), new Vector3(1, 1, 1))
};
vao = vertices.ToVertexArray();
//vao = Factory<VertexPositionColor>.CreateVertexArray(vertices);
shader = Factory <VertexPositionColor> .CreateShaderProgram(
new VertexShaders.PositionColor(),
new FragmentShaders.Color());
shader.Begin();
vao.Begin();
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 4 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, -1f, 0f, 1f),
new Vertex(-1f, 1f, 0f, 0f),
new Vertex(1f, 1f, 1f, 0f),
new Vertex(1f, -1f, 1f, 1f),
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
pixelUnpackBuffer = Context.Create.Buffer(BufferTarget.PixelUnpack, 1024 * 1024 * 4, BufferUsageHint.StreamDraw);
data = Enumerable.Range(0, 1024 * 1024 * 4 * 2).Select(x => (byte)(128.0 + 128.0 * Math.Sin((2.0 / 3.0) * Math.PI * (x % 4) + (double)x / 4 / 11111))).ToArray();
diffuseMap = Context.Create.Texture2D(640, 360, 1, Format.Rgba8);
sampler = Context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Nearest);
sampler.SetMinFilter(TextureMinFilter.Nearest);
sampler.SetMaxAnisotropy(16f);
var vsh = Context.Create.VertexShader(VertexShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vsh },
FragmentShaders = new[] { fsh },
VertexAttributeNames = new[] { "in_position", "in_tex_coord" },
SamplerNames = new[] { "DiffuseMap" }
});
}
/// <summary>
/// Initializes the 2D rendering system
/// </summary>
internal static void Init()
{
ProfilerTimer.Profile(() =>
{
rendererData = new Renderer2DStorage
{
QuadVertexArray = IVertexArray.Create()
};
float[] squareVertices =
{
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f
};
IVertexBuffer squareVertexBuffer = IVertexBuffer.Create(squareVertices, squareVertices.GetBytes());
BufferLayout squareBufferLayout = new BufferLayout(new[]
{
new BufferElement("a_Position", ShaderDataType.Float3),
new BufferElement("a_TexCoord", ShaderDataType.Float2)
});
squareVertexBuffer.SetLayout(squareBufferLayout);
rendererData.QuadVertexArray.AddVertexBuffer(squareVertexBuffer);
uint[] squareIndices = { 0, 1, 2, 2, 3, 0 };
IIndexBuffer squareIndexBuffer =
IIndexBuffer.Create(squareIndices, squareIndices.GetBytes() / sizeof(uint));
rendererData.QuadVertexArray.SetIndexBuffer(squareIndexBuffer);
rendererData.WhiteTexture = I2DTexture.Create(1, 1);
uint whiteTextureData = 0xffffffff;
rendererData.WhiteTexture.SetData(whiteTextureData, sizeof(uint));
rendererData.TextureShader = IShader.Create("Shaders/Texture.glsl");
rendererData.TextureShader.Bind();
rendererData.TextureShader.SetInt("u_Texture", 0);
});
}
public SketchDrawer(IContext glContext, ISketchService sketchService)
{
this.glContext = glContext;
this.sketchService = sketchService;
#region Shader Text
const string vertexShaderText =
@"#version 150
in vec2 in_position;
void main()
{
gl_Position = vec4(in_position, 0.0, 1.0f);
}
";
const string fragmentShaderText =
@"#version 150
uniform samplerCube Texture;
out vec4 out_color;
void main()
{
out_color = vec4(1.0, 0.0, 1.0, 1.0);
}
";
#endregion
var vs = glContext.Create.VertexShader(vertexShaderText);
var fs = glContext.Create.FragmentShader(fragmentShaderText);
shaderProgram = glContext.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vs },
FragmentShaders = new[] { fs },
VertexAttributeNames = new[] { "in_position" }
});
vao = glContext.Create.VertexArray();
}
/// <summary>
/// Set an array buffer object collected by this vertex array object.
/// </summary>
/// <param name="vertexArray">
/// The <see cref="VertexArray"/> that defined the vertex attribute buffer.
/// </param>
/// <param name="attributeName">
/// A <see cref="String"/> that specify the attribute name.
/// </param>
/// <param name="blockName">
/// A <see cref="String"/> that specify the attribute block declaring <paramref name="attributeName"/>.
/// </param>
internal void SetVertexArray(IVertexArray vertexArray, string attributeName, string blockName)
{
if (vertexArray == null)
{
throw new ArgumentNullException("vertexArray");
}
if (String.IsNullOrEmpty(attributeName))
{
throw new ArgumentException("invalid name", "attributeName");
}
IVertexArray previousVertexArray;
// Dispose previous vertex array
if (_VertexArrays.TryGetValue(attributeName, out previousVertexArray))
{
previousVertexArray.Dispose();
}
// Map buffer object with attribute name
_VertexArrays[attributeName] = vertexArray;
// Map buffer object with input name including block name also
if (blockName != null)
{
// Attribute referenced in block
attributeName = String.Format("{0}.{1}", blockName, attributeName);
// Dispose previous vertex array
if (_VertexArrays.TryGetValue(attributeName, out previousVertexArray))
{
previousVertexArray.Dispose();
}
// Map buffer object with attribute name
_VertexArrays[attributeName] = vertexArray;
}
// Update vertex arrays
_VertexArrayDirty = true;
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 4 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, -1f, 0f, 1f),
new Vertex(-1f, 1f, 0f, 0f),
new Vertex(1f, 1f, 1f, 0f),
new Vertex(1f, -1f, 1f, 1f),
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
pixelUnpackBuffer = Context.Create.Buffer(BufferTarget.PixelUnpack, 1024 * 1024 * 4, BufferUsageHint.StreamDraw);
data = Enumerable.Range(0, 1024 * 1024 * 4 * 2).Select(x => (byte)(128.0 + 128.0 * Math.Sin((2.0 / 3.0) * Math.PI * (x % 4) + (double)x / 4 / 11111))).ToArray();
diffuseMap = Context.Create.Texture2D(640, 360, 1, Format.Rgba8);
sampler = Context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Nearest);
sampler.SetMinFilter(TextureMinFilter.Nearest);
sampler.SetMaxAnisotropy(16f);
var vsh = Context.Create.VertexShader(VertexShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] {vsh},
FragmentShaders = new[] {fsh},
VertexAttributeNames = new[] {"in_position", "in_tex_coord"},
SamplerNames = new[] {"DiffuseMap"}
});
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 4 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, -1f, 0f, 1f),
new Vertex(-1f, 1f, 0f, 0f),
new Vertex(1f, 1f, 1f, 0f),
new Vertex(1f, -1f, 1f, 1f),
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
using (var textureLoader = new TextureLoader("../Textures/Chess256.png"))
{
diffuseMap = Context.Create.Texture2D(textureLoader.Width, textureLoader.Height, TextureHelper.CalculateMipCount(textureLoader.Width, textureLoader.Height, 1), Format.Srgb8Alpha8);
for (int i = 0; i < diffuseMap.MipCount; i++)
diffuseMap.SetData(i, textureLoader.GetMipData(i), FormatColor.Rgba, FormatType.UnsignedByte);
}
sampler = Context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Linear);
sampler.SetMinFilter(TextureMinFilter.LinearMipmapLinear);
sampler.SetMaxAnisotropy(16f);
var vsh = Context.Create.VertexShader(VertexShaderText);
var fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] {vsh},
FragmentShaders = new[] {fsh},
VertexAttributeNames = new[] {"in_position", "in_tex_coord"},
SamplerNames = new[] {"DiffuseMap"}
});
}
public Cube(IOpenGL30 gl)
{
Model = Matrix4f.Identity;
View = Matrix4f.Identity;
Projection = Matrix4f.Identity;
this.gl = gl;
shader = new CubeShader(gl);
vertexBuffer = CreateBuffer();
vertexArray = new VertexArray(gl, new [] { vertexBuffer }, new [] { Vertex.Descriptor });
}
public override void Initialize()
{
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 3 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex { Position = new Vector4(-0.5f, -0.5f, 0f, 1f), Color = new Color4(1, 0, 0, 1)},
new Vertex { Position = new Vector4(0.0f, 0.5f, 0f, 1f), Color = new Color4(0, 1, 0, 1)},
new Vertex { Position = new Vector4(0.5f, -0.5f, 0f, 1f), Color = new Color4(1, 1, 0, 1)}
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 3 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[] { 0, 1, 2 });
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, 32, 16);
IVertexShader vsh = Context.Create.VertexShader(VertexShaderText);
IFragmentShader fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] {vsh},
FragmentShaders = new[] {fsh},
VertexAttributeNames = new[] {"in_position", "in_color"}
});
}
public CursorRenderer(IClientSettings settings, IContext context, ITextureLoader textureLoader)
{
var header = settings.IsEs ? EsHeader : DesktopHeader;
var vertexShader = context.Create.VertexShader(header + VertexShaderText);
var fragmentShader = context.Create.FragmentShader(header + FragmentShaderText);
program = context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] { vertexShader },
FragmentShaders = new[] { fragmentShader },
VertexAttributeNames = new[] { "in_position", "in_tex_coord" },
SamplerNames = new[] { "DiffTexture" }
});
var vertexBuffer = context.Create.Buffer(BufferTarget.ArrayBuffer, 4 * Vertex.Size, BufferUsageHint.StaticDraw, new[]
{
new Vertex(-1f, 1f, 0f, 0f),
new Vertex(1f, 1f, 1f, 0f),
new Vertex(1f, -1f, 1f, 1f),
new Vertex(-1f, -1f, 0f, 1f)
});
var indexBuffer = context.Create.Buffer(BufferTarget.ElementArrayBuffer, 6 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3
});
vertexArray = context.Create.VertexArray();
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.Size, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, Vertex.Size, 2 * sizeof(float));
vertexArray.SetElementArrayBuffer(indexBuffer);
texture = textureLoader.LoadTexture(context, "Cursor.png");
sampler = context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Nearest);
}
public override void Initialize()
{
renderTarget = Context.Create.Texture2D(RenderTargetSize, RenderTargetSize, TextureHelper.CalculateMipCount(RenderTargetSize, 1, 1), Format.Rgba8);
depthStencil = Context.Create.Renderbuffer(RenderTargetSize, RenderTargetSize, Format.Depth24Stencil8);
framebuffer = Context.Create.Framebuffer();
framebuffer.AttachTextureImage(FramebufferAttachmentPoint.Color0, renderTarget, 0);
framebuffer.AttachRenderbuffer(FramebufferAttachmentPoint.DepthStencil, depthStencil);
var vertexBuffer = Context.Create.Buffer(BufferTarget.Array, 24 * 8 * sizeof(float), BufferUsageHint.StaticDraw, new[]
{
new Vertex(1f, -1f, 1f, 1f, 0f, 0f, 0f, 0f),
new Vertex(1f, 1f, 1f, 1f, 0f, 0f, 1f, 0f),
new Vertex(1f, 1f, -1f, 1f, 0f, 0f, 1f, 1f),
new Vertex(1f, -1f, -1f, 1f, 0f, 0f, 0f, 1f),
new Vertex(1f, 1f, 1f, 0f, 1f, 0f, 0f, 0f),
new Vertex(-1f, 1f, 1f, 0f, 1f, 0f, 1f, 0f),
new Vertex(-1f, 1f, -1f, 0f, 1f, 0f, 1f, 1f),
new Vertex(1f, 1f, -1f, 0f, 1f, 0f, 0f, 1f),
new Vertex(-1f, 1f, 1f, -1f, 0f, 0f, 0f, 0f),
new Vertex(-1f, -1f, 1f, -1f, 0f, 0f, 1f, 0f),
new Vertex(-1f, -1f, -1f, -1f, 0f, 0f, 1f, 1f),
new Vertex(-1f, 1f, -1f, -1f, 0f, 0f, 0f, 1f),
new Vertex(-1f, -1f, 1f, 0f, -1f, 0f, 0f, 0f),
new Vertex(1f, -1f, 1f, 0f, -1f, 0f, 1f, 0f),
new Vertex(1f, -1f, -1f, 0f, -1f, 0f, 1f, 1f),
new Vertex(-1f, -1f, -1f, 0f, -1f, 0f, 0f, 1f),
new Vertex(-1f, -1f, 1f, 0f, 0f, 1f, 0f, 0f),
new Vertex(-1f, 1f, 1f, 0f, 0f, 1f, 1f, 0f),
new Vertex(1f, 1f, 1f, 0f, 0f, 1f, 1f, 1f),
new Vertex(1f, -1f, 1f, 0f, 0f, 1f, 0f, 1f),
new Vertex(-1f, 1f, -1f, 0f, 0f, -1f, 0f, 0f),
new Vertex(-1f, -1f, -1f, 0f, 0f, -1f, 1f, 0f),
new Vertex(1f, -1f, -1f, 0f, 0f, -1f, 1f, 1f),
new Vertex(1f, 1f, -1f, 0f, 0f, -1f, 0f, 1f)
});
var indexBuffer = Context.Create.Buffer(BufferTarget.ElementArray, 36 * sizeof(ushort), BufferUsageHint.StaticDraw, new ushort[]
{
0, 1, 2, 0, 2, 3,
4, 5, 6, 4, 6, 7,
8, 9, 10, 8, 10, 11,
12, 13, 14, 12, 14, 15,
16, 17, 18, 16, 18, 19,
20, 21, 22, 20, 22, 23
});
vertexArray = Context.Create.VertexArray();
vertexArray.SetElementArrayBuffer(indexBuffer);
vertexArray.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, 32, 0);
vertexArray.SetVertexAttributeF(1, vertexBuffer, VertexAttributeDimension.Three, VertexAttribPointerType.Float, false, 32, 12);
vertexArray.SetVertexAttributeF(2, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, 32, 24);
transformBuffer = Context.Create.Buffer(BufferTarget.Uniform, 64, BufferUsageHint.DynamicDraw);
cameraBuffer = Context.Create.Buffer(BufferTarget.Uniform, 64, BufferUsageHint.DynamicDraw);
#if INTEL_WORKAROUND
cameraOutsideBuffer = Context.Create.Buffer(BufferTarget.Uniform, 64, BufferUsageHint.DynamicDraw);
#endif
cameraExtraBuffer = Context.Create.Buffer(BufferTarget.Uniform, 12, BufferUsageHint.DynamicDraw);
lightBuffer = Context.Create.Buffer(BufferTarget.Uniform, 12, BufferUsageHint.DynamicDraw);
using (var textureLoader = new TextureLoader("../Textures/DiffuseTest.png"))
{
diffuseMap = Context.Create.Texture2D(textureLoader.Width, textureLoader.Height, TextureHelper.CalculateMipCount(textureLoader.Width, textureLoader.Height, 1), Format.Rgba8);
for (int i = 0; i < diffuseMap.MipCount; i++)
diffuseMap.SetData(i, textureLoader.GetMipData(i), FormatColor.Rgba, FormatType.UnsignedByte);
}
sampler = Context.Create.Sampler();
sampler.SetMagFilter(TextureMagFilter.Linear);
sampler.SetMinFilter(TextureMinFilter.LinearMipmapLinear);
sampler.SetMaxAnisotropy(16f);
IVertexShader vsh = Context.Create.VertexShader(VertexShaderText);
IFragmentShader fsh = Context.Create.FragmentShader(FragmentShaderText);
program = Context.Create.Program(new ShaderProgramDescription
{
VertexShaders = new[] {vsh},
FragmentShaders = new[] {fsh},
VertexAttributeNames = new[] {"in_position", "in_normal", "in_tex_coord"},
UniformBufferNames = new[] {"Transform", "Camera", "Light"},
SamplerNames = new[] {"DiffuseMap"}
});
}
