public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
//by using the boxes for gaussian we can produce a more realisitc motion blur
//then simply using a standard box blur alone (aka a non linear motion blur)
float[] boxes = Materia.Nodes.Helpers.Blur.BoxesForGaussian(Magnitude, 3);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("width", (float)width);
shader.SetUniform("height", (float)height);
//the direction to blur in
shader.SetUniform("tx", (float)Math.Cos(Direction));
shader.SetUniform("ty", -(float)Math.Sin(Direction));
//intensity / magnitude of motion blur
shader.SetUniform("magnitude", (boxes[0] - 1.0f) / 2.0f);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
for (int i = 1; i < 3; i++)
{
shader.SetUniform("magnitude", (boxes[i] - 1.0f) / 2.0f);
GL.ActiveTexture(TextureUnit.Texture0);
output.Bind();
GL.Clear(ClearBufferMask.DepthBufferBit);
GL.Clear(ClearBufferMask.ColorBufferBit);
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
}
public void Process(int width, int height, GLTextuer2D output)
{
CreateBuffersIfNeeded();
if (Mesh != null)
{
//bind our depth framebuffer
frameBuff.Bind();
GL.Viewport(0, 0, width, height);
GL.ClearColor(0, 0, 0, 0);
GL.Clear(ClearBufferMask.DepthBufferBit);
GL.Clear(ClearBufferMask.ColorBufferBit);
//draw in depth
Mesh.DrawForDepth();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
GLFrameBuffer.Unbind();
}
Process(width, height, output, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
output.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
shader.SetUniform("width", (float)width);
shader.SetUniform("height", (float)height);
shader.SetUniform("azimuth", Azimuth);
shader.SetUniform("elevation", Elevation);
GL.ActiveTexture(0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
void Process()
{
GLTextuer2D i1 = (GLTextuer2D)input.Input.Data;
if (i1 == null)
{
return;
}
if (i1.Id == 0)
{
return;
}
CreateBufferIfNeeded();
curveLUT.Bind();
curveLUT.SetData(lutBrush.Image, GLInterfaces.PixelFormat.Rgba, 256, 2);
GLTextuer2D.Unbind();
processor.TileX = tileX;
processor.TileY = tileY;
processor.Process(width, height, i1, buffer);
processor.Complete();
Updated();
Output.Data = buffer;
Output.Changed();
}
private void Glview_Load(object sender, EventArgs e)
{
ViewContext.VerifyContext(glview);
ViewContext.Context.MakeCurrent(glview.WindowInfo);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
if (quad == null)
{
quad = new FullScreenQuad();
}
if (processor == null)
{
processor = new PreviewProcessor();
}
blankTexture = new GLTextuer2D(GLInterfaces.PixelInternalFormat.Rgb);
blankTexture.Bind();
blankTexture.SetData(IntPtr.Zero, GLInterfaces.PixelFormat.Rgb, 16, 16);
GLTextuer2D.Unbind();
Invalidate();
}
public void Blend(GLTextuer2D piece, GLTextuer2D whole)
{
IGL.Primary.Clear((int)ClearBufferMask.ColorBufferBit | (int)ClearBufferMask.DepthBufferBit);
if (shader != null)
{
shader.Use();
shader.SetUniform("blendMode", (int)Blending);
shader.SetUniform("MainTex", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
piece.Bind();
shader.SetUniform("Background", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
whole.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
Blit(whole, whole.Width, whole.Height);
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
ResizeViewTo(tex, output, tex.Width, tex.Height, width, height);
tex = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform("MainTex", 0);
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("invertRed", Red);
shader.SetUniform("invertGreen", Green);
shader.SetUniform("invertBlue", Blue);
shader.SetUniform("invertAlpha", Alpha);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
protected void ResizeViewTo(GLTextuer2D inc, GLTextuer2D o, int owidth, int oheight, int nwidth, int nheight)
{
float wp = (float)nwidth / (float)owidth;
float hp = (float)nheight / (float)oheight;
float fp = wp < hp ? wp : hp;
Matrix4 proj = Matrix4.CreateOrthographic(nwidth, nheight, 0.03f, 1000f);
Matrix4 translation = Matrix4.CreateTranslation(0, 0, 0);
//half width/height for scale as it is centered based
Matrix4 sm = Matrix4.CreateScale(fp * (float)(owidth * 0.5f), -fp * (float)(oheight * 0.5f), 1);
Matrix4 model = sm * translation;
Matrix4 view = Matrix4.LookAt(new Vector3(0, 0, 1), Vector3.Zero, Vector3.UnitY);
resizeProcessor.Model = model;
resizeProcessor.View = view;
resizeProcessor.Projection = proj;
resizeProcessor.Bind(inc);
if (renderQuad != null)
{
renderQuad.Draw();
}
resizeProcessor.Unbind();
o.Bind();
o.CopyFromFrameBuffer(nwidth, nheight);
GLTextuer2D.Unbind();
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
ResizeViewTo(tex, output, tex.Width, tex.Height, width, height);
tex = output;
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector3 min = Min;
Vector3 max = Max;
Vector3 mid = Mid;
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
shader.SetUniform3("maxValues", ref max);
shader.SetUniform3("minValues", ref min);
shader.SetUniform3("midValues", ref mid);
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Matrix3 rot = Rotation;
Matrix3 sc = Scale;
Vector3 tr = Translation;
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
shader.SetUniformMatrix3("rotation", ref rot);
shader.SetUniformMatrix3("scale", ref sc);
shader.SetUniform3("translation", ref tr);
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D warp, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
shader.SetUniform("intensity", Intensity);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
shader.SetUniform("Warp", 1);
GL.ActiveTexture(TextureUnit.Texture1);
warp.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
ResizeViewTo(tex, output, tex.Width, tex.Height, width, height);
tex = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
shader.SetUniform("directx", DirectX);
shader.SetUniform("intensity", Intensity);
shader.SetUniform("width", (float)width);
shader.SetUniform("height", (float)height);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform("MainTex", 0);
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("invertRed", Red);
shader.SetUniform("invertGreen", Green);
shader.SetUniform("invertBlue", Blue);
shader.SetUniform("invertAlpha", Alpha);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public void Process(int width, int height, GLTextuer2D blur, GLTextuer2D orig, GLTextuer2D output)
{
base.Process(width, height, blur, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
blur.Bind();
shader.SetUniform("Original", 1);
GL.ActiveTexture(TextureUnit.Texture1);
orig.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D other, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("redChannel", RedChannel);
shader.SetUniform("greenChannel", GreenChannel);
shader.SetUniform("blueChannel", BlueChannel);
shader.SetUniform("alphaChannel", AlphaChannel);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
shader.SetUniform("Other", 1);
GL.ActiveTexture(TextureUnit.Texture1);
other.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("width", (float)width);
shader.SetUniform("height", (float)height);
shader.SetUniform("radius", Radius);
shader.SetUniform("outline", Outline);
if (renderQuad != null)
{
renderQuad.Draw();
}
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
}
}
void LoadDefaultTextures()
{
lightMat = new Material.PBRLight();
if (defaultBlack == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0f, 0f, 0f, 1);
defaultBlack = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultBlack.Bind();
defaultBlack.SetData(black.Image, GLInterfaces.PixelFormat.Rgba, 128, 128);
defaultBlack.GenerateMipMaps();
defaultBlack.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultBlack.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
Materia.Nodes.Atomic.MeshNode.DefaultBlack = defaultBlack;
}
if (defaultWhite == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 1f, 1f, 1f, 1);
defaultWhite = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultWhite.Bind();
defaultWhite.SetData(black.Image, GLInterfaces.PixelFormat.Rgba, 128, 128);
defaultWhite.GenerateMipMaps();
defaultWhite.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultWhite.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
Materia.Nodes.Atomic.MeshNode.DefaultWhite = defaultWhite;
}
if (defaultGray == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0.5f, 0.5f, 0.5f, 1);
defaultGray = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultGray.Bind();
defaultGray.SetData(black.Image, GLInterfaces.PixelFormat.Rgba, 128, 128);
defaultGray.GenerateMipMaps();
defaultGray.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultGray.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
}
if (defaultDarkGray == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0.25f, 0.25f, 0.25f, 1);
defaultDarkGray = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultDarkGray.Bind();
defaultDarkGray.SetData(black.Image, GLInterfaces.PixelFormat.Rgba, 128, 128);
defaultDarkGray.GenerateMipMaps();
defaultDarkGray.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultDarkGray.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
Materia.Nodes.Atomic.MeshNode.DefaultDarkGray = defaultDarkGray;
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D other, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
GLTextuer2D tempColor = new GLTextuer2D(tex.InternalFormat);
tempColor.Bind();
tempColor.SetData(IntPtr.Zero, PixelFormat.Rgba, tex.Width, tex.Height);
if (tex.InternalFormat == PixelInternalFormat.R16f || tex.InternalFormat == PixelInternalFormat.R32f)
{
tempColor.SetSwizzleLuminance();
}
else if (tex.IsRGBBased)
{
tempColor.SetSwizzleRGB();
}
tempColor.SetFilter((int)TextureMinFilter.Linear, (int)TextureMagFilter.Linear);
GLTextuer2D.Unbind();
ResizeViewTo(tex, tempColor, tex.Width, tex.Height, width, height);
tex = tempColor;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
ResizeViewTo(other, output, other.Width, other.Height, width, height);
other = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("redChannel", RedChannel);
shader.SetUniform("greenChannel", GreenChannel);
shader.SetUniform("blueChannel", BlueChannel);
shader.SetUniform("alphaChannel", AlphaChannel);
shader.SetUniform("MainTex", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
shader.SetUniform("Other", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
other.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
Blit(output, width, height);
tempColor.Release();
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D tex2, GLTextuer2D tex3, GLTextuer2D tex4, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (Shader != null)
{
Vector2 tiling = new Vector2(TileX, TileY);
Shader.Use();
Shader.SetUniform2("tiling", ref tiling);
Shader.SetUniform("Input0", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
if (tex != null)
{
tex.Bind();
}
Shader.SetUniform("Input1", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
if (tex2 != null)
{
tex2.Bind();
}
Shader.SetUniform("Input2", 2);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture2);
if (tex3 != null)
{
tex3.Bind();
}
Shader.SetUniform("Input3", 3);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture3);
if (tex4 != null)
{
tex4.Bind();
}
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
public CurvesNode(int w, int h, GraphPixelType p = GraphPixelType.RGBA)
{
Name = "Curves";
Id = Guid.NewGuid().ToString();
width = w;
height = h;
minValue = 0;
maxValue = 1;
points = new Dictionary <int, List <Point> >();
previewProcessor = new BasicImageRenderer();
tileX = tileY = 1;
lutBrush = new FloatBitmap(256, 2);
internalPixelType = p;
curveLUT = new GLTextuer2D(GLInterfaces.PixelInternalFormat.Rgba8);
curveLUT.Bind();
curveLUT.SetFilter((int)GLInterfaces.TextureMinFilter.Nearest, (int)GLInterfaces.TextureMagFilter.Nearest);
curveLUT.SetWrap((int)GLInterfaces.TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
processor = new CurvesProcessor(curveLUT);
//set defaults
List <Point> pts = new List <Point>();
pts.Add(new Point(0, 1));
pts.Add(new Point(1, 0));
points[0] = pts;
points[1] = pts;
points[2] = pts;
points[3] = pts;
input = new NodeInput(NodeType.Color | NodeType.Gray, this, "Image Input");
Output = new NodeOutput(NodeType.Color | NodeType.Gray, this);
input.OnInputAdded += Input_OnInputAdded;
input.OnInputChanged += Input_OnInputChanged;
input.OnInputRemoved += Input_OnInputRemoved;
Inputs = new List <NodeInput>();
Inputs.Add(input);
Outputs = new List <NodeOutput>();
Outputs.Add(Output);
}
void Process()
{
GLTextuer2D i1 = (GLTextuer2D)input.Input.Data;
GLTextuer2D i2 = null;
if (input2.HasInput)
{
if (input2.Input.Data != null)
{
i2 = (GLTextuer2D)input2.Input.Data;
}
}
if (i1 == null)
{
return;
}
if (i1.Id == 0)
{
return;
}
if (colorLUT == null || colorLUT.Id == 0)
{
colorLUT = new GLTextuer2D(PixelInternalFormat.Rgba8);
}
if (LUT == null)
{
LUT = new FloatBitmap(256, 2);
}
//generate gradient
Utils.CreateGradient(LUT, gradient.positions, gradient.colors);
colorLUT.Bind();
colorLUT.SetData(LUT.Image, PixelFormat.Rgba, 256, 2);
colorLUT.SetFilter((int)TextureMinFilter.Linear, (int)TextureMagFilter.Linear);
GLTextuer2D.Unbind();
CreateBufferIfNeeded();
processor.TileX = tileX;
processor.TileY = tileY;
processor.ColorLUT = colorLUT;
processor.Mask = i2;
processor.Process(width, height, i1, buffer);
processor.Complete();
Output.Data = buffer;
Output.Changed();
Updated();
}
public void Process(int width, int height, GLTextuer2D blur, GLTextuer2D orig, GLTextuer2D output)
{
base.Process(width, height, blur, output);
if (shader != null)
{
GLTextuer2D tempColor = new GLTextuer2D(blur.InternalFormat);
tempColor.Bind();
tempColor.SetData(IntPtr.Zero, PixelFormat.Rgba, blur.Width, blur.Height);
if (blur.InternalFormat == PixelInternalFormat.R16f || blur.InternalFormat == PixelInternalFormat.R32f)
{
tempColor.SetSwizzleLuminance();
}
else if (blur.IsRGBBased)
{
tempColor.SetSwizzleRGB();
}
tempColor.SetFilter((int)TextureMinFilter.Linear, (int)TextureMagFilter.Linear);
GLTextuer2D.Unbind();
ResizeViewTo(blur, tempColor, blur.Width, blur.Height, width, height);
blur = tempColor;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
ResizeViewTo(orig, output, orig.Width, orig.Height, width, height);
orig = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
blur.Bind();
shader.SetUniform("Original", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
orig.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
tempColor.Release();
}
}
void LoadDefaultTextures()
{
if (defaultBlack == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0f, 0f, 0f, 1);
defaultBlack = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultBlack.Bind();
defaultBlack.SetData(black.Image, OpenTK.Graphics.OpenGL.PixelFormat.Rgba, 128, 128);
defaultBlack.GenerateMipMaps();
defaultBlack.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultBlack.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
}
if (defaultWhite == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 1f, 1f, 1f, 1);
defaultWhite = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultWhite.Bind();
defaultWhite.SetData(black.Image, OpenTK.Graphics.OpenGL.PixelFormat.Rgba, 128, 128);
defaultWhite.GenerateMipMaps();
defaultWhite.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultWhite.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
}
if (defaultGray == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0.5f, 0.5f, 0.5f, 1);
defaultGray = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultGray.Bind();
defaultGray.SetData(black.Image, OpenTK.Graphics.OpenGL.PixelFormat.Rgba, 128, 128);
defaultGray.GenerateMipMaps();
defaultGray.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultGray.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
}
if (defaultDarkGray == null)
{
FloatBitmap black = new FloatBitmap(128, 128);
Nodes.Helpers.Utils.Fill(black, 0, 0, 0.25f, 0.25f, 0.25f, 1);
defaultDarkGray = new GLTextuer2D(PixelInternalFormat.Rgba8);
defaultDarkGray.Bind();
defaultDarkGray.SetData(black.Image, OpenTK.Graphics.OpenGL.PixelFormat.Rgba, 128, 128);
defaultDarkGray.GenerateMipMaps();
defaultDarkGray.SetFilter((int)TextureMinFilter.LinearMipmapLinear, (int)TextureMagFilter.Linear);
defaultDarkGray.SetWrap((int)TextureWrapMode.Repeat);
GLTextuer2D.Unbind();
}
}
void Process()
{
if (!input.HasInput)
{
return;
}
GLTextuer2D i1 = (GLTextuer2D)input.Reference.Data;
GLTextuer2D i2 = null;
if (input2.HasInput)
{
i2 = (GLTextuer2D)input2.Reference.Data;
}
if (i1 == null)
{
return;
}
if (i1.Id == 0)
{
return;
}
if (processor == null)
{
return;
}
if (colorLUT == null || colorLUT.Id == 0)
{
colorLUT = new GLTextuer2D(PixelInternalFormat.Rgba8);
}
colorLUT.Bind();
colorLUT.SetData(LUT.Image, PixelFormat.Rgba, 256, 2);
colorLUT.SetFilter((int)TextureMinFilter.Linear, (int)TextureMagFilter.Linear);
GLTextuer2D.Unbind();
CreateBufferIfNeeded();
processor.TileX = tileX;
processor.TileY = tileY;
processor.ColorLUT = colorLUT;
processor.Mask = i2;
processor.Process(width, height, i1, buffer);
processor.Complete();
Output.Data = buffer;
TriggerTextureChange();
}
public override void Process(int width, int height, GLTextuer2D tex, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
ResizeViewTo(tex, output, tex.Width, tex.Height, width, height);
tex = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform("MainTex", 0);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
shader.SetUniform("ColorLUT", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
ColorLUT.Bind();
shader.SetUniform("horizontal", Horizontal);
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("Mask", 2);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture2);
if (Mask != null)
{
UseMask = true;
Mask.Bind();
}
else
{
UseMask = false;
}
shader.SetUniform("useMask", UseMask);
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D warp, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
ResizeViewTo(tex, output, tex.Width, tex.Height, width, height);
tex = output;
IGL.Primary.Clear((int)(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit));
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("MainTex", 0);
shader.SetUniform("intensity", Intensity);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture0);
tex.Bind();
tex.ClampToEdge();
shader.SetUniform("Warp", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
warp.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
tex.Bind();
tex.Repeat();
GLTextuer2D.Unbind();
//output.Bind();
//output.CopyFromFrameBuffer(width, height);
//GLTextuer2D.Unbind();
Blit(output, width, height);
}
}
public void Process(FunctionGraph graph, int width, int height, GLTextuer2D tex, GLTextuer2D tex2, GLTextuer2D tex3, GLTextuer2D tex4, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (Shader != null)
{
Shader.Use();
if (output != null)
{
output.Bind();
output.BindAsImage(0, false, true);
}
Shader.SetUniform("Input0", 1);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture1);
if (tex != null)
{
tex.Bind();
}
Shader.SetUniform("Input1", 2);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture2);
if (tex2 != null)
{
tex2.Bind();
}
Shader.SetUniform("Input2", 3);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture3);
if (tex3 != null)
{
tex3.Bind();
}
Shader.SetUniform("Input3", 4);
IGL.Primary.ActiveTexture((int)TextureUnit.Texture4);
if (tex4 != null)
{
tex4.Bind();
}
graph.AssignUniforms();
IGL.Primary.DispatchCompute(width / 8, height / 8, 1);
GLTextuer2D.UnbindAsImage(0);
GLTextuer2D.Unbind();
}
}
public void Process(int width, int height, GLTextuer2D tex, GLTextuer2D other, GLTextuer2D output)
{
base.Process(width, height, tex, output);
if (shader != null)
{
GLTextuer2D tempColor = new GLTextuer2D(PixelInternalFormat.Rgba);
tempColor.Bind();
tempColor.SetFilter((int)TextureMinFilter.Linear, (int)TextureMagFilter.Linear);
GLTextuer2D.Unbind();
ResizeViewTo(tex, tempColor, tex.Width, tex.Height, width, height);
tex = tempColor;
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
ResizeViewTo(other, output, other.Width, other.Height, width, height);
other = output;
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
Vector2 tiling = new Vector2(TileX, TileY);
shader.Use();
shader.SetUniform2("tiling", ref tiling);
shader.SetUniform("redChannel", RedChannel);
shader.SetUniform("greenChannel", GreenChannel);
shader.SetUniform("blueChannel", BlueChannel);
shader.SetUniform("alphaChannel", AlphaChannel);
shader.SetUniform("MainTex", 0);
GL.ActiveTexture(TextureUnit.Texture0);
tex.Bind();
shader.SetUniform("Other", 1);
GL.ActiveTexture(TextureUnit.Texture1);
other.Bind();
if (renderQuad != null)
{
renderQuad.Draw();
}
GLTextuer2D.Unbind();
output.Bind();
output.CopyFromFrameBuffer(width, height);
GLTextuer2D.Unbind();
tempColor.Release();
}
}