public void RenderPointWithStencil()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (Texture2D depthStencilTexture = Device.CreateTexture2D(new Texture2DDescription(1, 1, TextureFormat.Depth24Stencil8, false)))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), ShaderSources.PassThroughFragmentShader()))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
framebuffer.DepthStencilAttachment = depthStencilTexture;
StencilTest stencilTest = new StencilTest();
stencilTest.Enabled = true;
stencilTest.FrontFace.DepthFailStencilPassOperation = StencilOperation.Replace;
stencilTest.FrontFace.DepthPassStencilPassOperation = StencilOperation.Replace;
stencilTest.FrontFace.StencilFailOperation = StencilOperation.Replace;
stencilTest.FrontFace.ReferenceValue = 2;
RenderState renderState = new RenderState();
renderState.StencilTest = stencilTest;
window.Context.Framebuffer = framebuffer;
window.Context.Clear(new ClearState());
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(renderState, sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0);
using (ReadPixelBuffer readPixelBuffer = depthStencilTexture.CopyToBuffer(ImageFormat.DepthStencil, ImageDatatype.UnsignedInt248, 1))
{
byte[] depthStencil = readPixelBuffer.CopyToSystemMemory <byte>();
Assert.AreEqual(stencilTest.FrontFace.ReferenceValue, depthStencil[0]);
}
}
}
public void LinkAutomaticUniforms()
{
string fs =
@"#version 330
uniform sampler2D og_texture0;
uniform sampler2D og_texture1;
uniform sampler2D og_texture2;
uniform sampler2D og_texture3;
out vec4 FragColor;
void main()
{
FragColor =
texture(og_texture0, vec2(0, 0)) +
texture(og_texture1, vec2(0, 0)) +
texture(og_texture2, vec2(0, 0)) +
texture(og_texture3, vec2(0, 0));
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
{
Assert.AreEqual(0, ((Uniform <int>)sp.Uniforms["og_texture0"]).Value);
Assert.AreEqual(1, ((Uniform <int>)sp.Uniforms["og_texture1"]).Value);
Assert.AreEqual(2, ((Uniform <int>)sp.Uniforms["og_texture2"]).Value);
Assert.AreEqual(3, ((Uniform <int>)sp.Uniforms["og_texture3"]).Value);
}
}
public void UniformBuffer()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (ShaderProgram sp = Device.CreateShaderProgram(
ShaderSources.PassThroughVertexShader(),
ShaderSources.RedUniformBlockFragmentShader()))
using (UniformBuffer uniformBuffer = Device.CreateUniformBuffer(BufferHint.DynamicDraw, sp.UniformBlocks["RedBlock"].SizeInBytes))
{
Assert.IsFalse(sp.Log.Contains("warning"));
UniformBlock redBlock = sp.UniformBlocks["RedBlock"];
UniformBlockMember red = redBlock.Members["red"];
//
// Verify creating uniform buffer
//
Assert.IsNotNull(uniformBuffer);
Assert.AreEqual(BufferHint.DynamicDraw, uniformBuffer.UsageHint);
Assert.AreEqual(redBlock.SizeInBytes, uniformBuffer.SizeInBytes);
redBlock.Bind(uniformBuffer);
//
// Verify copying into red member
//
float redIntensity = 0.5f;
uniformBuffer.CopyFromSystemMemory(new[] { redIntensity }, red.OffsetInBytes);
float[] redIntensity2 = uniformBuffer.CopyToSystemMemory <float>(red.OffsetInBytes, sizeof(float));
Assert.AreEqual(redIntensity, redIntensity2[0]);
}
}
public void Matrix32()
{
string fs =
@"#version 330
uniform mat3x2 exampleMat32;
out vec3 FragColor;
void main()
{
FragColor = vec3(exampleMat32[1].x, exampleMat32[2].x, 0.0);
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
Matrix32 <float> m32 = new Matrix32 <float>(
0.0f, 1.0f, 1.0f,
0.0f, 0.0f, 0.0f);
Uniform <Matrix32 <float> > exampleMat32 = (Uniform <Matrix32 <float> >)sp.Uniforms["exampleMat32"];
Assert.AreEqual("exampleMat32", exampleMat32.Name);
Assert.AreEqual(UniformType.FloatMatrix32, exampleMat32.Datatype);
Assert.AreEqual(new Matrix32 <float>(), exampleMat32.Value);
exampleMat32.Value = m32;
Assert.AreEqual(m32, exampleMat32.Value);
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 255, 0);
}
}
public void RenderPointMultipleColorAttachments()
{
Texture2DDescription description = new Texture2DDescription(1, 1, TextureFormat.RedGreenBlue8, false);
string fs =
@"#version 330
out vec3 RedColor;
out vec3 GreenColor;
void main()
{
RedColor = vec3(1.0, 0.0, 0.0);
GreenColor = vec3(0.0, 1.0, 0.0);
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = window.Context.CreateFramebuffer())
using (Texture2D redTexture = Device.CreateTexture2D(description))
using (Texture2D greenTexture = Device.CreateTexture2D(description))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
Assert.AreNotEqual(sp.FragmentOutputs["RedColor"], sp.FragmentOutputs["GreenColor"]);
framebuffer.ColorAttachments[sp.FragmentOutputs["RedColor"]] = redTexture;
framebuffer.ColorAttachments[sp.FragmentOutputs["GreenColor"]] = greenTexture;
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(redTexture, 255, 0, 0);
TestUtility.ValidateColor(greenTexture, 0, 255, 0);
}
}
public void RenderTexturedPoint()
{
string fs =
@"#version 330
uniform sampler2D textureUnit;
out vec4 FragColor;
void main()
{
FragColor = texture(textureUnit, vec2(0, 0));
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
using (Texture2D texture = TestUtility.CreateTexture(new BlittableRGBA(Color.FromArgb(0, 255, 0, 0))))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
Uniform <int> textureUniform = (Uniform <int>)sp.Uniforms["textureUnit"];
textureUniform.Value = 0;
window.Context.TextureUnits[0].Texture = texture;
window.Context.TextureUnits[0].TextureSampler = Device.TextureSamplers.NearestClamp;
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0);
}
}
public void RenderTriangle()
{
Vector4F[] positions = new[]
{
new Vector4F(-0.5f, -0.5f, 0, 1),
new Vector4F(0.5f, -0.5f, 0, 1),
new Vector4F(0.5f, 0.5f, 0, 1)
};
ushort[] indices = new ushort[]
{
0, 1, 2
};
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), ShaderSources.PassThroughFragmentShader()))
using (VertexBuffer positionsBuffer = Device.CreateVertexBuffer(BufferHint.StaticDraw, ArraySizeInBytes.Size(positions)))
using (IndexBuffer indexBuffer = Device.CreateIndexBuffer(BufferHint.StaticDraw, indices.Length * sizeof(ushort)))
using (VertexArray va = window.Context.CreateVertexArray())
{
positionsBuffer.CopyFromSystemMemory(positions);
indexBuffer.CopyFromSystemMemory(indices);
va.Attributes[sp.VertexAttributes["position"].Location] =
new VertexBufferAttribute(positionsBuffer, ComponentDatatype.Float, 4);
va.IndexBuffer = indexBuffer;
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Triangles, 0, 3, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0);
//
// Verify detach
//
window.Context.Clear(new ClearState()
{
Buffers = ClearBuffers.ColorBuffer, Color = Color.FromArgb(0, 255, 0)
});
va.Attributes[sp.VertexAttributes["position"].Location] = null;
va.IndexBuffer = null;
window.Context.Draw(PrimitiveType.Triangles, 0, 0, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 0, 255, 0);
//
// Verify rendering without indices
//
va.Attributes[sp.VertexAttributes["position"].Location] =
new VertexBufferAttribute(positionsBuffer, ComponentDatatype.Float, 4);
window.Context.Draw(PrimitiveType.Triangles, 0, 3, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0);
}
}
public void RenderPoint()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), ShaderSources.PassThroughFragmentShader()))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 0, 0);
}
}
public void Find()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
{
ShaderCache cache = new ShaderCache();
ShaderProgram sp = cache.FindOrAdd("PassThrough",
ShaderSources.PassThroughVertexShader(),
ShaderSources.PassThroughFragmentShader());
ShaderProgram sp2 = cache.Find("PassThrough");
Assert.AreEqual(sp, sp2);
cache.Release("PassThrough");
cache.Release("PassThrough");
}
}
public void RenderMultitexturedPoint()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (Framebuffer framebuffer = TestUtility.CreateFramebuffer(window.Context))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), ShaderSources.MultitextureFragmentShader()))
using (Texture2D texture0 = TestUtility.CreateTexture(new BlittableRGBA(Color.FromArgb(0, 255, 0, 0))))
using (Texture2D texture1 = TestUtility.CreateTexture(new BlittableRGBA(Color.FromArgb(0, 0, 255, 0))))
using (VertexArray va = TestUtility.CreateVertexArray(window.Context, sp.VertexAttributes["position"].Location))
{
window.Context.TextureUnits[0].Texture = texture0;
window.Context.TextureUnits[0].TextureSampler = Device.TextureSamplers.NearestClamp;
window.Context.TextureUnits[1].Texture = texture1;
window.Context.TextureUnits[1].TextureSampler = Device.TextureSamplers.NearestClamp;
window.Context.Framebuffer = framebuffer;
window.Context.Draw(PrimitiveType.Points, 0, 1, new DrawState(TestUtility.CreateRenderStateWithoutDepthTest(), sp, va), new SceneState());
TestUtility.ValidateColor(framebuffer.ColorAttachments[0], 255, 255, 0);
}
}
public void PassThrough()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (ShaderProgram sp = Device.CreateShaderProgram(
ShaderSources.PassThroughVertexShader(),
ShaderSources.PassThroughFragmentShader()))
{
Assert.IsFalse(sp.Log.Contains("warning"));
Assert.IsEmpty(sp.Uniforms);
Assert.IsEmpty(sp.UniformBlocks);
Assert.AreEqual(1, sp.VertexAttributes.Count);
Assert.IsTrue(sp.VertexAttributes.Contains("position"));
ShaderVertexAttribute attribute = sp.VertexAttributes["position"];
Assert.AreEqual("position", attribute.Name);
Assert.AreEqual(ShaderVertexAttributeType.FloatVector4, attribute.Datatype);
Assert.AreEqual(1, attribute.Length);
}
}
public void UniformBlock()
{
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (ShaderProgram sp = Device.CreateShaderProgram(
ShaderSources.PassThroughVertexShader(),
ShaderSources.RedUniformBlockFragmentShader()))
{
Assert.IsFalse(sp.Log.Contains("warning"));
Assert.IsEmpty(sp.Uniforms);
Assert.AreEqual(1, sp.UniformBlocks.Count);
UniformBlock redBlock = sp.UniformBlocks["RedBlock"];
Assert.AreEqual("RedBlock", redBlock.Name);
Assert.GreaterOrEqual(redBlock.SizeInBytes, 4);
Assert.AreEqual(1, redBlock.Members.Count);
UniformBlockMember red = redBlock.Members["red"];
Assert.AreEqual("red", red.Name);
Assert.AreEqual(0, red.OffsetInBytes);
Assert.AreEqual(UniformType.Float, red.Datatype);
}
}
public void DefaultUniformBlock()
{
//
// Uniform initializers are not supported because there may be some driver bugs:
//
// http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Main=48817&Number=250791#Post250791
// http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Main=51624&Number=266719#Post266719
// http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Main=52018&Number=268866#Post268866
//
string fs =
@"#version 330
#extension GL_EXT_gpu_shader4 : enable // for texture1DArray
uniform float exampleFloat;
uniform vec2 exampleVec2;
uniform vec3 exampleVec3;
uniform vec4 exampleVec4;
uniform int exampleInt;
uniform ivec2 exampleIVec2;
uniform ivec3 exampleIVec3;
uniform ivec4 exampleIVec4;
uniform bool exampleBool;
uniform bvec2 exampleBVec2;
uniform bvec3 exampleBVec3;
uniform bvec4 exampleBVec4;
uniform sampler2D exampleSampler2D;
uniform sampler2DRect exampleSampler2DRect;
uniform sampler1DArray exampleSampler1DArray;
out vec4 FragColor;
void main()
{
float red = 0;
red += exampleFloat;
red += exampleVec2.x;
red += exampleVec3.x;
red += exampleVec4.x;
red += float(exampleInt);
red += float(exampleIVec2.x);
red += float(exampleIVec3.x);
red += float(exampleIVec4.x);
red += float(exampleBool);
red += float(exampleBVec2.x);
red += float(exampleBVec3.x);
red += float(exampleBVec4.x);
red += texture(exampleSampler2D, vec2(0, 0)).r;
red += texture(exampleSampler2DRect, vec2(0, 0)).r;
red += texture1DArray(exampleSampler1DArray, vec2(0, 0)).r;
FragColor = vec4(red, 0, 0, 1);
}";
using (GraphicsWindow window = Device.CreateWindow(1, 1))
using (ShaderProgram sp = Device.CreateShaderProgram(ShaderSources.PassThroughVertexShader(), fs))
{
Assert.IsFalse(sp.Log.Contains("warning"));
Assert.IsEmpty(sp.UniformBlocks);
Assert.AreEqual(15, sp.Uniforms.Count);
Uniform <float> exampleFloat = (Uniform <float>)sp.Uniforms["exampleFloat"];
Assert.AreEqual("exampleFloat", exampleFloat.Name);
Assert.AreEqual(UniformType.Float, exampleFloat.Datatype);
Assert.AreEqual(0, exampleFloat.Value);
exampleFloat.Value = 0.75f;
Assert.AreEqual(0.75f, exampleFloat.Value);
Uniform <Vector2F> exampleVec2 = (Uniform <Vector2F>)sp.Uniforms["exampleVec2"];
Assert.AreEqual("exampleVec2", exampleVec2.Name);
Assert.AreEqual(UniformType.FloatVector2, exampleVec2.Datatype);
Assert.AreEqual(new Vector2F(), exampleVec2.Value);
exampleVec2.Value = new Vector2F(1, 0.5f);
Assert.AreEqual(new Vector2F(1, 0.5f), exampleVec2.Value);
Uniform <Vector3F> exampleVec3 = (Uniform <Vector3F>)sp.Uniforms["exampleVec3"];
Assert.AreEqual("exampleVec3", exampleVec3.Name);
Assert.AreEqual(UniformType.FloatVector3, exampleVec3.Datatype);
Assert.AreEqual(new Vector3F(), exampleVec3.Value);
exampleVec3.Value = new Vector3F(1, 0, 0);
Assert.AreEqual(new Vector3F(1, 0, 0), exampleVec3.Value);
Uniform <Vector4F> exampleVec4 = (Uniform <Vector4F>)sp.Uniforms["exampleVec4"];
Assert.AreEqual("exampleVec4", exampleVec4.Name);
Assert.AreEqual(UniformType.FloatVector4, exampleVec4.Datatype);
Assert.AreEqual(new Vector4F(), exampleVec4.Value);
exampleVec4.Value = new Vector4F(1, 0, 0, 0);
Assert.AreEqual(new Vector4F(1, 0, 0, 0), exampleVec4.Value);
///////////////////////////////////////////////////////////////
Uniform <int> exampleInt = (Uniform <int>)sp.Uniforms["exampleInt"];
Assert.AreEqual("exampleInt", exampleInt.Name);
Assert.AreEqual(UniformType.Int, exampleInt.Datatype);
Assert.AreEqual(0, exampleInt.Value);
exampleInt.Value = 1;
Assert.AreEqual(1, exampleInt.Value);
Uniform <Vector2I> exampleIVec2 = (Uniform <Vector2I>)sp.Uniforms["exampleIVec2"];
Assert.AreEqual("exampleIVec2", exampleIVec2.Name);
Assert.AreEqual(UniformType.IntVector2, exampleIVec2.Datatype);
Assert.AreEqual(new Vector2I(), exampleIVec2.Value);
exampleIVec2.Value = new Vector2I(1, 0);
Assert.AreEqual(new Vector2I(1, 0), exampleIVec2.Value);
Uniform <Vector3I> exampleIVec3 = (Uniform <Vector3I>)sp.Uniforms["exampleIVec3"];
Assert.AreEqual("exampleIVec3", exampleIVec3.Name);
Assert.AreEqual(UniformType.IntVector3, exampleIVec3.Datatype);
Assert.AreEqual(new Vector3I(), exampleIVec3.Value);
exampleIVec3.Value = new Vector3I(1, 0, 0);
Assert.AreEqual(new Vector3I(1, 0, 0), exampleIVec3.Value);
Uniform <Vector4I> exampleIVec4 = (Uniform <Vector4I>)sp.Uniforms["exampleIVec4"];
Assert.AreEqual("exampleIVec4", exampleIVec4.Name);
Assert.AreEqual(UniformType.IntVector4, exampleIVec4.Datatype);
Assert.AreEqual(new Vector4I(), exampleIVec4.Value);
exampleIVec4.Value = new Vector4I(1, 0, 0, 0);
Assert.AreEqual(new Vector4I(1, 0, 0, 0), exampleIVec4.Value);
///////////////////////////////////////////////////////////////
Uniform <bool> exampleBool = (Uniform <bool>)sp.Uniforms["exampleBool"];
Assert.AreEqual("exampleBool", exampleBool.Name);
Assert.AreEqual(UniformType.Bool, exampleBool.Datatype);
Assert.AreEqual(false, exampleBool.Value);
exampleBool.Value = true;
Assert.AreEqual(true, exampleBool.Value);
Uniform <Vector2B> exampleBVec2 = (Uniform <Vector2B>)sp.Uniforms["exampleBVec2"];
Assert.AreEqual("exampleBVec2", exampleBVec2.Name);
Assert.AreEqual(UniformType.BoolVector2, exampleBVec2.Datatype);
Assert.AreEqual(new Vector2B(), exampleBVec2.Value);
exampleBVec2.Value = new Vector2B(true, false);
Assert.AreEqual(new Vector2B(true, false), exampleBVec2.Value);
Uniform <Vector3B> exampleBVec3 = (Uniform <Vector3B>)sp.Uniforms["exampleBVec3"];
Assert.AreEqual("exampleBVec3", exampleBVec3.Name);
Assert.AreEqual(UniformType.BoolVector3, exampleBVec3.Datatype);
Assert.AreEqual(new Vector3B(), exampleBVec3.Value);
exampleBVec3.Value = new Vector3B(true, false, false);
Assert.AreEqual(new Vector3B(true, false, false), exampleBVec3.Value);
Uniform <Vector4B> exampleBVec4 = (Uniform <Vector4B>)sp.Uniforms["exampleBVec4"];
Assert.AreEqual("exampleBVec4", exampleBVec4.Name);
Assert.AreEqual(UniformType.BoolVector4, exampleBVec4.Datatype);
Assert.AreEqual(new Vector4B(), exampleBVec4.Value);
exampleBVec4.Value = new Vector4B(true, false, false, false);
Assert.AreEqual(new Vector4B(true, false, false, false), exampleBVec4.Value);
///////////////////////////////////////////////////////////////
Uniform <int> exampleSampler2D = (Uniform <int>)sp.Uniforms["exampleSampler2D"];
Assert.AreEqual("exampleSampler2D", exampleSampler2D.Name);
Assert.AreEqual(UniformType.Sampler2D, exampleSampler2D.Datatype);
Assert.AreEqual(0, exampleSampler2D.Value);
exampleSampler2D.Value = 1;
Assert.AreEqual(1, exampleSampler2D.Value);
Uniform <int> exampleSampler2DRect = (Uniform <int>)sp.Uniforms["exampleSampler2DRect"];
Assert.AreEqual("exampleSampler2DRect", exampleSampler2DRect.Name);
Assert.AreEqual(UniformType.Sampler2DRectangle, exampleSampler2DRect.Datatype);
Assert.AreEqual(0, exampleSampler2DRect.Value);
exampleSampler2DRect.Value = 1;
Assert.AreEqual(1, exampleSampler2DRect.Value);
Uniform <int> exampleSampler1DArray = (Uniform <int>)sp.Uniforms["exampleSampler1DArray"];
Assert.AreEqual("exampleSampler1DArray", exampleSampler1DArray.Name);
Assert.AreEqual(UniformType.Sampler1DArray, exampleSampler1DArray.Datatype);
Assert.AreEqual(0, exampleSampler1DArray.Value);
exampleSampler1DArray.Value = 1;
Assert.AreEqual(1, exampleSampler1DArray.Value);
}
}
