public unsafe void Run(Texture2d tex, Size InputSize, Size OutputSize, bool flip) { //ack! make sure to set the pipeline before setting Bind(); Pipeline["InputSize"].Set(new Vector2(InputSize.Width,InputSize.Height)); Pipeline["TextureSize"].Set(new Vector2(InputSize.Width, InputSize.Height)); Pipeline["OutputSize"].Set(new Vector2(OutputSize.Width, OutputSize.Height)); Pipeline["FrameCount"].Set(0); //todo Pipeline["FrameDirection"].Set(1); //todo var Projection = Owner.CreateGuiProjectionMatrix(OutputSize); var Modelview = Owner.CreateGuiViewMatrix(OutputSize); Pipeline["MVPMatrix"].Set(Modelview * Projection, false); Owner.SetTextureWrapMode(tex, true); Pipeline["Texture"].Set(tex); Owner.SetViewport(OutputSize); int w = OutputSize.Width; int h = OutputSize.Height; float v0,v1; if (flip) { v0 = 1; v1 = 0; } else { v0 = 0; v1 = 1; } float* pData = stackalloc float[10*4]; int i=0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 1; //topleft vert pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; //junk pData[i++] = 0; pData[i++] = v0; //texcoord pData[i++] = w; pData[i++] = 0; pData[i++] = 0; pData[i++] = 1; //topright vert pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; //junk pData[i++] = 1; pData[i++] = v0; //texcoord pData[i++] = 0; pData[i++] = h; pData[i++] = 0; pData[i++] = 1; //bottomleft vert pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; //junk pData[i++] = 0; pData[i++] = v1; //texcoord pData[i++] = w; pData[i++] = h; pData[i++] = 0; pData[i++] = 1; //bottomright vert pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; pData[i++] = 0; //junk pData[i++] = 1; pData[i++] = v1; //texcoord Owner.SetBlendState(Owner.BlendNoneCopy); Owner.BindArrayData(pData); Owner.DrawArrays(PrimitiveType.TriangleStrip, 0, 4); }
public void TestCreate() { Texture2d texture = null; // Create(uint, uint, PixelLayout) try { texture = new Texture2d(); Assert.IsFalse(texture.Exists(_Context)); texture.Create(16, 16, PixelLayout.RGB24); Assert.IsFalse(texture.Exists(_Context)); texture.Create(_Context); Assert.IsTrue(texture.Exists(_Context)); } finally { if (texture != null) texture.Dispose(_Context); texture = null; } // Create(GraphicsContext, uint, uint, PixelLayout) try { texture = new Texture2d(); Assert.IsFalse(texture.Exists(_Context)); texture.Create(_Context, 16, 32, PixelLayout.RGB24); Assert.IsTrue(texture.Exists(_Context)); Assert.AreEqual(16, texture.Width); Assert.AreEqual(32, texture.Height); Assert.AreEqual(PixelLayout.RGB24, texture.PixelLayout); } finally { if (texture != null) texture.Dispose(_Context); texture = null; } }
/// <summary> /// Attach a 2D texture image to color buffer. /// </summary> /// <param name="texture"> /// A <see cref="Texture2d"/> which will be used for read/write operation on this RenderFrambuffer. /// </param> /// <param name="attachmentIndex"> /// A <see cref="UInt32"/> that specify the framebuffer color attachment index. /// </param> public void AttachColor(Texture2d texture, uint attachmentIndex) { AttachColor(texture, attachmentIndex, 0); }
public void TexParameter2d(Texture2d tex, TextureParameterName pName, int param) { BindTexture2d(tex); GL.TexParameter(TextureTarget.Texture2D, pName, param); }
public sd.Bitmap BitmapForTexture(Texture2d tex) { return(TextureWrapperForTexture(tex).SDBitmap); }
public void LoadTextureData(Texture2d tex, BitmapBuffer bmp) { bmp.ToSysdrawingBitmap(BitmapForTexture(tex)); }
public void Draw(Texture2d tex, float x, float y) { DrawInternal(tex, x, y, tex.Width, tex.Height); }
public void FreeTexture(Texture2d tex) { GL.DeleteTexture((int)tex.Opaque); }
private void initialize() { textureId = GL.GenTexture(); texture = new Texture2d(textureId, width, height, "rendertarget"); DrawState.BindPrimaryTexture(textureId); GL.TexImage2D(TextureTarget.Texture2D, 0, internalFormat, width, height, 0, pixelFormat, pixelType, IntPtr.Zero); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)textureMagFilter); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)textureMinFilter); GL.GetInteger(GetPName.FramebufferBinding, out previousFrameBufferId); frameBufferId = GL.GenFramebuffer(); GL.BindFramebuffer(FramebufferTarget.Framebuffer, frameBufferId); GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, textureId, 0); DrawState.CheckError("creating fbo"); if (renderBufferType != null) { renderBufferId = GL.GenRenderbuffer(); GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, renderBufferId); GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, renderBufferType.Value, width, height); switch (renderBufferType.Value) { case RenderbufferStorage.DepthComponent: case RenderbufferStorage.DepthComponent16: case RenderbufferStorage.DepthComponent24: case RenderbufferStorage.DepthComponent32: case RenderbufferStorage.DepthComponent32f: GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, renderBufferId); break; case RenderbufferStorage.DepthStencil: case RenderbufferStorage.Depth24Stencil8: case RenderbufferStorage.Depth32fStencil8: GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthStencilAttachment, RenderbufferTarget.Renderbuffer, renderBufferId); break; case RenderbufferStorage.StencilIndex1: case RenderbufferStorage.StencilIndex4: case RenderbufferStorage.StencilIndex8: case RenderbufferStorage.StencilIndex16: GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.StencilAttachment, RenderbufferTarget.Renderbuffer, renderBufferId); break; default: throw new NotSupportedException("renderBufferType " + renderBufferType.Value + " isn't supported."); } } var status = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer); if (status != FramebufferErrorCode.FramebufferComplete) { throw new Exception("frame buffer couldn't be constructed: " + status); } DrawState.UnbindTexture(textureId); GL.BindFramebuffer(FramebufferTarget.Framebuffer, previousFrameBufferId); Debug.Print(width + "x" + height + " render target created"); }
void UpdateSourceDrawingWork(JobInfo job) { //begin rendering on this context //should this have been done earlier? //do i need to check this on an intel video card to see if running excessively is a problem? (it used to be in the FinalTarget command below, shouldnt be a problem) //GraphicsControl.Begin(); GlobalWin.GL.BeginScene(); //run filter chain Texture2d texCurr = null; RenderTarget rtCurr = null; int rtCounter = 0; bool inFinalTarget = false; foreach (var step in CurrentFilterProgram.Program) { switch (step.Type) { case FilterProgram.ProgramStepType.Run: { int fi = (int)step.Args; var f = CurrentFilterProgram.Filters[fi]; f.SetInput(texCurr); f.Run(); var orec = f.FindOutput(); if (orec != null) { if (orec.SurfaceDisposition == SurfaceDisposition.Texture) { texCurr = f.GetOutput(); rtCurr = null; } } break; } case FilterProgram.ProgramStepType.NewTarget: { var size = (Size)step.Args; rtCurr = ShaderChainFrugalizers[rtCounter++].Get(size); rtCurr.Bind(); CurrentFilterProgram.CurrRenderTarget = rtCurr; break; } case FilterProgram.ProgramStepType.FinalTarget: { var size = (Size)step.Args; inFinalTarget = true; rtCurr = null; CurrentFilterProgram.CurrRenderTarget = null; GL.BindRenderTarget(null); break; } } } GL.EndScene(); if (job.offscreen) { job.offscreenBB = rtCurr.Texture2d.Resolve(); } else { Debug.Assert(inFinalTarget); //apply the vsync setting (should probably try to avoid repeating this) bool vsync = Global.Config.VSyncThrottle || Global.Config.VSync; //ok, now this is a bit undesireable. //maybe the user wants vsync, but not vsync throttle. //this makes sense... but we dont have the infrastructure to support it now (we'd have to enable triple buffering or something like that) //so what we're gonna do is disable vsync no matter what if throttling is off, and maybe nobody will notice. if (Global.DisableSecondaryThrottling) { vsync = false; } if (LastVsyncSetting != vsync || LastVsyncSettingGraphicsControl != presentationPanel.GraphicsControl) { if (LastVsyncSetting == null && vsync) { // Workaround for vsync not taking effect at startup (Intel graphics related?) presentationPanel.GraphicsControl.SetVsync(false); } presentationPanel.GraphicsControl.SetVsync(vsync); LastVsyncSettingGraphicsControl = presentationPanel.GraphicsControl; LastVsyncSetting = vsync; } //present and conclude drawing presentationPanel.GraphicsControl.SwapBuffers(); //nope. dont do this. workaround for slow context switching on intel GPUs. just switch to another context when necessary before doing anything //presentationPanel.GraphicsControl.End(); NeedsToPaint = false; //?? } }
FilterProgram UpdateSourceInternal(JobInfo job) { //no drawing actually happens. it's important not to begin drawing on a control if (!job.simulate) { GlobalWin.GLManager.Activate(CR_GraphicsControl); } IVideoProvider videoProvider = job.videoProvider; bool simulate = job.simulate; Size chain_outsize = job.chain_outsize; //simulate = true; int vw = videoProvider.BufferWidth; int vh = videoProvider.BufferHeight; if (Global.Config.DispFixAspectRatio) { if (Global.Config.DispManagerAR == Config.EDispManagerAR.System) { vw = videoProvider.VirtualWidth; vh = videoProvider.VirtualHeight; } if (Global.Config.DispManagerAR == Config.EDispManagerAR.Custom) { vw = Global.Config.DispCustomUserARWidth; vh = Global.Config.DispCustomUserARHeight; } } var padding = CalculateCompleteContentPadding(true, false); vw += padding.Horizontal; vh += padding.Vertical; int[] videoBuffer = videoProvider.GetVideoBuffer(); int bufferWidth = videoProvider.BufferWidth; int bufferHeight = videoProvider.BufferHeight; bool isGlTextureId = videoBuffer.Length == 1; BitmapBuffer bb = null; Texture2d videoTexture = null; if (!simulate) { if (isGlTextureId) { //FYI: this is a million years from happening on n64, since it's all geriatric non-FBO code //is it workable for saturn? videoTexture = GL.WrapGLTexture2d(new IntPtr(videoBuffer[0]), bufferWidth, bufferHeight); } else { //wrap the videoprovider data in a BitmapBuffer (no point to refactoring that many IVideoProviders) bb = new BitmapBuffer(bufferWidth, bufferHeight, videoBuffer); bb.DiscardAlpha(); //now, acquire the data sent from the videoProvider into a texture videoTexture = VideoTextureFrugalizer.Get(bb); //lets not use this. lets define BizwareGL to make clamp by default (TBD: check opengl) //GL.SetTextureWrapMode(videoTexture, true); } } //record the size of what we received, since lua and stuff is gonna want to draw onto it currEmuWidth = bufferWidth; currEmuHeight = bufferHeight; //build the default filter chain and set it up with services filters will need Size chain_insize = new Size(bufferWidth, bufferHeight); var filterProgram = BuildDefaultChain(chain_insize, chain_outsize, job.includeOSD); filterProgram.GuiRenderer = Renderer; filterProgram.GL = GL; //setup the source image filter Filters.SourceImage fInput = filterProgram["input"] as Filters.SourceImage; fInput.Texture = videoTexture; //setup the final presentation filter Filters.FinalPresentation fPresent = filterProgram["presentation"] as Filters.FinalPresentation; fPresent.VirtualTextureSize = new Size(vw, vh); fPresent.TextureSize = new Size(bufferWidth, bufferHeight); fPresent.BackgroundColor = videoProvider.BackgroundColor; fPresent.GuiRenderer = Renderer; fPresent.Config_FixAspectRatio = Global.Config.DispFixAspectRatio; fPresent.Config_FixScaleInteger = Global.Config.DispFixScaleInteger; fPresent.GL = GL; filterProgram.Compile("default", chain_insize, chain_outsize, !job.offscreen); if (simulate) { } else { CurrentFilterProgram = filterProgram; UpdateSourceDrawingWork(job); } //cleanup: if (bb != null) { bb.Dispose(); } return(filterProgram); }
void UpdateSourceDrawingWork(JobInfo job) { bool alternateVsync = false; // only used by alternate vsync IGL_SlimDX9 dx9 = null; if (!job.Offscreen) { //apply the vsync setting (should probably try to avoid repeating this) var vsync = Global.Config.VSyncThrottle || Global.Config.VSync; //ok, now this is a bit undesirable. //maybe the user wants vsync, but not vsync throttle. //this makes sense... but we don't have the infrastructure to support it now (we'd have to enable triple buffering or something like that) //so what we're gonna do is disable vsync no matter what if throttling is off, and maybe nobody will notice. //update 26-mar-2016: this upsets me. When fast-forwarding and skipping frames, vsync should still work. But I'm not changing it yet if (Global.DisableSecondaryThrottling) { vsync = false; } //for now, it's assumed that the presentation panel is the main window, but that may not always be true if (vsync && Global.Config.DispAlternateVsync && Global.Config.VSyncThrottle) { dx9 = GL as IGL_SlimDX9; if (dx9 != null) { alternateVsync = true; //unset normal vsync if we've chosen the alternate vsync vsync = false; } } //TODO - whats so hard about triple buffering anyway? just enable it always, and change api to SetVsync(enable,throttle) //maybe even SetVsync(enable,throttlemethod) or just SetVsync(enable,throttle,advanced) if (LastVsyncSetting != vsync || LastVsyncSettingGraphicsControl != presentationPanel.GraphicsControl) { if (LastVsyncSetting == null && vsync) { // Workaround for vsync not taking effect at startup (Intel graphics related?) presentationPanel.GraphicsControl.SetVsync(false); } presentationPanel.GraphicsControl.SetVsync(vsync); LastVsyncSettingGraphicsControl = presentationPanel.GraphicsControl; LastVsyncSetting = vsync; } } // begin rendering on this context // should this have been done earlier? // do i need to check this on an intel video card to see if running excessively is a problem? (it used to be in the FinalTarget command below, shouldn't be a problem) //GraphicsControl.Begin(); // CRITICAL POINT for yabause+GL //TODO - auto-create and age these (and dispose when old) int rtCounter = 0; _currentFilterProgram.RenderTargetProvider = new DisplayManagerRenderTargetProvider(size => ShaderChainFrugalizers[rtCounter++].Get(size)); GL.BeginScene(); // run filter chain Texture2d texCurr = null; RenderTarget rtCurr = null; bool inFinalTarget = false; foreach (var step in _currentFilterProgram.Program) { switch (step.Type) { case FilterProgram.ProgramStepType.Run: { int fi = (int)step.Args; var f = _currentFilterProgram.Filters[fi]; f.SetInput(texCurr); f.Run(); var orec = f.FindOutput(); if (orec != null) { if (orec.SurfaceDisposition == SurfaceDisposition.Texture) { texCurr = f.GetOutput(); rtCurr = null; } } break; } case FilterProgram.ProgramStepType.NewTarget: { var size = (Size)step.Args; rtCurr = ShaderChainFrugalizers[rtCounter++].Get(size); rtCurr.Bind(); _currentFilterProgram.CurrRenderTarget = rtCurr; break; } case FilterProgram.ProgramStepType.FinalTarget: { inFinalTarget = true; rtCurr = null; _currentFilterProgram.CurrRenderTarget = null; GL.BindRenderTarget(null); break; } } } GL.EndScene(); if (job.Offscreen) { job.OffscreenBb = rtCurr.Texture2d.Resolve(); job.OffscreenBb.DiscardAlpha(); } else { Debug.Assert(inFinalTarget); // wait for vsync to begin if (alternateVsync) { dx9.AlternateVsyncPass(0); } // present and conclude drawing presentationPanel.GraphicsControl.SwapBuffers(); // wait for vsync to end if (alternateVsync) { dx9.AlternateVsyncPass(1); } // nope. don't do this. workaround for slow context switching on intel GPUs. just switch to another context when necessary before doing anything // presentationPanel.GraphicsControl.End(); } }
public void TexParameter2d(Texture2d tex, TextureParameterName pname, int param) { BindTexture2d(tex); GL.TexParameter(TextureTarget.Texture2D, (global::OpenTK.Graphics.OpenGL.TextureParameterName)pname, param); }
private FilterProgram UpdateSourceInternal(JobInfo job) { //no drawing actually happens. it's important not to begin drawing on a control if (!job.Simulate && !job.Offscreen) { GLManager.Activate(CR_GraphicsControl); if (job.ChainOutsize.Width == 0 || job.ChainOutsize.Height == 0) { // this has to be a NOP, because lots of stuff will malfunction on a 0-sized viewport if (_currentFilterProgram != null) { UpdateSourceDrawingWork(job); //but we still need to do this, because of vsync } return null; } } IVideoProvider videoProvider = job.VideoProvider; bool simulate = job.Simulate; Size chainOutsize = job.ChainOutsize; //simulate = true; int[] videoBuffer = videoProvider.GetVideoBuffer(); int bufferWidth = videoProvider.BufferWidth; int bufferHeight = videoProvider.BufferHeight; int presenterTextureWidth = bufferWidth; int presenterTextureHeight = bufferHeight; bool isGlTextureId = videoBuffer.Length == 1; int vw = videoProvider.VirtualWidth; int vh = videoProvider.VirtualHeight; //TODO: it is bad that this is happening outside the filter chain //the filter chain has the ability to add padding... //for now, we have to have some hacks. this could be improved by refactoring the filter setup hacks to be in one place only though //could the PADDING be done as filters too? that would be nice. var fCoreScreenControl = CreateCoreScreenControl(); if(fCoreScreenControl != null) { var sz = fCoreScreenControl.PresizeInput("default", new Size(bufferWidth, bufferHeight)); presenterTextureWidth = vw = sz.Width; presenterTextureHeight = vh = sz.Height; } if (Global.Config.DispFixAspectRatio) { if (Global.Config.DispManagerAR == EDispManagerAR.System) { //Already set } if (Global.Config.DispManagerAR == EDispManagerAR.Custom) { //not clear what any of these other options mean for "screen controlled" systems vw = Global.Config.DispCustomUserARWidth; vh = Global.Config.DispCustomUserARHeight; } if (Global.Config.DispManagerAR == EDispManagerAR.CustomRatio) { //not clear what any of these other options mean for "screen controlled" systems FixRatio(Global.Config.DispCustomUserArx, Global.Config.DispCustomUserAry, videoProvider.BufferWidth, videoProvider.BufferHeight, out vw, out vh); } } var padding = CalculateCompleteContentPadding(true,false); vw += padding.Horizontal; vh += padding.Vertical; BitmapBuffer bb = null; Texture2d videoTexture = null; if (!simulate) { if (isGlTextureId) { //FYI: this is a million years from happening on n64, since it's all geriatric non-FBO code //is it workable for saturn? videoTexture = GL.WrapGLTexture2d(new IntPtr(videoBuffer[0]), bufferWidth, bufferHeight); } else { //wrap the VideoProvider data in a BitmapBuffer (no point to refactoring that many IVideoProviders) bb = new BitmapBuffer(bufferWidth, bufferHeight, videoBuffer); bb.DiscardAlpha(); //now, acquire the data sent from the videoProvider into a texture videoTexture = VideoTextureFrugalizer.Get(bb); // lets not use this. lets define BizwareGL to make clamp by default (TBD: check opengl) //GL.SetTextureWrapMode(videoTexture, true); } } // record the size of what we received, since lua and stuff is gonna want to draw onto it currEmuWidth = bufferWidth; currEmuHeight = bufferHeight; //build the default filter chain and set it up with services filters will need Size chainInsize = new Size(bufferWidth, bufferHeight); var filterProgram = BuildDefaultChain(chainInsize, chainOutsize, job.IncludeOSD, job.IncludeUserFilters); filterProgram.GuiRenderer = Renderer; filterProgram.GL = GL; //setup the source image filter Filters.SourceImage fInput = filterProgram["input"] as Filters.SourceImage; fInput.Texture = videoTexture; //setup the final presentation filter Filters.FinalPresentation fPresent = filterProgram["presentation"] as Filters.FinalPresentation; if (fPresent != null) { fPresent.VirtualTextureSize = new Size(vw, vh); fPresent.TextureSize = new Size(presenterTextureWidth, presenterTextureHeight); fPresent.BackgroundColor = videoProvider.BackgroundColor; fPresent.GuiRenderer = Renderer; fPresent.Flip = isGlTextureId; fPresent.Config_FixAspectRatio = Global.Config.DispFixAspectRatio; fPresent.Config_FixScaleInteger = Global.Config.DispFixScaleInteger; fPresent.Padding = ClientExtraPadding; fPresent.AutoPrescale = Global.Config.DispAutoPrescale; fPresent.GL = GL; } //POOPY. why are we delivering the GL context this way? such bad Filters.ScreenControlNDS fNDS = filterProgram["CoreScreenControl"] as Filters.ScreenControlNDS; if (fNDS != null) { fNDS.GuiRenderer = Renderer; fNDS.GL = GL; } filterProgram.Compile("default", chainInsize, chainOutsize, !job.Offscreen); if (simulate) { } else { _currentFilterProgram = filterProgram; UpdateSourceDrawingWork(job); } // cleanup: bb?.Dispose(); return filterProgram; }
public void AttachDepth(Texture2d texture) { AttachDepth(texture, 0); }
static unsafe void Main(string[] args) { BizHawk.Bizware.BizwareGL.IGL igl = new BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK(); List <Art> testArts = new List <Art>(); ArtManager am = new ArtManager(igl); foreach (var name in typeof(Program).Assembly.GetManifestResourceNames()) { if (name.Contains("flame")) { testArts.Add(am.LoadArt(typeof(Program).Assembly.GetManifestResourceStream(name))); } } var smile = am.LoadArt(typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.smile.png")); am.Close(true); StringRenderer sr; using (var xml = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.courier16px.fnt")) using (var tex = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.courier16px_0.png")) sr = new StringRenderer(igl, xml, tex); GuiRenderer gr = new GuiRenderer(igl); TestForm tf = new TestForm(); RetainedGraphicsControl c = new RetainedGraphicsControl(igl); tf.Controls.Add(c); c.Dock = System.Windows.Forms.DockStyle.Fill; tf.FormClosing += (object sender, System.Windows.Forms.FormClosingEventArgs e) => { tf.Controls.Remove(c); c.Dispose(); c = null; }; tf.Show(); //tf.Paint += (object sender, PaintEventArgs e) => c.Refresh(); c.SetVsync(false); //create a render target RenderTarget rt = igl.CreateRenderTarget(60, 60); rt.Bind(); igl.SetClearColor(Color.Blue); igl.Clear(ClearBufferMask.ColorBufferBit); gr.Begin(60, 60, true); gr.Draw(smile); gr.End(); rt.Unbind(); Texture2d rttex2d = igl.LoadTexture(rt.Texture2d.Resolve()); //test retroarch shader RenderTarget rt2 = igl.CreateRenderTarget(240, 240); rt2.Bind(); igl.SetClearColor(Color.CornflowerBlue); igl.Clear(ClearBufferMask.ColorBufferBit); RetroShader shader; using (var stream = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.4xSoft.glsl")) shader = new RetroShader(igl, new System.IO.StreamReader(stream).ReadToEnd()); igl.SetBlendState(igl.BlendNone); shader.Run(rttex2d, new Size(60, 60), new Size(240, 240), true); bool running = true; c.MouseClick += (object sender, MouseEventArgs e) => { if (e.Button == MouseButtons.Left) { running ^= true; } if (e.Button == MouseButtons.Right) { c.Retain ^= true; } }; DateTime start = DateTime.Now; int wobble = 0; for (; ;) { if (c == null) { break; } if (running) { c.Begin(); igl.SetClearColor(Color.Red); igl.Clear(ClearBufferMask.ColorBufferBit); int frame = (int)((DateTime.Now - start).TotalSeconds) % testArts.Count; gr.Begin(c.ClientSize.Width, c.ClientSize.Height); gr.SetBlendState(igl.BlendNormal); gr.SetModulateColor(Color.Green); gr.RectFill(250, 0, 16, 16); gr.SetBlendState(igl.BlendNone); gr.Draw(rttex2d, 0, 20); gr.SetBlendState(igl.BlendNormal); sr.RenderString(gr, 0, 0, "?? fps"); gr.SetModulateColor(Color.FromArgb(255, 255, 255, 255)); gr.SetCornerColor(0, OpenTK.Graphics.Color4.Red); gr.Draw(rt2.Texture2d, 0, 0); gr.SetCornerColor(0, OpenTK.Graphics.Color4.White); gr.SetModulateColorWhite(); gr.Modelview.Translate((float)Math.Sin(wobble / 360.0f) * 50, 0); gr.Modelview.Translate(100, 100); gr.Modelview.Push(); gr.Modelview.Translate(testArts[frame].Width, 0); gr.Modelview.Scale(-1, 1); wobble++; gr.SetModulateColor(Color.Yellow); gr.DrawFlipped(testArts[frame], true, false); gr.SetModulateColorWhite(); gr.Modelview.Pop(); gr.SetBlendState(igl.BlendNormal); gr.Draw(smile); gr.End(); c.SwapBuffers(); c.End(); } System.Windows.Forms.Application.DoEvents(); System.Threading.Thread.Sleep(0); } }
public void SetTextureWrapMode(Texture2d tex, bool clamp) { var tw = tex.Opaque as TextureWrapper; tw.WrapClamp = clamp ? TextureAddress.Clamp : TextureAddress.Wrap; }
public void DrawSubrect(Texture2d tex, float x, float y, float w, float h, float u0, float v0, float u1, float v1) { var tw = tex.Opaque as IGL_GdiPlus.TextureWrapper; var g = Gdi.GetCurrentGraphics(); PrepDraw(g, tex); SetupMatrix(g); float x0 = u0 * tex.Width; float y0 = v0 * tex.Height; float x1 = u1 * tex.Width; float y1 = v1 * tex.Height; sd.PointF[] destPoints = new sd.PointF[] { new sd.PointF(x,y), new sd.PointF(x+w,y), new sd.PointF(x,y+h), }; g.DrawImage(tw.SDBitmap, destPoints, new sd.RectangleF(x0, y0, x1 - x0, y1 - y0), sd.GraphicsUnit.Pixel, CurrentImageAttributes); g.Transform = new sd.Drawing2D.Matrix(); //.Reset() doesnt work ? ? }
public void SetPipelineUniformSampler(PipelineUniform uniform, Texture2d tex) { }
void PrepDraw(sd.Graphics g, Texture2d tex) { var tw = tex.Opaque as IGL_GdiPlus.TextureWrapper; //TODO - we can support bicubic for the final presentation.. if ((int)tw.MagFilter != (int)tw.MinFilter) throw new InvalidOperationException("tw.MagFilter != tw.MinFilter"); if (tw.MagFilter == TextureMagFilter.Linear) g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.Bilinear; if (tw.MagFilter == TextureMagFilter.Nearest) g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor; //--------- if (CurrentBlendState == Gdi.BlendNormal) { g.CompositingMode = sd.Drawing2D.CompositingMode.SourceOver; g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.Default; //? //CurrentImageAttributes.ClearColorMatrix(ColorAdjustType.Bitmap); } else //if(CurrentBlendState == Gdi.BlendNoneCopy) //if(CurrentBlendState == Gdi.BlendNoneOpaque) { g.CompositingMode = sd.Drawing2D.CompositingMode.SourceCopy; g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighSpeed; //WARNING : DO NOT USE COLOR MATRIX TO WIPE THE ALPHA //ITS SOOOOOOOOOOOOOOOOOOOOOOOOOOOO SLOW //instead, we added kind of hacky support for 24bpp images } }
public void LoadTextureData(Texture2d tex, BitmapBuffer bmp) { var tw = tex.Opaque as GDIPTextureWrapper; bmp.ToSysdrawingBitmap(tw.SDBitmap); }
unsafe void DrawInternal(Texture2d tex, float x, float y, float w, float h) { var tw = Gdi.TextureWrapperForTexture(tex); var g = Gdi.GetCurrentGraphics(); PrepDraw(g, tw); //a little bit of a fastpath.. I think it's safe //if (w == tex.Width && h == tex.Height && x == (int)x && y == (int)y) // g.DrawImageUnscaled(tw.SDBitmap, (int)x, (int)y); //else { sd.PointF[] destPoints = new sd.PointF[] { new sd.PointF(x,y), new sd.PointF(x+w,y), new sd.PointF(x,y+h), }; //g.DrawImage(tw.SDBitmap, x, y, w, h); //original g.DrawImage(tw.SDBitmap, destPoints, new sd.RectangleF(0, 0, tex.Width, tex.Height), sd.GraphicsUnit.Pixel, CurrentImageAttributes); } }
public void FreeTexture(Texture2d tex) { var tw = tex.Opaque as GDIPTextureWrapper; tw.Dispose(); }
public unsafe BitmapBuffer ResolveTexture2d(Texture2d tex) { //todo return(null); }
public void SetTextureWrapMode(Texture2d tex, bool clamp) { }
public TextureWrapper TextureWrapperForTexture(Texture2d tex) { return(ResourceIDs.Lookup[tex.Id.ToInt32()] as TextureWrapper); }
public void SetInput(Texture2d tex) { InputTexture = tex; }
/// <summary> /// Attach a 2D texture image to color buffer. /// </summary> /// <param name="texture"> /// A <see cref="Texture2d"/> which will be used for read/write operation on this RenderFrambuffer. /// </param> public void AttachColor(Texture2d texture) { AttachColor(texture, 0, 0); }
// filter actions protected void YieldOutput(Texture2d tex) { _outputTexture = tex; }
/// <summary> /// Attach a 2D texture image to color buffer. /// </summary> /// <param name="texture"> /// A <see cref="Texture"/> which will be used for read/write operation on this RenderFrambuffer. /// </param> /// <param name="level"> /// A <see cref="UInt32"/> that specify the texture level to bind. /// </param> /// <param name="attachmentIndex"> /// A <see cref="UInt32"/> that specify the framebuffer color attachment index. /// </param> public void AttachColor(Texture2d texture, uint attachmentIndex, uint level) { if ((level != 0) && (level > (uint)Math.Log(level, 2.0))) throw new ArgumentException("level greater than maximum allowed"); AttachColor(new RenderTextureAttachment(texture, level), attachmentIndex); }
private void VisionControl_ContextCreated(object sender, OpenGL.GlControlEventArgs e) { // Create GL context abstraction _GraphicsContext = new GraphicsContext(e.DeviceContext, e.RenderContext); // Create texture _FramebufferTexture = new Texture2d(1024, 1024, PixelLayout.RGB24); _FramebufferTexture.SamplerParams.MagFilter = TextureMagFilter.Linear; _FramebufferTexture.SamplerParams.MinFilter = TextureMinFilter.Linear; _FramebufferTexture.Create(_GraphicsContext); // Create framebuffer _Framebuffer = new Framebuffer(); _Framebuffer.AttachColor(0, _FramebufferTexture); _Framebuffer.Create(_GraphicsContext); // Create shader (standard) _ProgramStd = _GraphicsContext.CreateProgram("OpenGL.Standard"); _ProgramStd.Create(_GraphicsContext); // Create program (standard + texture) _ProgramStdTex = _GraphicsContext.CreateProgram("OpenGL.Standard+Texture"); _ProgramStdTex.Create(_GraphicsContext); // Create vertex arrays (square) ArrayBuffer <Vertex2f> quadBuffer = new ArrayBuffer <Vertex2f>(BufferUsage.StaticDraw); quadBuffer.Create(new Vertex2f[] { new Vertex2f(-0.5f, +0.5f), new Vertex2f(-0.5f, -0.5f), new Vertex2f(+0.5f, +0.5f), new Vertex2f(+0.5f, -0.5f), }); _ArraysQuad = new VertexArrays(); _ArraysQuad.SetArray(quadBuffer, VertexArraySemantic.Position); _ArraysQuad.SetElementArray(PrimitiveType.TriangleStrip); _ArraysQuad.Create(_GraphicsContext); // Create vertex arrays (square) ArrayBuffer <Vertex2f> postquadBuffer = new ArrayBuffer <Vertex2f>(BufferUsage.StaticDraw); postquadBuffer.Create(new Vertex2f[] { new Vertex2f(0.0f, 1.0f), new Vertex2f(0.0f, 0.0f), new Vertex2f(1.0f, 1.0f), new Vertex2f(1.0f, 0.0f), }); _ArraysPostQuad = new VertexArrays(); _ArraysPostQuad.SetArray(postquadBuffer, VertexArraySemantic.Position); _ArraysPostQuad.SetArray(postquadBuffer, VertexArraySemantic.TexCoord); _ArraysPostQuad.SetElementArray(PrimitiveType.TriangleStrip); _ArraysPostQuad.Create(_GraphicsContext); // Create vertex arrays (optical markers) _BufferOpticalMarkers = new ArrayBuffer <Vertex2f>(BufferUsage.DynamicDraw); _BufferOpticalMarkers.Create(10000 * 2); _ArraysOpticalMarkers = new VertexArrays(); _ArraysOpticalMarkers.SetArray(_BufferOpticalMarkers, VertexArraySemantic.Position); _ArraysOpticalMarkers.SetElementArray(PrimitiveType.Lines); _ArraysOpticalMarkers.Create(_GraphicsContext); }
public void AttachDepth(Texture2d texture, uint level) { AttachDepth(new RenderTextureAttachment(texture, level)); }
private void SetSphereMaterial(SceneObjectGeometry sphere, string material) { MaterialState sphereMaterial = new MaterialState(); sphereMaterial.FrontMaterial = new MaterialState.Material(ColorRGBAF.ColorWhite); sphereMaterial.FrontMaterial.Ambient = ColorRGBAF.ColorWhite * 0.2f; sphereMaterial.FrontMaterial.Diffuse = ColorRGBAF.ColorWhite * 0.8f; sphereMaterial.FrontMaterial.Specular = ColorRGBAF.ColorWhite * 1.0f; sphereMaterial.FrontMaterial.Shininess = 32.0f; sphere.ObjectState.DefineState(sphereMaterial); if (material == null) { return; } string basePath = Path.Combine("Data", "PhotosculptTextures"); string textureFilename, texturePath; textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "diffuse"); texturePath = Path.Combine(basePath, textureFilename); if (File.Exists(texturePath)) { try { Image textureImage = ImageCodec.Instance.Load(texturePath); Texture2d texture = new Texture2d(); texture.RequestMipmapsCreation(); texture.WrapCoordR = Texture.Wrap.MirroredRepeat; texture.WrapCoordS = Texture.Wrap.MirroredRepeat; texture.Create(textureImage); sphereMaterial.FrontMaterialDiffuseTexture = texture; sphereMaterial.FrontMaterialDiffuseTexCoord = 0; } catch (Exception exception) { throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception); } } textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "normal"); texturePath = Path.Combine(basePath, textureFilename); if (File.Exists(texturePath)) { try { Image textureImage = ImageCodec.Instance.Load(texturePath); Texture2d texture = new Texture2d(); texture.RequestMipmapsCreation(); texture.WrapCoordR = Texture.Wrap.MirroredRepeat; texture.WrapCoordS = Texture.Wrap.MirroredRepeat; texture.Create(textureImage); sphereMaterial.FrontMaterialNormalTexture = texture; sphereMaterial.FrontMaterialNormalTexCoord = 0; } catch (Exception exception) { throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception); } } textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "specular"); texturePath = Path.Combine(basePath, textureFilename); if (File.Exists(texturePath)) { try { Image textureImage = ImageCodec.Instance.Load(texturePath); Texture2d texture = new Texture2d(); texture.RequestMipmapsCreation(); texture.WrapCoordR = Texture.Wrap.MirroredRepeat; texture.WrapCoordS = Texture.Wrap.MirroredRepeat; texture.Create(textureImage); sphereMaterial.FrontMaterialSpecularTexture = texture; sphereMaterial.FrontMaterialSpecularTexCoord = 0; } catch (Exception exception) { throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception); } } textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "ambientocclusion"); texturePath = Path.Combine(basePath, textureFilename); if (File.Exists(texturePath)) { try { Image textureImage = ImageCodec.Instance.Load(texturePath); Texture2d texture = new Texture2d(); texture.RequestMipmapsCreation(); texture.WrapCoordR = Texture.Wrap.MirroredRepeat; texture.WrapCoordS = Texture.Wrap.MirroredRepeat; texture.Create(textureImage); sphereMaterial.FrontMaterialAmbientTexture = texture; sphereMaterial.FrontMaterialAmbientTexCoord = 0; } catch (Exception exception) { throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception); } } textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "displace"); texturePath = Path.Combine(basePath, textureFilename); if (File.Exists(texturePath)) { try { Image textureImage = ImageCodec.Instance.Load(texturePath); Texture2d texture = new Texture2d(); // texture.RequestMipmapsCreation(); texture.WrapCoordR = Texture.Wrap.Repeat; texture.WrapCoordS = Texture.Wrap.Repeat; texture.MinFilter = Texture.Filter.Nearest; texture.MagFilter = Texture.Filter.Nearest; texture.MipmapMaxLevel = 0; texture.Create(textureImage); sphereMaterial.FrontMaterialDisplacementTexture = texture; // sphereMaterial.FrontMaterialDisplacementTexCoord = 0; sphereMaterial.FrontMaterialDisplacementFactor = 0.2f; } catch (Exception exception) { throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception); } } }
public void FreeTexture(Texture2d tex) { var tw = (TextureWrapper)tex.Opaque; tw.Texture.Dispose(); }
public void SetTexture(Texture2d tex) { Texture = tex; }
private void BindTexture2d(Texture2d tex) { GL.BindTexture(TextureTarget.Texture2D, (int)tex.Opaque); }
public void Draw(Texture2d tex) { DrawInternal(tex, 0, 0, tex.Width, tex.Height); }
public void Draw(Texture2d tex) { DrawInternal(tex, 0, 0, tex.Width, tex.Height); }
public void Draw(Texture2d tex, float x, float y) { DrawInternal(tex, x, y, tex.Width, tex.Height); }
public void Draw(Texture2d art, float x, float y, float width, float height) { DrawInternal(art, x, y, width, height); }
public void Draw(Texture2d art, float x, float y, float width, float height) { DrawInternal(art, x, y, width, height); }
unsafe void DrawInternal(Texture2d tex, float x, float y, float w, float h) { var g = Gdi.GetCurrentGraphics(); PrepDraw(g, tex); SetupMatrix(g); sd.PointF[] destPoints = new sd.PointF[] { new sd.PointF(x,y), new sd.PointF(x+w,y), new sd.PointF(x,y+h), }; var tw = tex.Opaque as IGL_GdiPlus.TextureWrapper; g.PixelOffsetMode = sd.Drawing2D.PixelOffsetMode.Half; g.DrawImage(tw.SDBitmap, destPoints, new sd.RectangleF(0, 0, tex.Width, tex.Height), sd.GraphicsUnit.Pixel, CurrentImageAttributes); g.Transform = new sd.Drawing2D.Matrix(); //.Reset() doesnt work ? ? }
public void FreeTexture(Texture2d tex) { ResourceIDs.Free(tex.Id); }
public void BindTexture2d(Texture2d tex) { CurrentBoundTexture = tex; }
public void DrawSubrect(Texture2d tex, float x, float y, float w, float h, float u0, float v0, float u1, float v1) { var tw = Gdi.TextureWrapperForTexture(tex); var g = Gdi.GetCurrentGraphics(); PrepDraw(g, tw); float x0 = u0 * tex.Width; float y0 = v0 * tex.Height; float x1 = u1 * tex.Width; float y1 = v1 * tex.Height; sd.PointF[] destPoints = new sd.PointF[] { new sd.PointF(x,y), new sd.PointF(x+w,y), new sd.PointF(x,y+h), }; g.DrawImage(tw.SDBitmap, destPoints, new sd.RectangleF(x0, y0, x1 - x0, y1 - y0), sd.GraphicsUnit.Pixel, CurrentImageAttributes); //g.DrawImage(tw.SDBitmap, 0, 0); //test }