private void SceneRender(OpenGL gl)
{
ShaderVariables shaderVars = GetShaderVars();
// Get a reference to the raytracer shader.
var shader = shaderRayMarch;
shader.Bind(gl);
shaderVars.Set(gl, shader);
int rt1 = shader.GetUniformLocation(gl, "renderedTexture");
int rn1 = shader.GetUniformLocation(gl, "randomNumbers");
gl.Uniform1(rt1, 0);
gl.Uniform1(rn1, 1);
shader.SetUniform1(gl, "depth", _Depth ? 1 : 0);
shader.SetUniform1(gl, "screenWidth", _TargetWidth);
shader.SetUniform1(gl, "screenHeight", _TargetHeight);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _RaytracerBuffer[_PingPong ? 0 : 1]);
gl.ActiveTexture(OpenGL.GL_TEXTURE1);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _RandomNumbers[0]);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
if (_Rendering)
{
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, (256 / _ProgressiveSteps) * 6);
// CheckForError(gl);
}
shader.Unbind(gl);
}
public override void Render(NkHandle Userdata, GL_Texture Texture, NkRect ClipRect, uint Offset, uint Count)
{
float[] vert = new float[Count * 2];
float[] uvs = new float[Count * 2];
float[] colors = new float[Count * 4];
for (int i = 0; i < Count; i++)
{
NkVertex V = Verts[Inds[Offset + i]];
vert[i * 2] = V.Position.X;
vert[i * 2 + 1] = V.Position.Y;
uvs[i * 2] = V.UV.X;
uvs[i * 2 + 1] = V.UV.Y;
NkColor color = V.Color;
colors[i * 4] = color.R;
colors[i * 4 + 1] = color.G;
colors[i * 4 + 2] = color.B;
colors[i * 4 + 3] = color.A;
}
var vertexDataBuffer = new VertexBuffer();
vertexDataBuffer.Create(gl);
vertexDataBuffer.Bind(gl);
vertexDataBuffer.SetDataV2F(gl, 0, rawData, NkVertex.SIZE * (int)Count, false, 3);
// vertexDataBuffer.SetData(gl, 0, vert, false, 2);
var colourDataBuffer = new VertexBuffer();
colourDataBuffer.Create(gl);
colourDataBuffer.Bind(gl);
colourDataBuffer.SetData(gl, 1, colors, false, 4);
var uvDataBuffer = new VertexBuffer();
uvDataBuffer.Create(gl);
uvDataBuffer.Bind(gl);
uvDataBuffer.SetData(gl, 2, uvs, false, 2);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, Texture.TextureName);
glScissor2(window.DisplayHeight, (int)ClipRect.X, (int)ClipRect.Y, (int)ClipRect.W, (int)ClipRect.H);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, (int)Count);
vertexDataBuffer.Unbind(gl);
// colourDataBuffer.Unbind(gl);
// uvDataBuffer.Unbind(gl);
}
/// <summary>
/// Draws the scene.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public void Draw(OpenGL gl, float width, float height)
{
if (needsRefresh)
{
Initialise(gl);
}
resolutionX = width;
resolutionY = height;
// Clear the scene.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT | OpenGL.GL_STENCIL_BUFFER_BIT);
// Bind the shader, set the matrices.
shaderProgram.Bind(gl);
shaderProgram.SetUniform3(gl, "iResolution", resolutionX, resolutionY, 0.0f);
shaderProgram.SetUniform1(gl, "iGlobalTime", time);
time += 0.1f;
// Bind the out vertex array.
vertexBufferArray.Bind(gl);
texCoordsBufferArray.Bind(gl);
//Bind Textures
var ch0loc = shaderProgram.GetUniformLocation(gl, "iChannel0");
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[0]);
gl.Uniform1(ch0loc, 0);
var ch1loc = shaderProgram.GetUniformLocation(gl, "iChannel1");
gl.ActiveTexture(OpenGL.GL_TEXTURE1);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[1]);
gl.Uniform1(ch1loc, 1);
// Draw the square.
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 6);
// Unbind our vertex array and shader.
vertexBufferArray.Unbind(gl);
texCoordsBufferArray.Unbind(gl);
shaderProgram.Unbind(gl);
}
//public TextureManager()
//{
// _textureCollection = new Dictionary<string, TexContainer>();
// _idCount = 0;
//}
// http://www.mastropaolo.com/devildotnet/
// Path is to the image (only png/jpg for now)
// This creates a texture and assigns it to a texture unit on the GPU.
// What happens if all the texture units are taken ??
public void CreateTexture(string path, OpenGL gl, bool UseNewTU = false)
{
if (!_textureCollection.ContainsKey(path))
{
Debug.WriteLine("Found New Texture! " + "ID: " + _idCount.ToString() + " Path: " + path);
if (UseNewTU)
{
_idCount++;
}
int[] test = new int[3];
gl.GetInteger(OpenGL.GL_MAX_TEXTURE_IMAGE_UNITS, test);
if (test[0] <= _idCount)
{
throw new Exception("Out of Texture Units");
}
Bitmap img = new Bitmap(path);
TexContainer texC = new TexContainer(new Texture(), _idCount);
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.ActiveTexture(OpenGL.GL_TEXTURE0 + (uint)_idCount);
texC.Tex.Create(gl, img);
texC.Tex.Bind(gl);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
_textureCollection.Add(path, texC);
}
}
/// <summary>
/// Initialises the scene.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
public void Initialise(OpenGL gl)
{
time = DateTime.Now.Millisecond / 1000;
// Set a blue clear colour.
//gl.ClearColor(0.4f, 0.6f, 0.9f, 0.0f);
// Create the shader program.
var vertexShaderSource = ResourceHelper.LoadTextFromRecource("ShaderToy.NET.Shaders.main.vert");
var fragmentShaderSource = ResourceHelper.LoadTextFromRecource(
$"ShaderToy.NET.Shaders.{ActiveShader.ResourceName}.frag");
shaderProgram = new DynamicShaderProgram();
shaderProgram.Create(gl, vertexShaderSource, fragmentShaderSource, null);
shaderProgram.BindAttributeLocation(gl, attributeIndexPosition, "position");
shaderProgram.AssertValid(gl);
//Generate Textures
gl.GenTextures(2, glTextureArray);
//shaderProgram.BindAttributeLocation(gl, glTextureArray[0], "iChannel0");
//shaderProgram.BindAttributeLocation(gl, glTextureArray[1], "iChannel1");
var ch0loc = shaderProgram.GetUniformLocation(gl, "iChannel0");
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[0]);
gl.Uniform1(ch0loc, 0);
var ch1loc = shaderProgram.GetUniformLocation(gl, "iChannel1");
gl.ActiveTexture(OpenGL.GL_TEXTURE1);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[1]);
gl.Uniform1(ch1loc, 1);
/*gl.ActiveTexture(OpenGL.GL_TEXTURE0);
* gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[0]);
* gl.ActiveTexture(OpenGL.GL_TEXTURE1);
* gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[1]);*/
// Now create the geometry for the square.
CreateVerticesForSquare(gl);
needsRefresh = false;
}
public void Draw(OpenGL gl, float originX, float originY, float originZ, vec3 leftColor, vec3 rightColor, float audioModifier)
{
float scaleModifier = audioModifier * 1.6f;
if (scaleModifier < MinSize)
{
scaleModifier = MinSize;
}
for (int index = 0; index < _quad.VertexData.Length / _quad.DataStride; index++)
{
_quad.VertexData[index * _quad.DataStride + 3] = Constants.Colors[6, 0]; // r
_quad.VertexData[index * _quad.DataStride + 4] = Constants.Colors[6, 1]; // g
_quad.VertexData[index * _quad.DataStride + 5] = Constants.Colors[6, 2]; // b
_quad.VertexData[index * _quad.DataStride + 6] = 1.0f; // a
}
// Begin Draw
GlState.Instance.ModelMatrix = glm.translate(GlState.Instance.ModelMatrix, new vec3(originX, originY, originZ));
GlState.Instance.ModelMatrix = glm.scale(GlState.Instance.ModelMatrix, new vec3(scaleModifier, scaleModifier, scaleModifier));
// Update buffers
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, _quad.VertexData, _quad.SizeOfVertexDataBytes, OpenGL.GL_STATIC_DRAW);
// Make model matrix available for drawing
gl.UniformMatrix4(GlState.Instance.DefaultTexturedModelMatrixLocation, 1, false, GlState.Instance.ModelMatrix.to_array());
// Set blending for particle system
gl.BlendFunc(OpenGL.GL_ONE, OpenGL.GL_ONE);
gl.DepthFunc(OpenGL.GL_ALWAYS);
// Draw
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _texture);
gl.BindVertexArray(_vertexArrayObject[0]);
gl.DrawElements(OpenGL.GL_TRIANGLES, _quad.IndexData.Length, _quad.IndexData);
gl.BindVertexArray(0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
// Reset depth and blend func
gl.DepthFunc(OpenGL.GL_LESS);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
GlState.Instance.ModelMatrix = mat4.identity();
// End Draw
}
public void Render(OpenGL GL, GShaderProgram shader)
{
compassVAO.Bind(GL);
TexContainer tc;
tc = TextureManager.Instance.GetElement(_textureName);
tc.Tex.Bind(GL); // Bind to the current texture on texture unit 0
GL.ActiveTexture(OpenGL.GL_TEXTURE0 + (uint)tc.ID);
shader.SetUniform(GL, "uSampler", tc.ID);
// Turn ON aplha blending for the arrow so the empty background is ignored
GL.Enable(OpenGL.GL_BLEND);
GL.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
GL.DrawArrays(OpenGL.GL_TRIANGLE_FAN, 0, _numSegments);
GL.Disable(OpenGL.GL_BLEND);
compassVAO.Unbind(GL);
}
private void LoadRandomNumbers(OpenGL gl)
{
gl.GenTextures(1, _RandomNumbers);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _RandomNumbers[0]);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_S, OpenGL.GL_CLAMP_TO_EDGE);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_WRAP_T, OpenGL.GL_CLAMP_TO_EDGE);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_GENERATE_MIPMAP_SGIS, OpenGL.GL_FALSE); // automatic mipmap
byte[] pixels = new byte[4 * 4 * 1024 * 1024]; // sizeof(int)
var fs = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\WooFractal\\" + "randomSequences.vec2", FileMode.Open, FileAccess.Read);
var len = (int)fs.Length;
var bits = new byte[len];
fs.Read(bits, 0, len);
fs.Close();
var floats = new float[len / 2];
int byteidx = 0;
int idx = 0;
for (int y = 0; y < 1024; y++)
{
for (int x = 0; x < 1024; x++)
{
floats[idx++] = BitConverter.ToSingle(bits, byteidx);
byteidx += 4;
floats[idx++] = BitConverter.ToSingle(bits, byteidx);
byteidx += 4;
floats[idx++] = 0;
floats[idx++] = 1;
}
}
Buffer.BlockCopy(floats, 0, pixels, 0, pixels.Length);
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, OpenGL.GL_RGBA32F, 1024, 1024, 0,
OpenGL.GL_RGBA, OpenGL.GL_FLOAT, pixels);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
}
/// <summary>
/// updates pixel data of the desired texture.
/// </summary>
public void UpdateTextureBitmap(OpenGL gl, int texIndex, Bitmap image)
{
int[] textureMaxSize = { 0 };
gl.GetInteger(OpenGL.GL_MAX_TEXTURE_SIZE, textureMaxSize);
if (image == null)
{
return;
}
// Find the target width and height sizes, which is just the highest
// posible power of two that'll fit into the image.
int targetWidth = textureMaxSize[0];
int targetHeight = textureMaxSize[0];
//Console.WriteLine("Updating Tex " + texIndex + "Tex Max Size : " + targetWidth + "x" + targetHeight);
for (int size = 1; size <= textureMaxSize[0]; size *= 2)
{
if (image.Width < size)
{
targetWidth = size / 2;
break;
}
if (image.Width == size)
{
targetWidth = size;
}
}
for (int size = 1; size <= textureMaxSize[0]; size *= 2)
{
if (image.Height < size)
{
targetHeight = size / 2;
break;
}
if (image.Height == size)
{
targetHeight = size;
}
}
// If need to scale, do so now.
if (image.Width != targetWidth || image.Height != targetHeight)
{
// Resize the image.
Image newImage = image.GetThumbnailImage(targetWidth, targetHeight, null, IntPtr.Zero);
// Destory the old image, and reset.
image.Dispose();
image = (Bitmap)newImage;
}
// Lock the image bits (so that we can pass them to OGL).
BitmapData bitmapData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
// Set the width and height.
width[texIndex] = image.Width;
height[texIndex] = image.Height;
if (texIndex == 0)
{
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
}
else
{
gl.ActiveTexture(OpenGL.GL_TEXTURE1);
}
// Bind our texture object (make it the current texture).
gl.BindTexture(OpenGL.GL_TEXTURE_2D, glTextureArray[texIndex]);
// Set the image data.
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, (int)OpenGL.GL_RGBA,
width[texIndex], height[texIndex], 0, OpenGL.GL_BGRA, OpenGL.GL_UNSIGNED_BYTE,
bitmapData.Scan0);
// Unlock the image.
image.UnlockBits(bitmapData);
// Dispose of the image file.
image.Dispose();
// Set linear filtering mode.
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_LINEAR);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_LINEAR);
}
/// <summary>
/// Renders the scene in retained mode.
/// </summary>
/// <param name="gl">The OpenGL instance.</param>
/// <param name="useToonShader">if set to <c>true</c> use the toon shader, otherwise use a per-pixel shader.</param>
public void Render(OpenGL gl)
{
if (_SaveNextRender)
{
SaveInternal(gl);
}
if (_MaxIterations > 0 && _FramesRendered > _MaxIterations - 1 && _Rendering == false)
{
return;
}
// Clear the color and depth buffer.
gl.ClearColor(0f, 0f, 0f, 0f);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT | OpenGL.GL_STENCIL_BUFFER_BIT);
int renderBuffer = 0;
if (_PingPong)
{
renderBuffer = 1;
}
float[] viewport = new float[4];
gl.GetFloat(OpenGL.GL_VIEWPORT, viewport);
Debug.WriteLine("Rendering renderbuffer : " + renderBuffer);
if (_Depth)
{
gl.Viewport(0, 0, 1, 1);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, _DepthFrameBuffer[0]);
SceneRender(gl);
gl.Viewport(0, 0, (int)viewport[2], (int)viewport[3]);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, 0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _DepthCalcBuffer[0]);
int[] pixels = new int[4];
gl.GetTexImage(OpenGL.GL_TEXTURE_2D, 0, OpenGL.GL_RGBA, OpenGL.GL_FLOAT, pixels);
float valr = BitConverter.ToSingle(BitConverter.GetBytes(pixels[0]), 0);
// if (valr != valr)
// throw new Exception("Depth test failed");
// float valg = BitConverter.ToSingle(BitConverter.GetBytes(pixels[1]), 0);
// float valb = BitConverter.ToSingle(BitConverter.GetBytes(pixels[2]), 0);
// float vala = BitConverter.ToSingle(BitConverter.GetBytes(pixels[3]), 0);
_ImageDepth = valr;
_ImageDepthSet = true;
_Depth = false;
}
gl.Viewport(0, 0, _TargetWidth, _TargetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, _FrameBuffer[renderBuffer]);
SceneRender(gl);
int target = 0;
_PostProcess.Render(gl, _TargetWidth, _TargetHeight, ref target, _EffectFrameBuffer, _RaytracerBuffer[renderBuffer], _EffectRaytracerBuffer);
// !!!!!!!!!!!!!!!! Tonemapping
gl.Viewport(0, 0, _TargetWidth, _TargetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, _IntFrameBuffer[0]);
var shader = shaderTransfer;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _EffectRaytracerBuffer[target]);
shader.Bind(gl);
shader.SetUniform1(gl, "renderedTexture", 0);
shader.SetUniform1(gl, "gammaFactor", (float)_PostProcess._GammaFactor);
shader.SetUniform1(gl, "gammaContrast", (float)_PostProcess._GammaContrast);
shader.SetUniform1(gl, "mode", _PostProcess._ToneMappingMode);
shader.SetUniform1(gl, "toneFactor", (float)_PostProcess._ToneFactor);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
// CheckForError(gl);
shader.Unbind(gl);
// !!!!!!!!!!!!!!!!! Int to final framebuffer
gl.Viewport(0, 0, (int)viewport[2], (int)viewport[3]);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, 0);
// get a reference to the transfer shader
shader = shaderIntTransfer;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _PostprocessBuffer[0]);
shader.Bind(gl);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
gl.Viewport(0, 0, (int)viewport[2], (int)viewport[3]);
// CheckForError(gl);
shader.Unbind(gl);
// TIDY UP
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
if (_Rendering)
{
_FramesRendered += 1.0 / (double)_ProgressiveSteps;
if (_MaxIterations > 0 && _FramesRendered > _MaxIterations - 1)
{
_Rendering = false;
}
else
{
_ProgressiveIndex += 256 / _ProgressiveSteps;
_Rays = _TargetHeight * _TargetHeight * _FramesRendered;
if (_ProgressiveIndex >= 256)
{
_ProgressiveIndex = 0;
_PingPong = !_PingPong;
}
}
}
}
public GL_GUI_Context(Window window, float width, float height)
{
this.window = window;
this.Width = width;
this.Height = height;
context = SDL.SDL_GL_CreateContext(window.Handle);
SDL.SDL_GL_MakeCurrent(window.Handle, context);
gl = new OpenGL();
gl.Enable(OpenGL.GL_TEXTURE_2D);
shaderProgram = new ShaderProgram();
shaderProgram.Create(gl, VERTEX_SHADER, FRAGMENT_SHADER, null);
shaderProgram.BindAttributeLocation(gl, 0, "in_Position");
shaderProgram.BindAttributeLocation(gl, 1, "in_Color");
shaderProgram.AssertValid(gl);
gl.GenFramebuffersEXT(1, framebuffers);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, framebuffers[0]);
gl.GenTextures(1, framebufferTargets);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, framebufferTargets[0]);
gl.TexImage2D(OpenGL.GL_TEXTURE_2D, 0, OpenGL.GL_RGB, window.DisplayWidth, window.DisplayHeight, 0, OpenGL.GL_RGB, OpenGL.GL_UNSIGNED_BYTE, IntPtr.Zero);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MIN_FILTER, OpenGL.GL_NEAREST);
gl.TexParameter(OpenGL.GL_TEXTURE_2D, OpenGL.GL_TEXTURE_MAG_FILTER, OpenGL.GL_NEAREST);
gl.FramebufferTexture(OpenGL.GL_FRAMEBUFFER_EXT, OpenGL.GL_COLOR_ATTACHMENT0_EXT, framebufferTargets[0], 0);
gl.DrawBuffers(1, new uint[] { OpenGL.GL_COLOR_ATTACHMENT0_EXT });
if (gl.CheckFramebufferStatusEXT(OpenGL.GL_FRAMEBUFFER_EXT) != OpenGL.GL_FRAMEBUFFER_COMPLETE_EXT)
{
throw new Exception("Frame buffer setup not complete");
}
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, 0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
ortho = new float[] {
2.0f / Width, 0.0f, 0.0f, 0.0f,
0.0f, -2.0f / Height, 0.0f, 0.0f,
0.0f, 0.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 1.0f,
};
gl.Viewport(0, 0, window.DisplayWidth, window.DisplayHeight);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
gl.Disable(OpenGL.GL_CULL_FACE);
gl.Disable(OpenGL.GL_DEPTH_TEST);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.Enable(OpenGL.GL_SCISSOR_TEST);
shaderProgram.Bind(gl);
shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", ortho);
vertexBufferArray = new VertexBufferArray();
vertexBufferArray.Create(gl);
vertexBufferArray.Bind(gl);
}
public void Draw(OpenGL gl, float originX, float originY, float originZ, float audioModifier, bool doOriginTranslation)
{
OriginX = originX;
OriginY = originY;
OriginZ = OriginZ;
// Rotate colors
if (_colorRotateStopwatch.ElapsedMilliseconds >= ColorRotateIntervalMs)
{
pickColor();
_colorRotateStopwatch.Restart();
}
for (int index = 0; index < _particles.Count; index++)
{
Particle particle = _particles[index];
float x = particle.X;
float y = particle.Y;
float z = particle.Z;
float r = particle.R;
float g = particle.G;
float b = particle.B;
float a = particle.Life;
float size = particle.Size;
_pointData[_point.DataStride * index + 0] = x;
_pointData[_point.DataStride * index + 1] = y;
_pointData[_point.DataStride * index + 2] = z;
_pointData[_point.DataStride * index + 3] = size;
_pointData[_point.DataStride * index + 4] = r;
_pointData[_point.DataStride * index + 5] = g;
_pointData[_point.DataStride * index + 6] = b;
_pointData[_point.DataStride * index + 7] = a;
// Increment particle location and speed
if (OverrideParticleUpdate != null)
{
OverrideParticleUpdate(particle, audioModifier);
}
else
{
particle.Update();
}
// Invoke after update delegate if present
if (AfterParticleUpdate != null)
{
AfterParticleUpdate(particle, audioModifier);
}
// Reset dead particles
if (particle.Life <= 0.0f)
{
if (_isContinuous)
{
if (OverrideParticleInit != null)
{
// Call custom init if specified
OverrideParticleInit(particle, audioModifier);
}
else
{
// Re-init happening, no longer initial
particle.IsInitialInit = false;
// Default init
particle.Init(_random, audioModifier);
// Custom init if specified
if (AfterParticleInit != null)
{
AfterParticleInit(particle, audioModifier);
}
}
if (_autoRotateColors)
{
particle.R = Constants.Colors[_colorIndex, 0];
particle.G = Constants.Colors[_colorIndex, 1];
particle.B = Constants.Colors[_colorIndex, 2];
}
}
else
{
if (particle.IsAlive)
{
_deadParticleCount++;
particle.IsAlive = false;
if (_deadParticleCount == _particles.Count)
{
// None are alive. This particle system is no longer active
// and the caller should let it get GC'd
_isActive = false;
}
}
}
}
}
// Begin Draw
if (doOriginTranslation)
{
GlState.Instance.ModelMatrix = glm.translate(GlState.Instance.ModelMatrix, new vec3(originX, originY, originZ));
}
// Update buffers
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, null, _pointData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
GlBuffer.SetArraySubData(gl, _pointData, _pointData.Length * PrimitiveSizes.FloatBytes);
// Make model matrix available for drawing
gl.UniformMatrix4(GlState.Instance.ParticleModelMatrixLocation, 1, false, GlState.Instance.ModelMatrix.to_array());
// Set blending for particle system
gl.BlendFunc(_blendMode, OpenGL.GL_ONE);
gl.DepthFunc(OpenGL.GL_ALWAYS);
// Draw
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _texture);
gl.Uniform1(GlState.Instance.ParticleTextureLocation, 0);
gl.BindVertexArray(_vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, _pointData.Length);
gl.BindVertexArray(0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
// Reset depth and blend func
gl.DepthFunc(OpenGL.GL_LESS);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
if (doOriginTranslation)
{
GlState.Instance.ModelMatrix = mat4.identity();
}
// End Draw
}
public void Render(OpenGL gl, int targetWidth, int targetHeight, ref int target, uint[] effectFrameBuffer, uint raytracerBuffer, uint[] effectRaytracerBuffer)
{
if (_PostProcessFilter == 0)
{
// !!!!!!!!!!!!!!! rgb / a
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
var shader = shaderRGBA;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, raytracerBuffer);
shader.Bind(gl);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
}
else if (_PostProcessFilter == 1)
{
// !!!!!!!!!!!!!!! rgb / a
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
var shader = shaderRGBA;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, raytracerBuffer);
shader.Bind(gl);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
// !!!!!!!!!!!!!!! exponent
target = target > 0 ? 0 : 1;
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
shader = shaderHighlights;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, effectRaytracerBuffer[target > 0 ? 0 : 1]);
shader.Bind(gl);
shader.SetUniform1(gl, "exponent", (float)_GaussianExposure);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
// !!!!!!!!!!!!!!! gaussianShaderX
target = target > 0 ? 0 : 1;
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
shader = shaderGaussianX;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, effectRaytracerBuffer[target > 0 ? 0 : 1]);
shader.Bind(gl);
shader.SetUniform1(gl, "screenWidth", targetWidth);
shader.SetUniform1(gl, "screenHeight", targetHeight);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
// !!!!!!!!!!!!!!! gaussianShaderY
target = target > 0 ? 0 : 1;
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
shader = shaderGaussianY;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, effectRaytracerBuffer[target > 0 ? 0 : 1]);
shader.Bind(gl);
shader.SetUniform1(gl, "screenWidth", targetWidth);
shader.SetUniform1(gl, "screenHeight", targetHeight);
shader.SetUniform1(gl, "renderedTexture", 0);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
// !!!!!!!!!!!!!!! blend
target = target > 0 ? 0 : 1;
gl.Viewport(0, 0, targetWidth, targetHeight);
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, effectFrameBuffer[target]);
shader = shaderBlend;
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, raytracerBuffer);
gl.ActiveTexture(OpenGL.GL_TEXTURE1);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, effectRaytracerBuffer[target > 0 ? 0 : 1]);
shader.Bind(gl);
shader.SetUniform1(gl, "factor1", 1);
shader.SetUniform1(gl, "factor2", (float)_PostProcessAmount);
int rte1 = shader.GetUniformLocation(gl, "renderedTexture1");
int rne1 = shader.GetUniformLocation(gl, "renderedTexture2");
gl.Uniform1(rte1, 0);
gl.Uniform1(rne1, 1);
gl.DrawArrays(OpenGL.GL_TRIANGLES, 0, 3);
shader.Unbind(gl);
}
}
public void Draw(OpenGL gl, float originX, float originY, float originZ, float[] audioData)
{
_ballOrigin.x = originX;
_ballOrigin.y = originY;
_ballOrigin.z = originZ;
for (int index = 0; index < _pointSphere.VertexData.Length / _pointSphere.DataStride; index++)
{
float x = _pointSphere.VertexData[_pointSphere.DataStride * index + 0];
float y = _pointSphere.VertexData[_pointSphere.DataStride * index + 1];
float z = _pointSphere.VertexData[_pointSphere.DataStride * index + 2];
float r = Constants.Colors[_colorIndex, 0];
float g = Constants.Colors[_colorIndex, 1];
float b = Constants.Colors[_colorIndex, 2];
float a = 0.0f;
float size = audioData[0] / 8.0f;
if (size < MinPointSize)
{
size = MinPointSize;
}
if (size > MaxPointSize)
{
size = MaxPointSize;
}
_pointData[_point.DataStride * index + 0] = x;
_pointData[_point.DataStride * index + 1] = y;
_pointData[_point.DataStride * index + 2] = z;
_pointData[_point.DataStride * index + 3] = size;
_pointData[_point.DataStride * index + 4] = r;
_pointData[_point.DataStride * index + 5] = g;
_pointData[_point.DataStride * index + 6] = b;
_pointData[_point.DataStride * index + 7] = a;
}
// Rotation and scale factor
_rotX += IdleRotationSpeed;
_rotY += IdleRotationSpeed;
_rotZ += IdleRotationSpeed;
float scaleFactor = 1.0f + (audioData[0] * 0.04f);
// Begin Draw
GlState.Instance.ModelMatrix = mat4.identity();
GlState.Instance.ModelMatrix = glm.translate(GlState.Instance.ModelMatrix, new vec3(originX, originY, originZ));
GlState.Instance.ModelMatrix = glm.scale(GlState.Instance.ModelMatrix, new vec3(scaleFactor, scaleFactor, scaleFactor));
GlState.Instance.ModelMatrix = glm.rotate(GlState.Instance.ModelMatrix, _rotX, new vec3(1, 0, 0));
GlState.Instance.ModelMatrix = glm.rotate(GlState.Instance.ModelMatrix, _rotY, new vec3(0, 1, 0));
GlState.Instance.ModelMatrix = glm.rotate(GlState.Instance.ModelMatrix, _rotZ, new vec3(0, 0, 1));
// Update buffers
gl.BindBuffer(OpenGL.GL_ARRAY_BUFFER, _vertexBufferObject[0]);
GlBuffer.SetArrayData(gl, null, _pointData.Length * PrimitiveSizes.FloatBytes, OpenGL.GL_STREAM_DRAW);
GlBuffer.SetArraySubData(gl, _pointData, _pointData.Length * PrimitiveSizes.FloatBytes);
// Make model matrix available for drawing
gl.UniformMatrix4(GlState.Instance.ParticleModelMatrixLocation, 1, false, GlState.Instance.ModelMatrix.to_array());
// Set blending for particle system
gl.BlendFunc(OpenGL.GL_ONE, OpenGL.GL_ONE);
gl.DepthFunc(OpenGL.GL_ALWAYS);
// Draw
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, _texture);
gl.Uniform1(GlState.Instance.ParticleTextureLocation, 0);
gl.BindVertexArray(_vertexArrayObject[0]);
gl.DrawArrays(OpenGL.GL_POINTS, 0, _pointData.Length);
gl.BindVertexArray(0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
// Reset depth and blend func
gl.DepthFunc(OpenGL.GL_LESS);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
GlState.Instance.ModelMatrix = mat4.identity();
// End Draw
}
public void Render()
{
if (postprocessingEnabled && postShader != null && postShader.Compiled)
{
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, fbo);
}
float[] clear = Convert.ColorToGLColor(ClearColor);
gl.ClearColor(clear[0], clear[1], clear[2], clear[3]);
camera.Project(gl);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT |
OpenGL.GL_STENCIL_BUFFER_BIT);
attrs.Push(gl, null);
if (RenderGrid)
grid.Render(gl);
if (RenderAxies)
axies.Render(gl);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_ONE, OpenGL.GL_ONE);
foreach (Node node in children)
{
if (node is Light)
node.Render(gl);
}
if (Model != null)
Model.Render(gl);
foreach (Node node in children)
{
if (node is Light)
((Light)node).Pop(gl);
}
gl.Disable(OpenGL.GL_BLEND);
attrs.Pop(gl, null);
gl.Flush();
if (postprocessingEnabled && postShader != null && postShader.Compiled)
{
gl.BindFramebufferEXT(OpenGL.GL_FRAMEBUFFER_EXT, 0);
gl.ClearColor(0, 0, 0, 1);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.LoadIdentity();
gl.Ortho(0, viewportSize.Width, viewportSize.Height, 0, -1, 1);
gl.MatrixMode(OpenGL.GL_MODELVIEW);
gl.LoadIdentity();
postShader.Bind();
postShader.SetUniform1("resolution_x", viewportSize.Width);
postShader.SetUniform1("resolution_y", viewportSize.Height);
//gl.Uniform2(postShader.GetUniformLocation("resolution"),
// viewportSize.Width, viewportSize.Height);
gl.ActiveTexture(OpenGL.GL_TEXTURE0);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, fboTexture);
postShader.SetUniform1("texFramebuffer", 0);
gl.Begin(OpenGL.GL_QUADS);
gl.TexCoord(0, 1); gl.Vertex(0, 0);
gl.TexCoord(0, 0); gl.Vertex(0, (float)viewportSize.Height);
gl.TexCoord(1, 0); gl.Vertex((float)viewportSize.Width, (float)viewportSize.Height);
gl.TexCoord(1, 1); gl.Vertex((float)viewportSize.Width, 0);
gl.End();
postShader.Unbind();
}
}
public void UseTexure(OpenGL gl)
{
_texture.Bind(gl);
gl.ActiveTexture(_texture.TextureName);
}