private static List <BufferObject> CreateBuffers(Gltf gltf)
{
var glBuffers = new List <BufferObject>();
var byteBuffers = new List <byte[]>();
foreach (var buffer in gltf.Buffers)
{
byteBuffers.Add(ReadBuffer(buffer));
}
foreach (var bufferView in gltf.BufferViews)
{
if (bufferView.Target.HasValue)
{
var bufferGL = new BufferObject((BufferTarget)bufferView.Target);
var pinnedArray = GCHandle.Alloc(byteBuffers[bufferView.Buffer], GCHandleType.Pinned);
var intPtr = pinnedArray.AddrOfPinnedObject() + bufferView.ByteOffset;
bufferGL.Set(intPtr, bufferView.ByteLength, BufferUsageHint.StaticDraw);
pinnedArray.Free();
glBuffers.Add(bufferGL);
}
else
{
glBuffers.Add(null);
}
}
return(glBuffers);
}
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidBox(
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
BufferObject<Matrix4> sprite_rotation_local_buffer,
BufferObject<Matrix4> sprite_rotation_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
IValueProvider<string> fragdepthroutine,
ModelViewProjectionParameters mvp
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var outputroutine = ValueProvider.Create (() => "SetOutputsNone");
return CreateSolidBox
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer, sprite_rotation_local_buffer, sprite_rotation_buffer,
viewport,
particles_count, particle_scale_factor, fragdepthroutine, outputroutine,
mvp,
null,
null
);
}
/*
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidSphere
(
TextureBase normal_depth_target,
TextureBase uv_colorindex_target,
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
ModelViewProjectionParameters mvp,
UniformState subroutineMapping,
IEnumerable<Shader> subroutines
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var mode = ValueProvider.Create (() => 0);
return CreateSolidSphere
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture },
new DrawFramebufferBinding { VariableName = "Fragdata.uv_colorindex_none", Texture = uv_colorindex_target },
new DrawFramebufferBinding { VariableName = "Fragdata.normal_depth", Texture = normal_depth_target }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer,
viewport,
particles_count, particle_scale_factor, mode,
mvp,
subroutineMapping,
subroutines
);
}*/
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidSphere(
TextureBase normal_depth_target,
TextureBase uv_colorindex_target,
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
ModelViewProjectionParameters mvp
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var fragdepthroutine = ValueProvider.Create (() => "FragDepthDefault");
var outputroutine = ValueProvider.Create (() => "SetOutputsDefault");
return CreateSolidSphere
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture },
new DrawFramebufferBinding { VariableName = "uv_colorindex_none", Texture = uv_colorindex_target },
new DrawFramebufferBinding { VariableName = "normal_depth", Texture = normal_depth_target }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer,
viewport,
particles_count, particle_scale_factor, fragdepthroutine, outputroutine,
mvp,
null,
null
);
}
/// <summary>
/// Create a <see cref="ArrayBufferObjectBase"/> for testing.
/// </summary>
/// <returns>
/// It returns the <see cref="ArrayBufferObjectBase"/> instance to test.
/// </returns>
private void CreateGpuInstance(BufferObject buffer)
{
if (buffer.GetType() == typeof(ArrayBufferObject))
{
ArrayBufferObject arrayBufferObject = (ArrayBufferObject)buffer;
arrayBufferObject.Create(_Context, CreateTestArray());
}
else if (buffer.GetType() == typeof(ElementBufferObject))
{
ElementBufferObject elementBufferObject = (ElementBufferObject)buffer;
elementBufferObject.Create(_Context, CreateTestArray());
}
else if (buffer.GetType() == typeof(ArrayBufferObjectInterleaved))
{
ArrayBufferObjectInterleaved arrayBufferObjectInterleaved = (ArrayBufferObjectInterleaved)buffer;
arrayBufferObjectInterleaved.Create(_Context, CreateTestArray());
}
else if (buffer.GetType() == typeof(ArrayBufferObjectPacked))
{
ArrayBufferObjectPacked arrayBufferObjectPacked = (ArrayBufferObjectPacked)buffer;
arrayBufferObjectPacked.Create(_Context, CreateTestArray());
}
}
public void SetNonEmptyData()
{
var buffer = new BufferObject(BufferTarget.ArrayBuffer);
buffer.SetData(new float[] { 1, 2, 3 }, BufferUsageHint.StaticDraw);
Assert.AreEqual(sizeof(float) * 3, buffer.SizeInBytes);
}
void Awake()
{
cam = GetComponent <Camera>();
if (cameraSceneMap == null)
{
cameraSceneMap = new Dictionary <Camera, BufferObject>();
}
if (!cameraSceneMap.ContainsKey(cam))
{
BufferObject entry = new BufferObject();
CommandBuffer buffer = new CommandBuffer();
buffer.name = "SceneBuffer";
entry.buffer = buffer;
cameraSceneMap.Add(cam, entry);
}
isolatedCmdBuf = new CommandBuffer();
isolatedCmdBuf.name = "IsolatedSceneBuffer";
easyOutlineMaterial = new Material(Shader.Find("EasyOutline/System"));
openGLFix = (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES3 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLCore);
depthMaterial = new Material(Shader.Find("EasyOutline/RenderDepth"));
clearColor = openGLFix ? Color.white : Color.black;
renTexFmt = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat) ? RenderTextureFormat.RFloat : RenderTextureFormat.Default;
}
public RModel GetRenderModel(RSkeleton skeleton = null)
{
var model = new RModel
{
BoundingSphere = new Vector4(mesh.BoundingSphereCenter.ToOpenTK(), mesh.BoundingSphereRadius)
};
// Use a shared buffer to improve performance.
// The render meshes will keep references to these objects.
var vertexBuffer0 = new BufferObject(BufferTarget.ArrayBuffer);
vertexBuffer0.SetData(mesh.VertexBuffers[0].Buffer, BufferUsageHint.StaticDraw);
var vertexBuffer1 = new BufferObject(BufferTarget.ArrayBuffer);
vertexBuffer1.SetData(mesh.VertexBuffers[1].Buffer, BufferUsageHint.StaticDraw);
foreach (MeshObject meshObject in mesh.Objects)
{
var rMesh = new RMesh
{
Name = meshObject.Name,
SubIndex = meshObject.SubIndex,
SingleBindName = meshObject.ParentBoneName,
BoundingSphere = new Vector4(meshObject.BoundingSphereCenter.X, meshObject.BoundingSphereCenter.Y,
meshObject.BoundingSphereCenter.Z, meshObject.BoundingSphereRadius),
RenderMesh = CreateRenderMesh(skeleton, meshObject, vertexBuffer0, vertexBuffer1),
};
model.SubMeshes.Add(rMesh);
}
return(model);
}
/// <summary>
/// sets or updates a vertex attribute of type Matrix4
/// Matrix4 is stored row-major, but OpenGL expects data to be column-major, so the Matrix4 inputs become transposed in the shader
/// </summary>
/// <param name="bindingID">shader binding location</param>
/// <param name="data">array of Matrix4 inputs</param>
/// <param name="perInstance">if set to <c>true</c> [per instance].</param>
private void SetAttribute(int bindingID, Matrix4[] data, bool perInstance = false)
{
if (-1 == bindingID)
{
return;
}
this.Activate();
BufferObject bufferObject = this.RequestBuffer(bindingID, BufferTarget.ArrayBuffer);
bufferObject.Set <Matrix4>(data, BufferUsageHint.StaticDraw);
bufferObject.Activate();
int num = Marshal.SizeOf(typeof(Vector4));
int stride = Marshal.SizeOf(typeof(Matrix4));
for (int index = 0; index < 4; ++index)
{
GL.VertexAttribPointer(bindingID + index, 4, VertexAttribPointerType.Float, false, stride, num * index);
GL.EnableVertexAttribArray(bindingID + index);
if (perInstance)
{
GL.VertexAttribDivisor(bindingID + index, 1);
}
}
this.Deactivate();
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
for (int index = 0; index < 4; ++index)
{
GL.DisableVertexAttribArray(bindingID + index);
}
}
//protected const int MAXOUTPUTS = 16;
//protected OperatorOutput[] outputs = new OperatorOutput[MAXOUTPUTS];
public OperatorComponentBase(bool usingFilenames = true, params Tuple <ShaderType, string>[] shaderSourceOrFilenames)
{
Vector3[] vertex =
{
new Vector3(-1f, 1f, 0f),
new Vector3(-1f, -1f, 0f),
new Vector3(1f, 1f, 0f),
new Vector3(1f, -1f, 0f)
};
uint[] index =
{
0, 1, 2,
1, 3, 2
};
// vertices for OpenGL coordinate space and an identity projection.
Resources.Add(VertexBuffer = vertex.ToBufferObject("vertex"));
Resources.Add(IndexBuffer = index.ToBufferObject("index", BufferTarget.ElementArrayBuffer));
if (shaderSourceOrFilenames != null && shaderSourceOrFilenames.Length > 0)
{
Shader = new ReloadableResource <ShaderProgram>("shader", () => new ShaderProgram("shader_internal", "vertex", "", usingFilenames, shaderSourceOrFilenames), (s) => new ShaderProgram(s));
Resources.Add(Shader);
}
}
public static RModel GetRenderModel(Mesh mesh, RSkeleton skeleton)
{
var model = new RModel
{
BoundingSphere = new Vector4(mesh.BoundingSphereCenter.ToOpenTK(), mesh.BoundingSphereRadius)
};
// Use a shared buffer to improve performance.
// The render meshes will keep references to these objects.
var vertexBuffer0 = new BufferObject(BufferTarget.ArrayBuffer);
vertexBuffer0.SetData(mesh.VertexBuffers[0].Buffer, BufferUsageHint.StaticDraw);
var vertexBuffer1 = new BufferObject(BufferTarget.ArrayBuffer);
vertexBuffer1.SetData(mesh.VertexBuffers[1].Buffer, BufferUsageHint.StaticDraw);
foreach (MeshObject meshObject in mesh.Objects)
{
var singleBindIndex = skeleton.GetBoneIndex(meshObject.ParentBoneName);
var rMesh = new RMesh(meshObject.Name,
meshObject.SubIndex,
meshObject.ParentBoneName,
singleBindIndex,
new Vector4(meshObject.BoundingSphereCenter.ToOpenTK(),
meshObject.BoundingSphereRadius),
CreateRenderMesh(mesh, skeleton, meshObject, vertexBuffer0, vertexBuffer1),
// TODO: The actual in game check is more complicated, and involves checking names, subindex, and usage.
meshObject.Attributes.Select(m => m.AttributeStrings[0].Text).ToList()
);
model.SubMeshes.Add(rMesh);
}
return model;
}
private static void RenderPresetsToFiles()
{
using (GameWindow gameWindow = OpenTKSharedResources.CreateGameWindowContext(width, height))
{
// Resource creation.
screenVbo = ScreenDrawing.CreateScreenQuadBuffer();
shader = OpenTKSharedResources.shaders["NudSphere"];
// Skip thumbnail generation if the shader didn't compile.
if (!shader.ProgramCreatedSuccessfully)
{
return;
}
// HACK: This isn't a very clean way to pass resources around.
NudMatSphereDrawing.LoadMaterialSphereTextures();
Dictionary <NUD.DummyTextures, Texture> dummyTextures = RenderTools.CreateNudDummyTextures();
CreateNudSphereShader();
foreach (string file in Directory.EnumerateFiles(MainForm.executableDir + "\\materials", "*.nmt", SearchOption.AllDirectories))
{
NUD.Material material = NUDMaterialEditor.ReadMaterialListFromPreset(file)[0];
string presetName = Path.GetFileNameWithoutExtension(file);
RenderMaterialPresetToFile(presetName, material, dummyTextures);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="target">The target of the texture or cube face for loading mip maps</param>
/// <param name="width">The width of the texture or cube map face in pixels</param>
/// <param name="height">The height of the texture or cube map face in pixels</param>
/// <param name="baseMipLevel"></param>
/// <param name="format">The input format and internal format information</param>
public static void LoadBaseLevelGenerateMipmaps(TextureTarget target, int width, int height,
BufferObject baseMipLevel, TextureFormatUncompressed format)
{
LoadUncompressedMipLevel(target, width, height, baseMipLevel, format, 0);
GL.GenerateMipmap((GenerateMipmapTarget)target);
}
private static void InitializeUVBufferData(BufferObject uvPositionVBO, List <Vector2> uvs)
{
// Set up the buffer data.
uvPositionVBO.Bind();
Vector2[] uvArray = uvs.ToArray();
GL.BufferData(uvPositionVBO.BufferTarget, (IntPtr)(sizeof(float) * 2 * uvArray.Length), uvArray, BufferUsageHint.StaticDraw);
}
private void InitVBOs()
{
// Create vertex and index buffers for our particles.
// These point to texels in the textures that store particle position and attributes.
Vector2[] vertex = new Vector2[width * height];
uint[] index = new uint[width * height];
int i = 0;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
vertex[i] = new Vector2((float)x / (float)width, (float)y / (float)height);
index[i] = (uint)i;
i++;
}
}
vertexVBO = new BufferObject <Vector2>("vbuf", BufferTarget.ArrayBuffer, BufferUsageHint.StaticDraw, vertex);
Resources.Add(vertexVBO);
indexVBO = new BufferObject <uint>("ibuf", BufferTarget.ElementArrayBuffer, BufferUsageHint.StaticDraw, index);
Resources.Add(indexVBO);
}
public override void Write(byte[] buffer, int offset, int count)
{
if (count <= 0)
{
return;
}
count = Math.Min(buffer.Length - offset, count);
var tCount = count;
var tOffset = offset;
var cWriteBuf = _lastBuffer;
if (cWriteBuf == null)
{
_localBuffer.Enqueue(cWriteBuf = _ringBufferProvider.Create());
}
while (tCount > 0)
{
if (cWriteBuf.IsFull)
{
_localBuffer.Enqueue(cWriteBuf = _ringBufferProvider.Create());
}
var cWrite = cWriteBuf.Write(buffer, tOffset, tCount);
tCount -= cWrite;
tOffset += cWrite;
}
_lastBuffer = cWriteBuf.IsFull ? null : cWriteBuf;
_length += count;
}
/// <summary>
/// Test for default values after construction.
/// </summary>
/// <param name="buffer"></param>
private void ConstructionDefaulValues(BufferObject buffer)
{
Assert.AreEqual(0U, buffer.BufferSize);
Assert.AreEqual(0U, buffer.ClientBufferSize);
Assert.AreEqual(IntPtr.Zero, buffer.GpuBufferAddress);
Assert.AreEqual(IntPtr.Zero, buffer.ClientBufferAddress);
}
private static void LoadFloatTexImageDataPbo(Texture2D floatTexture, Vector3[] pixels, int width, int height)
{
BufferObject pixelBuffer = new BufferObject(BufferTarget.PixelUnpackBuffer);
pixelBuffer.SetData(pixels, BufferUsageHint.StaticDraw);
floatTexture.LoadImageData(width, height, pixelBuffer, new TextureFormatUncompressed(PixelInternalFormat.Rgb, PixelFormat.Rgb, PixelType.Float));
}
unsafe void PrepareState()
{
if (m_AttributeState != null)
{
UpdateGrid ();
PositionBuffer.Publish ();
ParameterBuffer.Publish ();
m_State.Activate ();
return;
}
m_Count = m_GridDiameter / m_GridDensity + 1;
unsafe
{
PositionBuffer = new BufferObjectCompact<Vector3> (sizeof(Vector3), 4 * m_Count + 2) { Name = "position_buffer", Usage = BufferUsageHint.DynamicDraw };
ParameterBuffer = new BufferObjectCompact<float> (sizeof(float), 4 * m_Count + 2) { Name = "parameter_buffer", Usage = BufferUsageHint.DynamicDraw };
}
m_UniformState = new UniformState ().Set ("modelview_transform", m_CameraMvp.ModelViewProjection);
m_AttributeState = new ArrayObject (new VertexAttribute { AttributeName = "pos", Buffer = PositionBuffer, Size = 3, Type = VertexAttribPointerType.Float }, new VertexAttribute { AttributeName = "param", Buffer = ParameterBuffer, Size = 1, Type = VertexAttribPointerType.Float });
m_Program = new Program ("coordinate_grid_program", GetShaders ("GridRenderPass", "").ToArray ());
m_State = new State (null, m_AttributeState, m_Program, m_UniformState);
PrepareState ();
}
/// <summary>
/// Sets a vertex attribute array for the given <paramref name="bindingID" />.
/// </summary>
/// <typeparam name="DataElement">The data element type.</typeparam>
/// <param name="bindingID">The binding ID.</param>
/// <param name="data">The attribute array data.</param>
/// <param name="type">The array elements base type.</param>
/// <param name="elementSize">Element count for each array element.</param>
/// <param name="perInstance">
/// if set to <c>true</c> attribute array contains one entry for each instance
/// if set to <c>false</c> all attribute array elements are for one instance
/// </param>
private void SetAttribute <DataElement>(
int bindingID,
DataElement[] data,
VertexAttribPointerType type,
int elementSize,
bool perInstance = false)
where DataElement : struct
{
if (-1 == bindingID)
{
return;
}
this.Activate();
BufferObject bufferObject = this.RequestBuffer(bindingID, BufferTarget.ArrayBuffer);
bufferObject.Set <DataElement>(data, BufferUsageHint.StaticDraw);
bufferObject.Activate();
int stride = Marshal.SizeOf(typeof(DataElement));
GL.VertexAttribPointer(bindingID, elementSize, type, false, stride, 0);
GL.EnableVertexAttribArray(bindingID);
if (perInstance)
{
GL.VertexAttribDivisor(bindingID, 1);
}
else
{
this.lastAttributeLength = data.Length;
}
this.Deactivate();
bufferObject.Deactivate();
GL.DisableVertexAttribArray(bindingID);
}
public HSDScene()
{
AttachmentTypes.Remove(typeof(SBMeshList));
AttachmentTypes.Remove(typeof(SBTextureList));
AttachmentTypes.Add(typeof(SBDobjAttachment));
boneBindUniformBuffer = new BufferObject(BufferTarget.UniformBuffer);
boneTransformUniformBuffer = new BufferObject(BufferTarget.UniformBuffer);
}
public void UncompressedBaseLevel()
{
Texture2D texture = new Texture2D();
BufferObject pixelBuffer = new BufferObject(BufferTarget.PixelUnpackBuffer);
pixelBuffer.SetData(new float[] { 1, 1, 1 }, BufferUsageHint.StaticDraw);
texture.LoadImageData(1, 1, pixelBuffer, new TextureFormatUncompressed(PixelInternalFormat.Rgb, PixelFormat.Rgb, PixelType.Float));
}
public void CompressedBaseLevel()
{
Texture2D texture = new Texture2D();
BufferObject pixelBuffer = new BufferObject(BufferTarget.PixelUnpackBuffer);
pixelBuffer.SetData(new float[] { 1, 1, 1 }, BufferUsageHint.StaticDraw);
texture.LoadImageData(1, 1, pixelBuffer, InternalFormat.CompressedRgbaS3tcDxt1Ext);
}
public static void InitializeUVBufferData(NUD nud)
{
// The previous object's data will be cleaned up by GLOBjectManager.
uvPositionVbo = new BufferObject(BufferTarget.ArrayBuffer);
uvElementsIbo = new BufferObject(BufferTarget.ElementArrayBuffer);
nud.UpdateVertexBuffers(uvPositionVbo, uvElementsIbo);
}
/// <summary>
/// Loads texture data of the specified format for the first mip level.
/// Mipmaps are generated by OpenGL.
/// </summary>
/// <param name="width">The width of the base mip level in pixels</param>
/// <param name="height">The height of the base mip level in pixels</param>
/// <param name="baseMipLevel">The image data of the first mip level</param>
/// <param name="format">The image format for all mipmaps</param>
public void LoadImageData(int width, int height, BufferObject baseMipLevel, TextureFormatUncompressed format)
{
Width = width;
Height = height;
Bind();
MipmapLoading.LoadBaseLevelGenerateMipmaps(TextureTarget, width, height, baseMipLevel, format);
}
/// <summary>
/// Updates the shader buffer.
/// </summary>
/// <typeparam name="DATA_ELEMENT_TYPE">The type of the ata element type.</typeparam>
/// <param name="name">The name.</param>
/// <param name="uniformArray">The uniform array.</param>
public void UpdateShaderBuffer <DATA_ELEMENT_TYPE>(string name, DATA_ELEMENT_TYPE[] uniformArray) where DATA_ELEMENT_TYPE : struct
{
if (!buffers.TryGetValue(name, out BufferObject buffer))
{
buffer = new BufferObject(BufferTarget.ShaderStorageBuffer);
buffers.Add(name, buffer);
}
buffer.Set(uniformArray, BufferUsageHint.StaticCopy);
}
private BufferObject RequestBuffer(int bindingID, BufferTarget bufferTarget)
{
if (!this.boundBuffers.TryGetValue(bindingID, out var bufferObject))
{
bufferObject = new BufferObject(bufferTarget);
this.boundBuffers[bindingID] = bufferObject;
}
return(bufferObject);
}
/// <summary>
/// Updates the uniforms.
/// </summary>
/// <typeparam name="DATA">The type of the ata.</typeparam>
/// <param name="name">The name.</param>
/// <param name="uniforms">The uniforms.</param>
public void UpdateUniforms <DATA>(string name, DATA uniforms) where DATA : struct
{
if (!buffers.TryGetValue(name, out BufferObject buffer))
{
buffer = new BufferObject(BufferTarget.UniformBuffer);
buffers.Add(name, buffer);
}
buffer.Set(uniforms, BufferUsageHint.StaticRead);
}
public new void Dispose()
{
_lastBuffer = null;
while (_localBuffer?.Count != 0)
{
_localBuffer?.Dequeue().ReIntegrate();
}
base.Dispose();
}
public static void SetUp()
{
// Create the buffer.
rectangularPrismPositionBuffer = new BufferObject(BufferTarget.ArrayBuffer);
rectangularPrismPositionBuffer.Bind();
Vector3[] rectangularPrismPositions = GetRectangularPrismPositions(1, 1, 1);
GL.BufferData(rectangularPrismPositionBuffer.BufferTarget, (IntPtr)(sizeof(float) * 3 * rectangularPrismPositions.Length),
rectangularPrismPositions, BufferUsageHint.StaticDraw);
}
public TcpClientChannel()
{
ChannelSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_synchronizeHandle = new AutoResetEvent(false);
_buffObj = new BufferObject(_bufferSize = 8192);
_netWriter = new NetworkWriter();
ActiveSocketOperations = new Dictionary <Guid, ISocketOperation>();
OperationTable = new Dictionary <int, Type>();
_lockObj = new object();
}
public Mesh(Vertex[] vertices, int[] indices)
{
_vertices = vertices;
_indices = indices;
_vertexArrayObject = new VertexArrayObject();
_elementBufferObject = new BufferObject(BufferTarget.ElementArrayBuffer);
_vertexBufferObject = new BufferObject(BufferTarget.ArrayBuffer);
_shader = null;
}
public QuadsMesh(GL gl, Layer layer = Layer.Layer0)
{
_GL = gl;
ID = Guid.NewGuid();
Visible = true;
Layer = layer;
BufferObject = new BufferObject <Quad <TIndex, TVertex> >(gl);
VertexArrayObject = new VertexArrayObject(gl);
}
public static BufferObject CreateScreenQuadBuffer()
{
// Create buffer for vertex positions. The data won't change, so only initialize once.
BufferObject screenQuad = new BufferObject(BufferTarget.ArrayBuffer);
screenQuad.Bind();
GL.BufferData(screenQuad.BufferTarget, (IntPtr)(sizeof(float) * screenQuadVertices.Length),
screenQuadVertices, BufferUsageHint.StaticDraw);
return(screenQuad);
}
private void InitParticles()
{
var rnd = new Random(12);
Func<float> Rnd01 = () => (float)rnd.NextDouble();
Func<float> RndCoord = () => (Rnd01() - 0.5f) * 2.0f;
Func<float> RndSpeed = () => (Rnd01() - 0.5f) * 0.01f;
bufferParticles = new BufferObject(BufferTarget.ShaderStorageBuffer);
var data = new Particle[particelCount];
for (int i = 0; i < particelCount; ++i)
{
data[i].position = new Vector2(RndCoord(), RndCoord());
data[i].velocity = new Vector2(RndSpeed(), RndSpeed());
}
bufferParticles.Set(data, BufferUsageHint.StaticCopy);
}
public void LoadBufferObject(BufferObject pBufferObject)
{
if (pBufferObject == null)
{
return;
}
if (BufferObjectManager.mBufferObjectsManaged.Contains(pBufferObject))
{
/* Just make sure it doesn't get deleted. */
BufferObjectManager.mBufferObjectsToBeUnloaded.Remove(pBufferObject);
}
else
{
BufferObjectManager.mBufferObjectsManaged.Add(pBufferObject);
BufferObjectManager.mBufferObjectsToBeLoaded.Add(pBufferObject);
}
}
unsafe void PrepareState()
{
if (m_ParticleRenderingState != null)
{
Simulate (DateTime.Now);
PositionBuffer.Publish ();
ColorAndSizeBuffer.Publish ();
m_SystemState.Activate ();
return;
}
unsafe
{
//VelocityBuffer = new BufferObject<Vector4> (sizeof(Vector4), size) { Name = "velocity_buffer", Usage = BufferUsageHint.DynamicDraw };
PositionBuffer = new BufferObject<Vector4> (sizeof(Vector4), PARTICLES_COUNT) { Name = "position_buffer", Usage = BufferUsageHint.DynamicDraw };
ColorAndSizeBuffer = new BufferObject<Vector4> (sizeof(Vector4), PARTICLES_COUNT) { Name = "colorandsize_buffer", Usage = BufferUsageHint.DynamicDraw };
}
m_Projection = new MatrixStack ().Push (Matrix4.CreateOrthographic (14, 14, -1, 1));
m_TransformationStack = new MatrixStack (m_Projection).Push (Matrix4.Identity).Push (Matrix4.Identity);
m_UniformState = new UniformState ().Set ("color", new Vector4 (0, 0, 1, 1)).Set ("red", 1.0f).Set ("green", 0.0f).Set ("blue", 1.0f).Set ("colors", new float[] { 0, 1, 0, 1 }).Set ("colors2", new Vector4[] { new Vector4 (1, 0.1f, 0.1f, 0), new Vector4 (1, 0, 0, 0), new Vector4 (1, 1, 0.1f, 0) }).Set ("modelview_transform", m_TransformationStack);
var sprite = new[] { new Vector3 (-1, -1, 0), new Vector3 (-1, 1, 0), new Vector3 (1, 1, 0), new Vector3 (1, -1, 0) };
var vdata_buffer = new BufferObject<Vector3> (sizeof(Vector3)) { Name = "vdata_buffer", Usage = BufferUsageHint.DynamicDraw, Data = sprite };
m_ParticleRenderingState = new ArrayObject (new VertexAttribute { AttributeName = "vertex_pos", Buffer = vdata_buffer, Size = 3, Type = VertexAttribPointerType.Float }, new VertexAttribute { AttributeName = "sprite_pos", Buffer = PositionBuffer, Divisor = 1, Size = 4, Stride = 0, Type = VertexAttribPointerType.Float }, new VertexAttribute { AttributeName = "sprite_colorandsize", Buffer = ColorAndSizeBuffer, Divisor = 1, Size = 4, Type = VertexAttribPointerType.Float });
m_ParticleRenderingProgram = new Program ("main_program", opentk.ShadingSetup.RenderPass.GetResourceShaders(string.Empty, GetType ().Namespace.Split ('.').Last ()).ToArray ());
m_SystemState = new State (null, m_ParticleRenderingState, m_ParticleRenderingProgram, m_UniformState);
var hnd = PositionBuffer.Handle;
hnd = ColorAndSizeBuffer.Handle;
m_DebugView = new opentk.QnodeDebug.QuadTreeDebug(10000, m_TransformationStack);
InitializeSystem();
PrepareState ();
}
protected override void PrepareStateCore()
{
unsafe
{
MetaBuffer = new BufferObject<MetaInformation> (sizeof(MetaInformation), 0) { Name = "metadata_buffer", Usage = BufferUsageHint.DynamicDraw };
}
}
private void InitializeSystem()
{
ColorAndSize = ColorAndSizeBuffer;
Position = PositionBuffer;
Oscilation = new Vector2[Position.Length];
Phase = new float[Position.Length];
Velocity = new Vector4[Position.Length];
VelocityUpdate = new Vector4[Position.Length];
Bmin = new Vector4[Position.Length];
Bmax = new Vector4[Position.Length];
}
public void UnloadBufferObject(BufferObject pBufferObject)
{
if (pBufferObject == null)
{
return;
}
if (BufferObjectManager.mBufferObjectsManaged.Contains(pBufferObject))
{
if (BufferObjectManager.mBufferObjectsLoaded.Contains(pBufferObject))
{
BufferObjectManager.mBufferObjectsToBeUnloaded.Add(pBufferObject);
}
else if (BufferObjectManager.mBufferObjectsToBeLoaded.Remove(pBufferObject))
{
BufferObjectManager.mBufferObjectsManaged.Remove(pBufferObject);
}
}
}
unsafe void PrepareState()
{
if (m_AttributeState != null)
{
FillBuffers();
PositionBuffer.Publish ();
DimensionBuffer.Publish ();
m_State.Activate ();
return;
}
unsafe
{
PositionBuffer = new BufferObjectCompact<Vector3> (sizeof(Vector3), m_MaxSize) { Name = "position_buffer", Usage = BufferUsageHint.DynamicDraw };
DimensionBuffer = new BufferObjectCompact<Vector3> (sizeof(Vector3), m_MaxSize) { Name = "dimension_buffer", Usage = BufferUsageHint.DynamicDraw };
}
m_UniformState = new UniformState ()
.Set ("modelview_transform", m_TransformationStack);
m_AttributeState = new ArrayObject (
new VertexAttribute { AttributeName = "cube_pos", Buffer = PositionBuffer, Size = 3, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "cube_dimensions", Buffer = DimensionBuffer, Size = 3, Type = VertexAttribPointerType.Float });
m_Program = new Program ("debug_qnode_program", GetShaders("QnodeDebug", "").ToArray ());
m_State = new State (null, m_AttributeState, m_Program, m_UniformState);
var hnd = PositionBuffer.Handle;
hnd = DimensionBuffer.Handle;
PrepareState ();
}
//
private void PrepareState()
{
if (m_Initialized)
{
if (PARTICLES_COUNT != m_PositionBuffer.Data.Length)
{
Position = m_PositionBuffer.Data = new Vector4[PARTICLES_COUNT];
Dimension = m_DimensionBuffer.Data = new Vector4[PARTICLES_COUNT];
Color = m_ColorBuffer.Data = new Vector4[PARTICLES_COUNT];
Rotation = m_RotationBuffer.Data = new Matrix4[PARTICLES_COUNT];
RotationLocal = m_RotationLocalBuffer.Data = new Matrix4[PARTICLES_COUNT];
InitializeSystem ();
}
Simulate (DateTime.Now);
switch (PublishMethod){
case PublishMethod.AllAtOnce:
m_PositionBuffer.Publish ();
m_DimensionBuffer.Publish ();
m_ColorBuffer.Publish ();
m_RotationBuffer.Publish();
m_RotationLocalBuffer.Publish();
Publish (0, PARTICLES_COUNT);
break;
case PublishMethod.Incremental:
{
m_PublishCounter %= PARTICLES_COUNT;
var start = m_PublishCounter;
var end = Math.Min(start + PublishSize, PARTICLES_COUNT);
var cnt = end - start;
m_PositionBuffer.PublishPart (start, cnt);
m_DimensionBuffer.PublishPart (start, cnt);
m_ColorBuffer.PublishPart (start, cnt);
m_RotationBuffer.PublishPart (start, cnt);
m_RotationLocalBuffer.PublishPart (start, cnt);
Publish (start, cnt);
m_PublishCounter = end;
}
break;
default:
break;
}
return;
}
unsafe
{
m_PositionBuffer = new BufferObject<Vector4> (sizeof(Vector4), 0) { Name = "position_buffer", Usage = BufferUsageHint.DynamicDraw };
m_DimensionBuffer = new BufferObject<Vector4> (sizeof(Vector4), 0) { Name = "dimension_buffer", Usage = BufferUsageHint.DynamicDraw };
m_ColorBuffer = new BufferObject<Vector4> (sizeof(Vector4), 0) { Name = "color_buffer", Usage = BufferUsageHint.DynamicDraw };
m_RotationBuffer = new BufferObject<Matrix4> (sizeof(Matrix4), 0) { Name = "rotation_buffer", Usage = BufferUsageHint.DynamicDraw };
m_RotationLocalBuffer = new BufferObject<Matrix4> (sizeof(Matrix4), 0) { Name = "rotation_local_buffer", Usage = BufferUsageHint.DynamicDraw };
}
ParticleStateArrayObject =
new ArrayObject (
new VertexAttribute { AttributeName = "sprite_pos", Buffer = m_PositionBuffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_color", Buffer = m_ColorBuffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_dimensions", Buffer = m_DimensionBuffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_rotation_local", Buffer = m_RotationLocalBuffer, Size = 16, Stride = 64, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_rotation", Buffer = m_RotationBuffer, Size = 16, Stride = 64, Type = VertexAttribPointerType.Float }
);
//
PublishSize = 100000;
ModelScaleFactor = 1;
TransformationStack = new MatrixStack(2);
ProjectionStack = new MatrixStack(1);
CameraMvp = new ModelViewProjectionParameters("", TransformationStack, ProjectionStack);
//
m_Manip = new OrbitManipulator (ProjectionStack);
m_Grid = new Grid (CameraMvp);
TransformationStack[0] = m_Manip.RT;
TransformationStack.ValueStack[1] = Matrix4.Scale(ModelScaleFactor);
//
Uniforms = new UniformState
{
{"particle_scale_factor", () => this.ParticleScaleFactor},
{CameraMvp}
};
//
Shading = GlobalContext.Container.GetExportedValues<IShadingSetup>().FirstOrDefault();
PrepareStateCore();
m_Initialized = true;
PrepareState ();
}
public LinuxNativeWindow(IntPtr display, IntPtr gbm, int fd,
int x, int y, int width, int height, string title,
GraphicsMode mode, GameWindowFlags options,
DisplayDevice display_device)
{
Debug.Print("[KMS] Creating window on display {0:x}", display);
Title = title;
display_device = display_device ?? DisplayDevice.Default;
if (display_device == null)
{
throw new NotSupportedException("[KMS] Driver does not currently support headless systems");
}
window = new LinuxWindowInfo(display, fd, gbm, display_device.Id as LinuxDisplay);
// Note: we only support fullscreen windows on KMS.
// We implicitly override the requested width and height
// by the width and height of the DisplayDevice, if any.
width = display_device.Width;
height = display_device.Height;
bounds = new Rectangle(0, 0, width, height);
client_size = bounds.Size;
if (!mode.Index.HasValue)
{
mode = new EglGraphicsMode().SelectGraphicsMode(window, mode, 0);
}
Debug.Print("[KMS] Selected EGL mode {0}", mode);
SurfaceFormat format = GetSurfaceFormat(display, mode);
SurfaceFlags usage = SurfaceFlags.Rendering | SurfaceFlags.Scanout;
if (!Gbm.IsFormatSupported(gbm, format, usage))
{
Debug.Print("[KMS] Failed to find suitable surface format, using XRGB8888");
format = SurfaceFormat.XRGB8888;
}
Debug.Print("[KMS] Creating GBM surface on {0:x} with {1}x{2} {3} [{4}]",
gbm, width, height, format, usage);
IntPtr gbm_surface = Gbm.CreateSurface(gbm,
width, height, format, usage);
if (gbm_surface == IntPtr.Zero)
{
throw new NotSupportedException("[KMS] Failed to create GBM surface for rendering");
}
window.Handle = gbm_surface;
Debug.Print("[KMS] Created GBM surface {0:x}", window.Handle);
window.CreateWindowSurface(mode.Index.Value);
Debug.Print("[KMS] Created EGL surface {0:x}", window.Surface);
cursor_default = CreateCursor(gbm, Cursors.Default);
cursor_empty = CreateCursor(gbm, Cursors.Empty);
Cursor = MouseCursor.Default;
exists = true;
}
public SpriteBatch(TiledTexture tiledTexture, int x, int y, int z, float scaleX, float scaleY)
{
bufferObject = new BufferObject();
Scale = new Vector2(scaleX, scaleY);
Sprites = new List<Sprite>();
TiledTexture = tiledTexture;
X = x;
Y = y;
Z = z;
//Shader
program = new Program();
string vertexShader =
@"
in vec2 vertex_position;
in vec2 sprite_position;
in vec2 tex_position;
in vec4 vx_color;
in float rotation;
in vec2 scale;
in vec2 size;
varying vec4 color;
varying vec2 tex_coord;
uniform mat4 projection;
uniform vec2 offset;
uniform vec2 tile_size;
uniform mat2 uvTile;
void main()
{
color = vx_color;
float calc_cos = cos(rotation);
float calc_sin = sin(rotation);
vec2 size_total = size * tile_size * scale;
gl_Position = projection *
//Object Translate
mat4(
vec4(1.0, 0.0, 0.0, 0.0),
vec4(0.0, 1.0, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(offset + (sprite_position * tile_size) + (size_total * 0.5), 0.0, 1.0)) *
//Rotation
mat4(
vec4(calc_cos, calc_sin, 0.0, 0.0),
vec4(-calc_sin, calc_cos, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(0.0, 0.0, 0.0, 1.0)) *
//Rotation Origin Translate
mat4(
vec4(1.0, 0.0, 0.0, 0.0),
vec4(0.0, 1.0, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(size_total * -0.5, 0.0, 1.0)) *
//Scale
mat4(
vec4(size_total.x, 0.0, 0.0, 0.0),
vec4(0.0, size_total.y, 0.0, 0.0),
vec4(0.0, 0.0, 1.0, 0.0),
vec4(0.0, 0.0, 0.0, 1.0)) *
vec4(vertex_position, 0.0, 1.0);
tex_coord = tex_position + (vertex_position * uvTile * size);
}
";
string fragShader =
@"
varying vec2 tex_coord;
varying vec4 color;
uniform sampler2D tex_sampler;
void main()
{
gl_FragColor = texture2D(tex_sampler, tex_coord).bgra * color;
}
";
program.AddShader(ShaderType.VertexShader, vertexShader);
program.AddShader(ShaderType.FragmentShader, fragShader);
program.SetVariable("offset", new Vector2(X, Y));
program.SetVariable("tile_size", new Vector2((float)tiledTexture.TileWidth, (float)tiledTexture.TileWidth) * Scale);
program.SetVariable("uvTile", new Matrix2(tiledTexture.uTile, 0, 0, tiledTexture.vTile));
program.SetVariable("projection", Projection.Matrix);
program.SetVariable("tex_sampler", 0);
Projection.ProjectionChangeEvent += Projection_ProjectionChangeEvent;
}
private void InitializeSystem()
{
ColorAndSize = ColorAndSizeBuffer;
Position = PositionBuffer;
OrigPosition = Position.ToArray ();
//initialize particle system
for (int i = 0; i < Position.Length; i++)
{
double phi = 2 * Math.PI * i / (double)Position.Length;
Position[i] = new Vector4 ((float)Math.Cos (phi), (float)Math.Sin (phi), 0, 1);
}
Oscilation = new Vector2[Position.Length];
Phase = new float[Position.Length];
Velocity = new Vector4[Position.Length];
System.Random rnd = new Random ();
for (int i = 0; i < Position.Length; i++)
{
Oscilation[i] = new Vector2 ((float)rnd.NextDouble (), (float)rnd.NextDouble ());
Oscilation[i].Normalize ();
Phase[i] = (float)rnd.NextDouble ();
ColorAndSize[i] = 0.1f * new Vector4 (0, 0, 0, (float)rnd.NextDouble ());
Velocity[i] = new Vector4 (0, 0.01f / (10 * ColorAndSize[i].W), 0, 0);
}
}
public override void Update(IWindowInfo window)
{
WaitFlip(true);
base.SwapBuffers();
bo = LockSurface();
int fb = GetFramebuffer(bo);
SetScanoutRegion(fb);
}
internal BufferAllocatedEventArgs(BufferObject buffer, int size)
{
Buffer = buffer;
Size = size;
}
static void HandleDestroyFB(BufferObject bo, IntPtr data)
{
IntPtr gbm = bo.Device;
int fb = data.ToInt32();
Debug.Print("[KMS] Destroying framebuffer {0}", fb);
if (fb != 0)
{
Drm.ModeRmFB(Gbm.DeviceGetFD(gbm), fb);
}
}
int GetFramebuffer(BufferObject bo)
{
if (bo == BufferObject.Zero)
goto fail;
int bo_handle = bo.Handle;
if (bo_handle == 0)
{
Debug.Print("[KMS] Gbm.BOGetHandle({0:x}) failed.", bo);
goto fail;
}
int width = bo.Width;
int height = bo.Height;
int bpp = Mode.ColorFormat.BitsPerPixel;
int depth = Mode.Depth;
int stride = bo.Stride;
if (width == 0 || height == 0 || bpp == 0)
{
Debug.Print("[KMS] Invalid framebuffer format: {0}x{1} {2} {3} {4}",
width, height, stride, bpp, depth);
goto fail;
}
int buffer;
int ret = Drm.ModeAddFB(
fd, width, height,
(byte)depth, (byte)bpp, stride, bo_handle,
out buffer);
if (ret != 0)
{
Debug.Print("[KMS] Drm.ModeAddFB({0}, {1}, {2}, {3}, {4}, {5}, {6}) failed. Error: {7}",
fd, width, height, depth, bpp, stride, bo_handle, ret);
goto fail;
}
bo.SetUserData((IntPtr)buffer, DestroyFB);
return buffer;
fail:
Debug.Print("[Error] Failed to create framebuffer.");
return -1;
}
void WaitFlip(bool block)
{
PollFD fds = new PollFD();
fds.fd = fd;
fds.events = PollFlags.In;
EventContext evctx = new EventContext();
evctx.version = EventContext.Version;
evctx.page_flip_handler = PageFlipPtr;
int timeout = block ? -1 : 0;
while (is_flip_queued)
{
fds.revents = 0;
if (Libc.poll(ref fds, 1, timeout) < 0)
break;
if ((fds.revents & (PollFlags.Hup | PollFlags.Error)) != 0)
break;
if ((fds.revents & PollFlags.In) != 0)
Drm.HandleEvent(fd, ref evctx);
else
break;
}
// Page flip has taken place, update buffer objects
if (!is_flip_queued)
{
IntPtr gbm_surface = WindowInfo.Handle;
Gbm.ReleaseBuffer(gbm_surface, bo);
bo = bo_next;
}
}
void ISimulationScheme.Simulate(System3 system, DateTime simulationTime, long simulationStep)
{
var trailBundleSize = Math.Max(TrailBundleSize, 1);
if (m_State == null) {
//create program from resources filtered by namespace and name
var program = new Program ("SimulationScheme")
{
RenderPass.GetShaders ("System3", "ParticlesWithTrails"),
RenderPass.GetShaders ("System3", "PWTSub")
};
m_Parameters = new BufferObjectCompact<float>(sizeof(float), 0) { Name = "map_parameters_buffer", Usage = BufferUsageHint.DynamicDraw };
m_State =
new State (null)
{
program,
new ShaderStorageSet
{
{"Position", system.PositionBuffer},
{"Rotation", system.RotationBuffer},
{"MapParameters", m_Parameters},
{"Dimension", system.DimensionBuffer},
{"Attribute1", system.ColorBuffer},
{"Meta", system.MetaBuffer},
},
new UniformState
{
{"u_Dt", () => (float)system.DT },
{"u_TrailSize", () => system.TrailSize },
{"u_TrailBundleSize", () => TrailBundleSize },
{"u_StepsPerFrame", () => system.StepsPerFrame },
{"u_ParticleScale", () => (float)system.ParticleScaleFactor },
{"u_Map", (ShaderType)ShaderTypeExt.ComputeShader, () => system.ChaoticMap.Name },
}
};
}
system.MetaBuffer.Publish();
system.PositionBuffer.Publish();
system.DimensionBuffer.Publish();
system.RotationBuffer.Publish();
system.ColorBuffer.Publish();
system.RotationLocalBuffer.Publish();
m_Parameters.Length = system.ChaoticMap.a.Length;
m_Parameters.CopyFrom(system.ChaoticMap.a, 0);
m_Parameters.Publish();
m_State.Activate ();
GLExtensions.DispatchCompute (system.PARTICLES_COUNT/(8 * trailBundleSize) + 1, 1, 1);
//system.MetaBuffer.Readout();
//system.PositionBuffer.Readout();
//system.RotationBuffer.Readout();
//system.DimensionBuffer.Readout();
//system.ColorBuffer.Readout();
}
void SetCursor(MouseCursor cursor)
{
BufferObject bo = default(BufferObject);
if (cursor == MouseCursor.Default)
{
bo = cursor_default;
}
else if (cursor == MouseCursor.Empty)
{
bo = cursor_empty;
}
else
{
if (cursor_custom != BufferObject.Zero)
cursor_custom.Dispose();
cursor_custom = CreateCursor(window.BufferManager, cursor);
bo = cursor_custom;
}
// If we failed to create a proper cursor, try falling back
// to the empty cursor. We do not want to crash here!
if (bo == BufferObject.Zero)
{
bo = cursor_empty;
}
if (bo != BufferObject.Zero)
{
Drm.SetCursor(window.FD, window.DisplayDevice.Id,
bo.Handle, bo.Width, bo.Height, cursor.X, cursor.Y);
}
}
/// <summary>
/// given color and depth textures, render them.
/// </summary>
private static RenderPass CreateSolidSphere(
FramebufferBindingSet targets,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
IValueProvider<Vector2> viewport,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
IValueProvider<string> fragdepthroutine,
IValueProvider<string> outputroutine,
ModelViewProjectionParameters mvp,
UniformState subroutineMapping,
IEnumerable<Shader> subroutines
)
{
var uniform_state = subroutineMapping != null? new UniformState (subroutineMapping): new UniformState();
uniform_state.Set ("viewport_size", viewport);
uniform_state.Set ("particle_scale_factor", particle_scale_factor);
uniform_state.Set ("u_SetFragmentDepth", ShaderType.FragmentShader, fragdepthroutine);
uniform_state.Set ("u_SetOutputs", ShaderType.FragmentShader, outputroutine);
uniform_state.SetMvp("", mvp);
var array_state =
new ArrayObject (
new VertexAttribute { AttributeName = "sprite_pos", Buffer = sprite_pos_buffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_color", Buffer = sprite_color_buffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float },
new VertexAttribute { AttributeName = "sprite_dimensions", Buffer = sprite_dimensions_buffer, Size = 3, Stride = 16, Type = VertexAttribPointerType.Float }
);
var shaders = SeparateProgramPass.GetShaders("solid_sphere", "RenderPassFactory");
shaders = shaders.Concat(subroutines ?? new Shader[0]).ToArray();
//
var resultPass = new SeparateProgramPass
(
//the name of the pass-program
"solid_sphere_RenderPassFactory",
//before state
null,
//before render
null,
//render code
(window) =>
{
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable (EnableCap.DepthTest);
GL.DepthMask(true);
GL.DepthFunc (DepthFunction.Less);
GL.Disable (EnableCap.Blend);
//setup viewport
GL.Viewport(0, 0, (int)viewport.Value.X, (int)viewport.Value.Y);
GL.DrawArrays (BeginMode.Points, 0, particles_count.Value);
},
//shaders
shaders,
//pass state
array_state,
uniform_state,
targets
);
return resultPass;
}
public Cube()
{
Vertices = new Vector3[]
{
new Vector3(1.0f, -1.0f, -1.0f),
new Vector3(1.0f, -1.0f, 1.0f),
new Vector3(-1.0f, -1.0f, 1.0f),
new Vector3(-1.0f, -1.0f, -1.0f),
new Vector3(-1.0f, 1.0f, -1.0f),
new Vector3(-1.0f, 1.0f, 1.0f),
new Vector3(1.0f, 1.0f, 1.0f),
new Vector3(1.0f, 1.0f, -1.0f),
new Vector3(-1.0f, -1.0f, -1.0f),
new Vector3(-1.0f, -1.0f, 1.0f),
new Vector3(-1.0f, 1.0f, 1.0f),
new Vector3(-1.0f, 1.0f, -1.0f),
new Vector3(1.0f, 1.0f, -1.0f),
new Vector3(1.0f, 1.0f, 1.0f),
new Vector3(1.0f, -1.0f, 1.0f),
new Vector3(1.0f, -1.0f, -1.0f),
new Vector3(-1.0f, -1.0f, -1.0f),
new Vector3(-1.0f, 1.0f, -1.0f),
new Vector3(1.0f, 1.0f, -1.0f),
new Vector3(1.0f, -1.0f, -1.0f),
new Vector3(1.0f, -1.0f, 1.0f),
new Vector3(1.0f, 1.0f, 1.0f),
new Vector3(-1.0f, 1.0f, 1.0f),
new Vector3(-1.0f, -1.0f, 1.0f)
};
Normals = new Vector3[]
{
new Vector3(0.0f, -1.0f, 0.0f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(-1.0f, 0.0f, 0.0f),
new Vector3(-1.0f, 0.0f, 0.0f),
new Vector3(-1.0f, 0.0f, 0.0f),
new Vector3(-1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f)
};
Colors = new int[]
{
ColorToRgba32(Color.DarkRed),
ColorToRgba32(Color.DarkRed),
ColorToRgba32(Color.Gold),
ColorToRgba32(Color.Gold),
ColorToRgba32(Color.DarkRed),
ColorToRgba32(Color.DarkRed),
ColorToRgba32(Color.Gold),
ColorToRgba32(Color.Gold),
};
Texcoords = new Vector2[]
{
new Vector2(0, 1),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 0),
new Vector2(0, 1),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 0),
};
VertexData = new BufferObject<Vector3>(BufferTarget.ArrayBuffer, Vertices);
NormalData = new BufferObject<Vector3>(BufferTarget.ArrayBuffer, Normals);
// IndexData = new BufferObject<int>(BufferTarget.ElementArrayBuffer, Indices);
}
