private void Swap(ref TextureArray2D t1, ref TextureArray2D t2) { var tmp = t1; t1 = t2; t2 = tmp; }
public void LoadKtxCubemap() { var tex = new TextureArray2D(IO.LoadImage(TestData.Directory + "cubemap.ktx")); Assert.AreEqual(6, tex.NumLayers); Assert.AreEqual(3, tex.NumMipmaps); }
private void SaveMultipleLevel(ExportModel info, TextureArray2D texture) { Debug.Assert(info.TexFormat.Format.HasGliFormat); var numLayer = info.Layer == -1 ? models.Images.NumLayers : 1; var numLevels = info.Mipmap == -1 ? models.Images.NumMipmaps : 1; var supportCropping = numLevels == 1; var width = info.GetCropWidth(); var height = info.GetCropHeight(); if (!info.UseCropping && numLevels == 1) { // set full width and height width = models.Images.GetWidth(info.Mipmap); height = models.Images.GetHeight(info.Mipmap); } Debug.Assert(width > 0); Debug.Assert(height > 0); if (!supportCropping) { width = models.Images.Width; height = models.Images.Height; } // allocate ImageLoader.CreateStorage(info.TexFormat.Format.GliFormat, width, height, numLayer, numLevels); // store data for (var layerIdx = 0; layerIdx < numLayer; ++layerIdx) { for (var levelIdx = 0; levelIdx < numLevels; ++levelIdx) { ImageLoader.GetLevelSize(levelIdx, out var bufSize); var data = texture.GetData( numLayer == 1 ? info.Layer : layerIdx, numLevels == 1 ? info.Mipmap : levelIdx, info.TexFormat.Format, info.UseCropping && supportCropping, info.CropStartX, info.CropStartY, ref width, ref height, models.GlData.ExportShader, (int)bufSize); ImageLoader.StoreLevel(layerIdx, levelIdx, data, (UInt64)data.Length); } } // save texture if (info.FileType == ExportModel.FileFormat.Ktx) { ImageLoader.SaveKtx(info.Filename); } else if (info.FileType == ExportModel.FileFormat.Ktx2) { ImageLoader.SaveKtx2(info.Filename); } else if (info.FileType == ExportModel.FileFormat.Dds) { ImageLoader.SaveDDS(info.Filename); } }
public static void CompareWithSmall(Image image, Color.Channel channels) { var tex = new TextureArray2D(image); var colors = tex.GetPixelColors(0, 0); CompareWithSmall(colors, channels); }
public void TestMipmaps() { // load checkers texture var tex = new TextureArray2D(IO.LoadImage(TestData.Directory + "checkers.dds")); Assert.AreEqual(3, tex.NumMipmaps); Assert.AreEqual(4, tex.Size.Width); Assert.AreEqual(4, tex.Size.Height); TestData.TestCheckersLevel0(tex.GetPixelColors(0, 0)); TestData.TestCheckersLevel1(tex.GetPixelColors(0, 1)); TestData.TestCheckersLevel2(tex.GetPixelColors(0, 2)); // remove mipmaps tex = tex.CloneWithoutMipmapsT(); Assert.AreEqual(1, tex.NumMipmaps); Assert.AreEqual(4, tex.Size.Width); Assert.AreEqual(4, tex.Size.Height); TestData.TestCheckersLevel0(tex.GetPixelColors(0, 0)); // generate mipmaps again tex = tex.GenerateMipmapLevelsT(3); Assert.AreEqual(3, tex.NumMipmaps); Assert.AreEqual(4, tex.Size.Width); Assert.AreEqual(4, tex.Size.Height); TestData.TestCheckersLevel0(tex.GetPixelColors(0, 0)); TestData.TestCheckersLevel1(tex.GetPixelColors(0, 1)); TestData.TestCheckersLevel2(tex.GetPixelColors(0, 2)); }
public void SSIMMultiscaleLuminance() { var s = new MultiscaleSSIMShader(); var toRed = new ImageFramework.Model.Shader.TransformShader("return value.r;", "float4", "float"); var fromRed = new ImageFramework.Model.Shader.TransformShader("return float4(value, value, value, 1.0);", "float", "float4"); var tex = IO.LoadImageTexture(TestData.Directory + "checkers.dds"); var redTex = new TextureArray2D(tex.LayerMipmap, tex.Size, Format.R32_Float, true); var dstTex = new TextureArray2D(tex.LayerMipmap, tex.Size, Format.R32G32B32A32_Float, true); var upload = new UploadBuffer(256); Assert.AreEqual(tex.NumMipmaps, 3); var expected = tex.GetPixelColors(LayerMipmapSlice.Mip2)[0]; // copy checkers red channel only foreach (var lm in tex.LayerMipmap.Range) { toRed.Run(tex, redTex, lm, upload); } // this should copy lowest resolution mipmap to first mipmap s.RunCopy(redTex, LayerMipmapSlice.Mip0, upload); // copy back foreach (var lm in tex.LayerMipmap.Range) { fromRed.Run(redTex, dstTex, lm, upload); } var actual = dstTex.GetPixelColors(LayerMipmapSlice.Mip0); foreach (var color in actual) { Assert.IsTrue(color.Equals(expected, Color.Channel.R, 0.0011f)); } }
// converts a lat long texture to a cubemap public TextureArray2D ConvertToCube(TextureArray2D latlong, int resolution) { Debug.Assert(latlong.NumLayers == 1); var dst = new TextureArray2D(new LayerMipmapCount(6, 1), new Size3(resolution, resolution), Format.R32G32B32A32_Float, false); var dev = Device.Get(); quad.Bind(false); dev.Pixel.Set(toCube.Pixel); dev.Pixel.SetShaderResource(0, latlong.GetSrView(LayerMipmapSlice.Mip0)); dev.Pixel.SetSampler(0, sampler); dev.OutputMerger.SetRenderTargets(null, dst.GetRtView(new LayerMipmapSlice(0, 0)), dst.GetRtView(new LayerMipmapSlice(1, 0)), dst.GetRtView(new LayerMipmapSlice(2, 0)), dst.GetRtView(new LayerMipmapSlice(3, 0)), dst.GetRtView(new LayerMipmapSlice(4, 0)), dst.GetRtView(new LayerMipmapSlice(5, 0))); dev.SetViewScissors(resolution, resolution); dev.DrawQuad(); dev.Pixel.SetShaderResource(0, null); dev.Pixel.SetSampler(0, null); dev.OutputMerger.SetRenderTargets((RenderTargetView)null); quad.Unbind(); return(dst); }
private void Apply(TextureArray2D src, TextureArray2D dst, int dirX, int dirY) { quad.Bind(false); var dev = Device.Get(); dev.Pixel.Set(shader.Pixel); cbuffer.SetData(new DirSizeData { DirX = dirX, DirY = dirY, SizeX = src.Size.Width, SizeY = src.Size.Height }); dev.Pixel.SetConstantBuffer(0, cbuffer.Handle); dev.SetViewScissors(dst.Size.Width, dst.Size.Height); foreach (var lm in src.LayerMipmap.LayersOfMipmap(0)) { dev.Pixel.SetShaderResource(0, src.GetSrView(lm)); dev.OutputMerger.SetRenderTargets(dst.GetRtView(lm)); dev.DrawQuad(); } dev.Pixel.SetShaderResource(0, null); dev.OutputMerger.SetRenderTargets((RenderTargetView)null); quad.Unbind(); }
public static void CompareWithSmall(DllImageData image, Color.Channel channels) { var tex = new TextureArray2D(image); var colors = tex.GetPixelColors(LayerMipmapSlice.Mip0); CompareWithSmall(colors, channels); }
/// <summary> /// returns colors from the given filename within the test directory /// </summary> public static Color[] GetColors(string filename) { using (var tex = new TextureArray2D(IO.LoadImage(Directory + filename))) { return(tex.GetPixelColors(LayerMipmapSlice.Mip0)); } }
/// <summary> /// copies a single mip from one layer of a texture to another layer of a texture. The formats don't have to match /// </summary> /// <param name="src">source texture</param> /// <param name="srcLayer"></param> /// <param name="srcMip"></param> /// <param name="dst">destination texture</param> /// <param name="dstLayer"></param> /// <param name="dstMip"></param> public void CopyLayer(TextureArray2D src, int srcLayer, int srcMip, TextureArray2D dst, int dstLayer, int dstMip) { Debug.Assert(src.Size == dst.Size); var dev = DirectX.Device.Get(); quad.Bind(false); dev.Pixel.Set(convert2D.Pixel); dev.Pixel.SetShaderResource(0, src.View); cbuffer.SetData(new LayerLevelOffsetData { Layer = srcLayer, Level = srcMip, Xoffset = 0, Yoffset = 0, Multiplier = 1.0f }); var dim = dst.Size.GetMip(dstMip); dev.Pixel.SetConstantBuffer(0, cbuffer.Handle); dev.OutputMerger.SetRenderTargets(dst.GetRtView(dstLayer, dstMip)); dev.SetViewScissors(dim.Width, dim.Height); dev.DrawQuad(); // remove bindings dev.Pixel.SetShaderResource(0, null); dev.OutputMerger.SetRenderTargets((RenderTargetView)null); }
public override void Draw(TextureArray2D texture) { // this will draw the checkers background base.Draw(texture); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); // bind shader shader.Bind(); shader.SetTransform(GetTransform()); shader.SetMipmap((float)models.Display.ActiveMipmap); shader.SetLayer((float)models.Display.ActiveLayer); shader.SetFarplane(CalcFarplane()); shader.SetGrayscale(models.Display.Grayscale); shader.SetCrop(models.Export, models.Display.ActiveLayer); models.GlData.BindSampler(shader.GetTextureLocation(), true, models.Display.LinearInterpolation); texture.Bind(shader.GetTextureLocation()); models.GlData.Vao.DrawQuad(); GL.Disable(EnableCap.Blend); Program.Unbind(); }
public void FastGaussTest() { // filter kernel: // 1 2 1 // 2 4 2 // 1 2 1 var s = new FastGaussShader(); var img = IO.LoadImageTexture(TestData.Directory + "small.pfm"); var dst = new TextureArray2D(LayerMipmapCount.One, img.Size, Format.R32G32B32A32_Float, true); s.Run(img, dst, 0, false, new UploadBuffer(256)); var src = img.GetPixelColors(LayerMipmapSlice.Mip0); var res = dst.GetPixelColors(LayerMipmapSlice.Mip0); Assert.AreEqual(3 * 3, res.Length); // expected values calculated by hand float midR = (src[0].Red + src[1].Red * 2.0f + src[2].Red + src[3].Red * 2.0f + src[4].Red * 4.0f + src[5].Red * 2.0f + src[6].Red + src[7].Red * 2.0f + src[8].Red) / 16.0f; float midG = (src[0].Green + src[1].Green * 2.0f + src[2].Green + src[3].Green * 2.0f + src[4].Green * 4.0f + src[5].Green * 2.0f + src[6].Green + src[7].Green * 2.0f + src[8].Green) / 16.0f; var midColor = new Color(midR, midG, 1.0f); float firstR = (src[0].Red * 4.0f + src[1].Red * 2.0f + src[3].Red * 2.0f + src[4].Red) / 9.0f; var firstColor = new Color(firstR); Assert.IsTrue(res[4].Equals(midColor, Color.Channel.R | Color.Channel.G)); Assert.IsTrue(res[0].Equals(firstColor, Color.Channel.R)); }
/// <summary> /// for unit testing purposes. Converts naked srv to TextureArray2D /// </summary> internal TextureArray2D ConvertFromRaw(SharpDX.Direct3D11.ShaderResourceView srv, Size3 size, SharpDX.DXGI.Format dstFormat) { var res = new TextureArray2D(1, 1, size, dstFormat, false); var dev = DirectX.Device.Get(); quad.Bind(false); dev.Pixel.Set(convert2D.Pixel); dev.Pixel.SetShaderResource(0, srv); cbuffer.SetData(new LayerLevelOffsetData { Layer = 0, Level = 0, Xoffset = 0, Yoffset = 0, Multiplier = 1.0f }); dev.Pixel.SetConstantBuffer(0, cbuffer.Handle); dev.OutputMerger.SetRenderTargets(res.GetRtView(0, 0)); dev.SetViewScissors(size.Width, size.Height); dev.DrawQuad(); // remove bindings dev.Pixel.SetShaderResource(0, null); dev.OutputMerger.SetRenderTargets((RenderTargetView)null); quad.Unbind(); return(res); }
/// converts a cubemap texture to a lat long map public TextureArray2D ConvertToLatLong(TextureArray2D cube, int resolution) { Debug.Assert(cube.NumLayers == 6); var dst = new TextureArray2D(LayerMipmapCount.One, new Size3(resolution, Math.Max(resolution / 2, 1)), Format.R32G32B32A32_Float, false); var dev = Device.Get(); quad.Bind(false); dev.Pixel.Set(toLatLong.Pixel); var dim = dst.Size; dev.Pixel.SetShaderResource(0, cube.GetCubeView(0)); dev.Pixel.SetSampler(0, sampler); dev.OutputMerger.SetRenderTargets(dst.GetRtView(LayerMipmapSlice.Mip0)); dev.SetViewScissors(dim.Width, dim.Height); dev.DrawQuad(); dev.Pixel.SetShaderResource(0, null); dev.Pixel.SetSampler(0, null); dev.OutputMerger.SetRenderTargets((RenderTargetView)null); quad.Unbind(); return(dst); }
protected void DrawLayer(Matrix4 offset, int layer, TextureArray2D texture) { Debug.Assert(texture != null); var finalTransform = offset * GetTransform(); // draw the checkers background models.GlData.CheckersShader.Bind(finalTransform); models.GlData.Vao.DrawQuad(); // blend over the final image GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); shader.Bind(); shader.SetTransform(finalTransform); shader.SetLayer(layer); shader.SetMipmap(models.Display.ActiveMipmap); shader.SetGrayscale(models.Display.Grayscale); shader.SetCrop(models.Export, layer); models.GlData.BindSampler(shader.GetTextureLocation(), true, models.Display.LinearInterpolation); texture.Bind(shader.GetTextureLocation()); models.GlData.Vao.DrawQuad(); // disable everything GL.Disable(EnableCap.Blend); Program.Unbind(); }
private void CompareAfterExport(string inputImage, string outputImage, string outputExtension, GliFormat format, Color.Channel channels = Color.Channel.Rgb, float tolerance = 0.01f) { var model = new Models(1); model.AddImageFromFile(inputImage); model.Apply(); var origTex = (TextureArray2D)model.Pipelines[0].Image; model.Export.Quality = 100; model.Export.Export(origTex, new ExportDescription(outputImage, outputExtension, model.Export) { FileFormat = format }); var expTex = new TextureArray2D(IO.LoadImage(outputImage + "." + outputExtension)); for (int curLayer = 0; curLayer < origTex.NumLayers; ++curLayer) { for (int curMipmap = 0; curMipmap < origTex.NumMipmaps; ++curMipmap) { var origColors = origTex.GetPixelColors(curLayer, curMipmap); var expColor = expTex.GetPixelColors(curLayer, curMipmap); TestData.CompareColors(origColors, expColor, channels, tolerance); } } }
public void ConvertFromSrgb() { var tex = new TextureArray2D(IO.LoadImage(TestData.Directory + "small_a.png")); var newTex = shader.Convert(tex, Format.R32G32B32A32_Float, models.Scaling); TestData.CompareWithSmall(newTex.GetPixelColors(LayerMipmapSlice.Mip0), Color.Channel.Rgba); }
/// <summary> /// clears the temporary texture /// </summary> public void Dispose() { if (temp != null) { textureCache.StoreTexture(temp); temp = null; } }
public void BindSourceImage(TextureArray2D texture, Sampler sampler, int id) { sampler.Bind(TextureBindingStart + id); texture.Bind(TextureBindingStart + id); // set srgb variable shader.Bind(); GL.Uniform1(TextureSrgbStart + id, texture.IsSrgb?1:0); }
/// <summary> /// this texture should contain the final result /// </summary> /// <returns>valid texture</returns> public TextureArray2D GetPrimaryTexture() { if (primary != null) { return(primary); } primary = textureCache.GetTexture(); return(primary); }
/// <summary> /// dispatches the shader with the given layer and level /// source textures have to be bound before a call to this function /// </summary> /// <param name="layer"></param> /// <param name="mipmap"></param> /// <param name="width">mipmap width</param> /// <param name="height">mipmap height</param> /// <param name="target">target image</param> public void Run(int layer, int mipmap, int width, int height, TextureArray2D target) { shader.Bind(); target.BindAsImage(GetDestinationImageBinding(), layer: layer, mipmap: mipmap, access: TextureAccess.WriteOnly); SetLevel(mipmap); SetLayer(layer); GL.DispatchCompute(width / LocalSize + 1, height / LocalSize + 1, 1); Program.Unbind(); }
public void ConvertToSrgb() { // convert from RGBA32F to RGBA8_SRGB var tex = new TextureArray2D(IO.LoadImage(TestData.Directory + "small.pfm")); var newTex = shader.Convert(tex, Format.R8G8B8A8_UNorm_SRgb, models.Scaling); TestData.CompareWithSmall(newTex.GetPixelColors(LayerMipmapSlice.Mip0), Color.Channel.Rgb); }
/// <summary> /// this texture can be used for ping pong rendering /// </summary> /// <returns>valid texture</returns> public TextureArray2D GetTemporaryTexture() { if (temp != null) { return(temp); } temp = textureCache.GetTexture(); return(temp); }
public void CreateGif(TextureArray2D left, TextureArray2D right, Config cfg) { Debug.Assert(left != null); Debug.Assert(right != null); Debug.Assert(left.Size == right.Size); Debug.Assert(!progressModel.IsProcessing); var cts = new CancellationTokenSource(); progressModel.AddTask(CreateGifAsync(left, right, cfg, progressModel.GetProgressInterface(cts.Token)), cts); }
private async Task CreateGifAsync(TextureArray2D left, TextureArray2D right, Config cfg, IProgress progress) { // delay in milliseconds var numFrames = cfg.FramesPerSecond * cfg.NumSeconds; try { progressModel.EnableDllProgress = false; var leftView = left.GetSrView(LayerMipmapSlice.Mip0); var rightView = right.GetSrView(LayerMipmapSlice.Mip0); var curProg = progress.CreateSubProgress(0.9f); // create frames using (var dst = IO.CreateImage(new ImageFormat(Format.R8G8B8A8_UNorm_SRgb), left.Size, LayerMipmapCount.One)) { var dstMip = dst.GetMipmap(LayerMipmapSlice.Mip0); var dstPtr = dstMip.Bytes; var dstSize = dstMip.ByteSize; // render frames into texture using (var frame = new TextureArray2D(LayerMipmapCount.One, left.Size, Format.R8G8B8A8_UNorm_SRgb, false)) { var frameView = frame.GetRtView(LayerMipmapSlice.Mip0); for (int i = 0; i < numFrames; ++i) { float t = (float)i / (numFrames); int borderPos = (int)(t * frame.Size.Width); // render frame shader.Run(leftView, rightView, frameView, cfg.SliderWidth, borderPos, frame.Size.Width, frame.Size.Height); // save frame as png frame.CopyPixels(LayerMipmapSlice.Mip0, dstPtr, dstSize); var filename = $"{cfg.TmpFilename}{i:D4}"; await Task.Run(() => IO.SaveImage(dst, filename, "png", GliFormat.RGBA8_SRGB), progress.Token); curProg.Progress = i / (float)numFrames; curProg.What = "creating frames"; } } } // convert video await FFMpeg.ConvertAsync(cfg, progress.CreateSubProgress(1.0f)); } finally { progressModel.EnableDllProgress = true; } }
public void MitchelXYScale() { var shader = new MitchellNetravaliScaleShader(new QuadShader(), new UploadBuffer(256)); var checkers = new TextureArray2D(IO.LoadImage(TestData.Directory + "sphere.png")); var res = shader.Run(checkers, new Size3(20, 40)); var reference = new TextureArray2D(IO.LoadImage(TestData.Directory + "sphere_scaled.png")); // compare with gimp reference TestData.CompareColors(reference.GetPixelColors(0, 0), res.GetPixelColors(0, 0)); }
public void Alignment() { var tex = new TextureArray2D(IO.LoadImage(TestData.Directory + "unaligned.png")); Assert.AreEqual(3, tex.Size.Width % 4); Assert.AreEqual(1, tex.Size.Height % 4); // convert with 4 texel alignment var newTex = shader.Convert(tex, Format.R8G8B8A8_UNorm_SRgb, LayerMipmapSlice.Mip0, 1.0f, false, Size3.Zero, Size3.Zero, new Size3(4, 4, 0), models.Scaling); Assert.AreEqual(0, newTex.Size.Width % 4); Assert.AreEqual(0, newTex.Size.Height % 4); }
public void MitchelUpscale() { var models = new Models(1); var shader = new MitchellNetravaliScaleShader(new QuadShader(), new UploadBuffer(256)); var checkers = new TextureArray2D(IO.LoadImage(TestData.Directory + "sphere.png")); var res = shader.Run(checkers, new Size3(62, 31), models.Scaling); var reference = new TextureArray2D(IO.LoadImage(TestData.Directory + "sphere_up.png")); // compare with gimp reference TestData.CompareColors(reference.GetPixelColors(LayerMipmapSlice.Mip0), res.GetPixelColors(LayerMipmapSlice.Mip0)); }
/// <summary> /// stores the textures for later use /// </summary> /// <param name="tex"></param> public void StoreTexture(TextureArray2D tex) { Debug.Assert(tex != null); if (tex.NumMipmaps == images.NumMipmaps) { // can be used for later textures.Push(tex); } else { // immediately discard (incompatible image) tex.Dispose(); } }