/// <summary>
/// The execute.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
public override void Execute(CommandContext context)
{
Assert.ArgumentNotNull(context, "context");
if (context.Items.Length != 1)
{
return;
}
Item itemNotNull = Client.GetItemNotNull(context.Parameters["itemid"]);
itemNotNull.Fields.ReadAll();
Field field = itemNotNull.Fields[context.Parameters["fieldid"]];
Assert.IsNotNull(field, "field");
ImageRenderer renderer = new ImageRenderer
{
Item = itemNotNull,
FieldName = field.Name,
FieldValue = string.Empty,
Parameters = this.GetRendererParameters(context.Parameters)
};
SheerResponse.SetAttribute("scHtmlValue", "value", renderer.Render().ToString());
SheerResponse.SetAttribute("scPlainValue", "value", EditorConstants.NoValue);
SheerResponse.Eval("scSetHtmlValue('{0}');", context.Parameters["controlid"]);
WebUtil.SetCookieValue("sitecore_webedit_editing", "1");
}
public static void Main(String[] args)
{
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
ImageRenderer rendObj = new ImageRenderer(i);
threads[i] = new Thread(new ThreadStart(rendObj.Foo));
threads[i].Start();
}
for (int i = 0; i < 10; i++) {
threads[i].Join();
}
Console.WriteLine("");
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(delegate() {
Console.WriteLine("task " + i + " running");
// NB: There is a race here. Nothing guarantees that
// the new thread will read i before the main thread
// increments it for the next iteration of the loop.
});
threads[i].Start();
}
for (int i = 0; i < 10; i++) {
threads[i].Join();
}
}
public override IEnumerable <LocalRenderingExtensionInfo> ListRenderingExtensions()
{
if (m_renderingExtensions == null)
{
List <LocalRenderingExtensionInfo> list = new List <LocalRenderingExtensionInfo>();
RPLRenderer rPLRenderer = new RPLRenderer();
list.Add(new LocalRenderingExtensionInfo("RPL", rPLRenderer.LocalizedName, isVisible: false, typeof(RPLRenderer), isExposedExternally: false));
ExcelRenderer excelRenderer = new ExcelRenderer();
list.Add(new LocalRenderingExtensionInfo("Excel", excelRenderer.LocalizedName, isVisible: false, typeof(ExcelRenderer), isExposedExternally: true));
ExcelOpenXmlRenderer excelOpenXmlRenderer = new ExcelOpenXmlRenderer();
list.Add(new LocalRenderingExtensionInfo("EXCELOPENXML", excelOpenXmlRenderer.LocalizedName, isVisible: true, typeof(ExcelOpenXmlRenderer), isExposedExternally: true));
ImageRenderer imageRenderer = new ImageRenderer();
list.Add(new LocalRenderingExtensionInfo("IMAGE", imageRenderer.LocalizedName, isVisible: false, typeof(ImageRenderer), isExposedExternally: true));
PDFRenderer pDFRenderer = new PDFRenderer();
list.Add(new LocalRenderingExtensionInfo("PDF", pDFRenderer.LocalizedName, isVisible: true, typeof(PDFRenderer), isExposedExternally: true));
WordDocumentRenderer wordDocumentRenderer = new WordDocumentRenderer();
list.Add(new LocalRenderingExtensionInfo("WORD", wordDocumentRenderer.LocalizedName, isVisible: false, typeof(WordDocumentRenderer), isExposedExternally: true));
WordOpenXmlDocumentRenderer wordOpenXmlDocumentRenderer = new WordOpenXmlDocumentRenderer();
list.Add(new LocalRenderingExtensionInfo("WORDOPENXML", wordOpenXmlDocumentRenderer.LocalizedName, isVisible: true, typeof(WordOpenXmlDocumentRenderer), isExposedExternally: true));
list.Add(new LocalRenderingExtensionInfo("MHTML", new ReportingServices.Rendering.HtmlRenderer.MHtmlRenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.MHtmlRenderingExtension), isExposedExternally: true));
list.Add(new LocalRenderingExtensionInfo("HTML4.0", new ReportingServices.Rendering.HtmlRenderer.Html40RenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.Html40RenderingExtension), isExposedExternally: true));
list.Add(new LocalRenderingExtensionInfo("HTML5", new ReportingServices.Rendering.HtmlRenderer.Html5RenderingExtension().LocalizedName, isVisible: true, typeof(ReportingServices.Rendering.HtmlRenderer.Html5RenderingExtension), isExposedExternally: true));
m_renderingExtensions = list;
}
return(m_renderingExtensions);
}
/// <summary>
/// Renders the <see cref="PresentationImage"/> to a provided offscreen <see cref="Bitmap"/>.
/// </summary>
/// <param name="bmp">The offscreen bitmap to render to.</param>
/// <returns></returns>
/// <remarks>
/// This method can be used anywhere an offscreen bitmap is required, such as
/// paper/DICOM printing, thumbnail generation, creation of new DICOM images, etc.
/// </remarks>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="bmp"/> is null.</exception>
/// <exception cref="ArgumentException">Thrown if <paramref name="bmp"/> has invalid dimensions.</exception>
/// <exception cref="RenderingException">Thrown if any <see cref="Exception"/> is encountered while rendering the image.</exception>
public virtual void DrawToBitmap(Bitmap bmp)
{
Platform.CheckForNullReference(bmp, "bmp");
Platform.CheckPositive(bmp.Width, "bmp.Width");
Platform.CheckPositive(bmp.Height, "bmp.Height");
var graphics = System.Drawing.Graphics.FromImage(bmp);
var contextId = graphics.GetHdc();
try
{
using (var surface = ImageRenderer.GetRenderingSurface(IntPtr.Zero, bmp.Width, bmp.Height))
{
surface.ContextID = contextId;
surface.ClipRectangle = new Rectangle(0, 0, bmp.Width, bmp.Height);
var drawArgs = new DrawArgs(surface, null, DrawMode.Render);
DrawNoEvents(drawArgs);
drawArgs = new DrawArgs(surface, null, DrawMode.Refresh);
DrawNoEvents(drawArgs);
}
}
finally
{
graphics.ReleaseHdc(contextId);
graphics.Dispose();
}
}
public static void Main(String[] args)
{
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++)
{
ImageRenderer rendObj = new ImageRenderer(i);
threads[i] = new Thread(new ThreadStart(rendObj.Foo));
threads[i].Start();
}
for (int i = 0; i < 10; i++)
{
threads[i].Join();
}
Console.WriteLine("");
for (int i = 0; i < 10; i++)
{
threads[i] = new Thread(delegate() {
Console.WriteLine("task " + i + " running");
// NB: There is a race here. Nothing guarantees that
// the new thread will read i before the main thread
// increments it for the next iteration of the loop.
});
threads[i].Start();
}
for (int i = 0; i < 10; i++)
{
threads[i].Join();
}
}
public override void Initialize(Game game)
{
progressBar = new BarWidget()
{
BoundsAsRatio = true,
Bounds = new FloatRect(.25f, .45f, .5f, .1f),
BorderColor = Color.White,
BorderSize = 3,
EmptyBackgroundColor = Color.Red,
FullBackgroundColor = Color.Black,
EmptyFillColor = Color.Black,
FullFillColor = Color.Green
};
entity = new Entity();
game.Resources.RegisterResource(
game.Resources.ResourceDeserializer.Deserialize(
new ScriptDocument(FileFinder.ResourcePath("BrothEngine/resource.json")).JString
));
ImageRenderer renderer = new ImageRenderer(entity)
{
Resource = game.Resources.TryGetResource <ImageResource>("ENGINE.logo")
};
entity.Renderer = renderer;
entity.Transform.Position = new Vector2f(game.Window.Size.X / 2, game.Window.Size.Y / 2);
}
static void Main(string[] args)
{
int mapWidth, mapHeight, fillPercent;
if (args.Length < 3)
{
Console.WriteLine("Usage: *.exe <width> <height> <fill%>");
return;
}
else
{
mapWidth = Int32.Parse(args[0]);
mapHeight = Int32.Parse(args[1]);
fillPercent = Int32.Parse(args[2]);
}
CaveGenerator caveGenerator = new CaveGenerator();
Renderer renderer = new Renderer();
ImageRenderer imageRenderer = new ImageRenderer();
int[] playerPos = { 0, 0 };
byte[,] mapContent = new byte[mapWidth, mapHeight];
bool[,] map = new bool[mapWidth, mapHeight];
caveGenerator.GenerateCave(ref map, ref mapContent, 2, fillPercent);
// caveGenerator.SpawnPlayer(ref map, ref mapContent, ref playerPos);
// renderer.DrawMap(ref map, ref mapContent);
Console.WriteLine("Rendering image...");
imageRenderer.DrawMap(ref mapContent);
Console.WriteLine("Done.");
return;
}
public ThumbnailPickerGUI(ImageRenderer imageRenderer, ScrollView thumbnailScroll)
{
this.imageRenderer = imageRenderer;
imageGrid = new SingleSelectButtonGrid(thumbnailScroll);
imageGrid.SelectedValueChanged += new EventHandler(imageGrid_SelectedValueChanged);
thumbnailImages = new ImageAtlas("ThumbnailPicker", new IntSize2(imageGrid.ItemWidth, imageGrid.ItemHeight));
}
public IActionResult GetBarcode(string data)
{
_logger.LogInformation("GetBarcode " + data);
System.IO.File.WriteAllText(Environment.CurrentDirectory + @"/mydata/" + "file_" + DateTime.Now.Ticks + ".txt", data);
var cachedString = _distributedCache.GetString("TEST");
if (string.IsNullOrEmpty(cachedString))
{
_distributedCache.SetString("TEST", "somevaluetocache");
_logger.LogInformation("Was not found, ... but now set.");
}
else
{
_logger.LogInformation("Yeah, ... was found : " + cachedString);
}
var barcode = Code128Encoder.Encode(data, true);
var renderer = new ImageRenderer();
var stream = new MemoryStream();
renderer.Render(barcode, stream);
return(File(stream.ToArray(), "image/png"));
}
public NoiseControl()
{
InitializeComponent();
var map = new NoiseMap();
var builder = new PlaneNoiseMapBuilder()
{
DestNoiseMap = map,
};
builder.SetDestSize(pictureBox.Width, pictureBox.Height);
m_noiseBuilder = builder;
var image = new SharpNoise.Utilities.Imaging.Image();
var renderer = new ImageRenderer()
{
SourceNoiseMap = map,
DestinationImage = image,
};
if (greyRadioButton.Checked)
{
renderer.BuildGrayscaleGradient();
}
else if (terrainRadioButton.Checked)
{
renderer.BuildTerrainGradient();
}
else
{
throw new Exception();
}
m_imageRenderer = renderer;
}
public Renderer(RenderSurface surface)
{
Surface = surface;
ContentArchive content;
using (var stream = GetType().Assembly.GetManifestResourceStream("DemoRenderer.DemoRenderer.contentarchive"))
{
content = ContentArchive.Load(stream);
}
Shapes = new ShapesExtractor(looper, pool);
SphereRenderer = new RayTracedRenderer <SphereInstance>(content, @"ShapeDrawing\RenderSpheres");
CapsuleRenderer = new RayTracedRenderer <CapsuleInstance>(content, @"ShapeDrawing\RenderCapsules");
CylinderRenderer = new RayTracedRenderer <CylinderInstance>(content, @"ShapeDrawing\RenderCylinders");
BoxRenderer = new BoxRenderer(content);
TriangleRenderer = new TriangleRenderer(content);
MeshRenderer = new MeshRenderer(Shapes.MeshCache, content);
Lines = new LineExtractor(pool, looper);
LineRenderer = new LineRenderer(content);
Background = new BackgroundRenderer(content);
CompressToSwap = new CompressToSwap(content);
ImageRenderer = new ImageRenderer(content);
ImageBatcher = new ImageBatcher(pool);
GlyphRenderer = new GlyphRenderer(content);
TextBatcher = new TextBatcher();
UILineRenderer = new UILineRenderer(content);
UILineBatcher = new UILineBatcher();
OnResize();
}
public async void TransitionsAsync()
{
OverworldGenerator og = new OverworldGenerator();
OverworldTerrain noiseGen = new OverworldTerrain(true);
await Task.Run(() =>
{
var map = new NoiseMap();
PlaneNoiseMapBuilder builder =
new PlaneNoiseMapBuilder()
{
DestNoiseMap = map, SourceModule = noiseGen.transitions
};
var image = new Image();
var transitionsRenderer = new ImageRenderer()
{
SourceNoiseMap = map, DestinationImage = image
};
transitionsRenderer.BuildGrayscaleGradient();
builder.SetBounds(-400, 400, -300, 300);
builder.SetDestSize(800, 600);
builder.Build();
transitionsRenderer.Render();
var bmp = transitionsRenderer.DestinationImage.ToGdiBitmap();
bmp.Save("_transitions.bmp");
Assert.Equal(0, 0);
});
}
public void Render_Ean13_IncludeContentAsText()
{
var renderer = new ImageRenderer(imageFormat: ImageFormat.Png, includeEanContentAsText: true);
IBarcode barcode = EanEncoder.Encode("978020137962");
using Stream stream = File.OpenWrite(@"d:\temp\ean-test.png");
renderer.Render(barcode, stream);
}
public static void ModifyContent(ref ImageRenderer renderer, Resource.IResource res)
{
renderer.rectTranfrom = renderer.GetComponent <RectTransform>();
renderer.image = renderer.GetComponent <RawImage>();
renderer.ChangeContent(res);
renderer.Attrs = res.Attrs;
renderer.ApplyAttrs(res.Attrs);
}
public static ImageLoader GetImageLoader (ImageRenderer imageRenderer)
{
//TODO
if (_onlyLoader == null) {
_onlyLoader = new ImageLoader (Android.App.Application.Context, 64, 40);
}
return _onlyLoader;
}
public ImageView(MonoReports.Model.Controls.Image image, SectionView parentSection, PixbufRepository pixbufRepository) : base(image)
{
this.ParentSection = parentSection;
AbsoluteBound = new Rectangle(parentSection.AbsoluteDrawingStartPoint.X + image.Location.X, parentSection.AbsoluteDrawingStartPoint.Y + image.Location.Y, image.Width, image.Height);
ImageRenderer = new ImageRenderer()
{
PixbufRepository = pixbufRepository, DesignMode = true
};
}
static async Task RenderImage(AdaptiveCard card, string image)
{
var renderer = new ImageRenderer(new HostConfig(), String.Empty);
var imageStream = await renderer.RenderAdaptiveCardAsync(card, 480);
using (FileStream fileStream = new FileStream(image, FileMode.Create))
{
await imageStream.CopyToAsync(fileStream);
}
}
public IActionResult GetBarcode(string data)
{
var barcode = Code128Encoder.Encode(data, true);
var renderer = new ImageRenderer();
var stream = new MemoryStream();
renderer.Render(barcode, stream);
return(File(stream.ToArray(), "image/png"));
}
protected virtual void DrawBackground(ImageWithDeviceContext destImage)
{
if (BackgroundImage == null)
{
return;
}
ImageRenderer.StretchImageWithOutMargin(destImage, RealX, RealY, Size.Width, Size.Height,
BackgroundImage, 0, BackgroundImage.Width, BackgroundImage.Height,
BackgroundImageStretchExcludeMargin, Opacity);
}
public static void Main(string[] args)
{
// The noise source - a simple Perlin noise generator will do for this sample
var noiseSource = new Perlin
{
Seed = new Random().Next()
};
// Create a new, empty, noise map and initialize a new planar noise map builder with it
var noiseMap = new NoiseMap();
var noiseMapBuilder = new PlaneNoiseMapBuilder
{
DestNoiseMap = noiseMap,
SourceModule = noiseSource
};
// Set the size of the noise map
noiseMapBuilder.SetDestSize(1280, 720);
// Set the bounds of the noise mpa builder
// These are the coordinates in the noise source from which noise values will be sampled
noiseMapBuilder.SetBounds(-3, 3, -2, 2);
// Build the noise map - samples values from the noise module above,
// using the bounds coordinates we have passed in the builder
noiseMapBuilder.Build();
// Create a new image and image renderer
var image = new Image();
var renderer = new ImageRenderer
{
SourceNoiseMap = noiseMap,
DestinationImage = image
};
// The renderer needs to know how to map noise values to colors.
// In this case, we use one of the predefined gradients, specifically the terrain gradient,
// which maps lower noise values to blues and greens and higher values to brouns and whites.
// This simulates the look of a map with water, grass and vegetation, dirt and mountains.
renderer.BuildTerrainGradient();
// Before rendering the image, we could set various parameters on the renderer,
// such as the position and color of the light source.
// But we aren't going to bother for this sample.
// Finally, render the image
renderer.Render();
// Finally, save the rendered image as a PNG in the current directory
using (var fs = File.OpenWrite("NoiseMap.png"))
{
image.SaveGdiBitmap(fs, ImageFormat.Png);
}
}
public void Render(Camera camera)
{
if (Surface.Resolution.X != depthBuffer.Description.Width || Surface.Resolution.Y != depthBuffer.Description.Height)
{
OnResize();
}
var context = Surface.Context;
Shapes.MeshCache.FlushPendingUploads(context);
context.Rasterizer.SetViewport(0, 0, Surface.Resolution.X, Surface.Resolution.Y, 0.0f, 1.0f);
//Note reversed depth.
context.ClearDepthStencilView(dsv, DepthStencilClearFlags.Depth, 0, 0);
context.ClearRenderTargetView(rtv, new SharpDX.Mathematics.Interop.RawColor4());
context.OutputMerger.SetRenderTargets(dsv, rtv);
context.Rasterizer.State = rasterizerState;
context.OutputMerger.SetDepthStencilState(opaqueDepthState);
//All ray traced shapes use analytic coverage writes to get antialiasing.
context.OutputMerger.SetBlendState(a2cBlendState);
SphereRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.spheres.Span), 0, Shapes.spheres.Count);
CapsuleRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.capsules.Span), 0, Shapes.capsules.Count);
CylinderRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.cylinders.Span), 0, Shapes.cylinders.Count);
//Non-raytraced shapes just use regular opaque rendering.
context.OutputMerger.SetBlendState(opaqueBlendState);
BoxRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.boxes.Span), 0, Shapes.boxes.Count);
TriangleRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.triangles.Span), 0, Shapes.triangles.Count);
MeshRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.meshes.Span), 0, Shapes.meshes.Count);
LineRenderer.Render(context, camera, Surface.Resolution, SpanConverter.AsSpan(Lines.lines.Span), 0, Lines.lines.Count);
Background.Render(context, camera);
//Resolve MSAA rendering down to a single sample buffer for screenspace work.
//Note that we're not bothering to properly handle tonemapping during the resolve. That's going to hurt quality a little, but the demos don't make use of very wide ranges.
//(If for some reason you end up expanding the demos to make use of wider HDR, you can make this a custom resolve pretty easily.)
context.ResolveSubresource(colorBuffer, 0, resolvedColorBuffer, 0, Format.R16G16B16A16_Float);
context.OutputMerger.SetRenderTargets(resolvedRTV);
//Glyph and screenspace line drawing rely on the same premultiplied alpha blending transparency. We'll handle their state out here.
context.OutputMerger.SetBlendState(uiBlendState);
context.OutputMerger.SetDepthStencilState(uiDepthState);
ImageRenderer.PreparePipeline(context);
ImageBatcher.Flush(context, Surface.Resolution, ImageRenderer);
UILineBatcher.Flush(context, Surface.Resolution, UILineRenderer);
GlyphRenderer.PreparePipeline(context);
TextBatcher.Flush(context, Surface.Resolution, GlyphRenderer);
//Note that, for now, the compress to swap handles its own depth state since it's the only post processing stage.
context.OutputMerger.SetBlendState(opaqueBlendState);
context.Rasterizer.State = rasterizerState;
CompressToSwap.Render(context, resolvedSRV, Surface.RTV);
}
public MainWindow()
{
InitializeComponent();
LoadChannelButtons();
RenderOptions.SetBitmapScalingMode(PianoRollImage, BitmapScalingMode.NearestNeighbor);
RenderOptions.SetEdgeMode(PianoRollImage, EdgeMode.Aliased);
_player = new MidiPlayer(from button in _channelButtons select button.ChannelState);
_noteRenderer = new ImageRenderer();
}
/// <summary>
/// Loads a tacton from image.
/// For transcoding an image to a tactile matrix, the static available ImageRender is used.
/// </summary>
/// <param name="img">The image to transcode into a tactile matrix.</param>
/// <returns>the tactile matrix representation of the tacton.</returns>
/// <remarks>By default, dark pixels of the given image will be turned into raised pins; light pixels
/// into lowered pins.</remarks>
public static bool[,] LoadTactonFromImage(Image img)
{
bool[,] tacton = new bool[0, 0];
if (img != null && ImageRenderer != null)
{
tacton = ImageRenderer.RenderMatrix(buildImageDummyViewRange(img), img);
}
return(tacton);
}
private async void viewImage_Click(object sender, RoutedEventArgs e)
{
var renderer = new ImageRenderer(new HostConfig(), this.Resources);
var imageStream = renderer.RenderAdaptiveCard(this._card, 480);
string path = System.IO.Path.GetRandomFileName() + ".png";
using (FileStream fileStream = new FileStream(path, FileMode.Create))
{
await imageStream.CopyToAsync(fileStream);
}
Process.Start(path);
}
public void Render(Camera camera)
{
if (Surface.Resolution.X != width || Surface.Resolution.Y != height)
{
OnResize();
}
Shapes.MeshCache.FlushPendingUploads();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer);
//Note reversed depth.
GL.ClearDepth(0.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Greater);
//All ray traced shapes use analytic coverage writes to get antialiasing.
GL.Enable(EnableCap.SampleAlphaToCoverage);
SphereRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.spheres.Span), 0, Shapes.spheres.Count);
CapsuleRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.capsules.Span), 0, Shapes.capsules.Count);
CylinderRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.cylinders.Span), 0, Shapes.cylinders.Count);
//Non-raytraced shapes just use regular opaque rendering.
GL.Disable(EnableCap.SampleAlphaToCoverage);
BoxRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.boxes.Span), 0, Shapes.boxes.Count);
TriangleRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.triangles.Span), 0, Shapes.triangles.Count);
MeshRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Shapes.meshes.Span), 0, Shapes.meshes.Count);
LineRenderer.Render(camera, Surface.Resolution, SpanConverter.AsSpan(Lines.lines.Span), 0, Lines.lines.Count);
Background.Render(camera);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
//Resolve MSAA rendering down to a single sample buffer for screenspace work.
//Note that we're not bothering to properly handle tonemapping during the resolve. That's going to hurt quality a little, but the demos don't make use of very wide ranges.
//(If for some reason you end up expanding the demos to make use of wider HDR, you can make this a custom resolve pretty easily.)
GL.BlitNamedFramebuffer(framebuffer, resolvedFramebuffer, 0, 0, width, height, 0, 0, width, height, ClearBufferMask.ColorBufferBit, BlitFramebufferFilter.Nearest);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, resolvedFramebuffer);
//Glyph and screenspace line drawing rely on the same premultiplied alpha blending transparency. We'll handle their state out here.
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.OneMinusSrcAlpha);
GL.BlendEquation(BlendEquationMode.FuncAdd);
ImageRenderer.PreparePipeline();
ImageBatcher.Flush(Surface.Resolution, ImageRenderer);
UILineBatcher.Flush(Surface.Resolution, UILineRenderer);
GlyphRenderer.PreparePipeline();
TextBatcher.Flush(Surface.Resolution, GlyphRenderer);
GL.Disable(EnableCap.Blend);
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
CompressToSwap.Render(resolvedColorBuffer);
}
public void Render_Barcode2D()
{
// Arrange
var renderer = new ImageRenderer();
IBarcode barcode = QrEncoder.Encode("Hello Unicode\nHave a nice day!", ErrorCorrectionLevel.L, Encoding.Unicode);
// Act
byte[] data = RenderBarcodeToByteArray(renderer, barcode);
// Assert
data.Should().NotBeNull();
}
public void Render_Barcode1D()
{
// Arrange
var renderer = new ImageRenderer();
IBarcode barcode = Code128Encoder.Encode("Wikipedia");
// Act
byte[] data = RenderBarcodeToByteArray(renderer, barcode);
// Assert
data.Should().NotBeNull();
}
public void CreateTestImageRenderer()
{
testTextureImage = new Image();
testRenderer = new ImageRenderer();
testRenderer.ClearGradient();
testRenderer.AddGradientPoint(-1.00, new Color(189, 94, 4, 255));
testRenderer.AddGradientPoint(0.50, new Color(144, 48, 6, 255));
testRenderer.AddGradientPoint(1.00, new Color(60, 10, 8, 255));
testRenderer.EnableLight = false;
}
public static Bitmap RenderLayer(ImageGraphic layer, int dstWidth, int dstHeight)
{
Bitmap bitmap = new Bitmap(dstWidth, dstHeight);
Rectangle clientArea = new Rectangle(0, 0, dstWidth, dstHeight);
BitmapData bitmapData = LockBitmap(bitmap);
int bytesPerPixel = 4;
ImageRenderer.Render(layer, bitmapData.Scan0, bitmapData.Width, bytesPerPixel, clientArea);
bitmap.UnlockBits(bitmapData);
return(bitmap);
}
public GraniteTextureTest()
{
module = new Turbulence
{
Seed = 2,
Frequency = 4,
Power = 1.0 / 8.0,
Roughness = 6,
Source0 = new Add
{
Source0 = new Billow
{
Seed = 1,
Frequency = 8,
Persistence = 0.625,
Lacunarity = 2.18359375,
OctaveCount = 6,
},
Source1 = new ScaleBias
{
Scale = -0.5,
Bias = 0,
Source0 = new Cell
{
Seed = 1,
Frequency = 16,
EnableDistance = true,
}
}
}
};
noiseMap = new NoiseMap();
textureImage = new Image();
renderer = new ImageRenderer
{
EnableLight = true,
LightAzimuth = 135,
LightElevation = 60,
LightContrast = 2,
LightColor = new Color(255, 255, 255, 0),
};
renderer.AddGradientPoint(-1.0000, new Color(0, 0, 0, 255));
renderer.AddGradientPoint(-0.9375, new Color(0, 0, 0, 255));
renderer.AddGradientPoint(-0.8750, new Color(216, 216, 242, 255));
renderer.AddGradientPoint(0.0000, new Color(191, 191, 191, 255));
renderer.AddGradientPoint(0.5000, new Color(210, 116, 125, 255));
renderer.AddGradientPoint(0.7500, new Color(210, 113, 98, 255));
renderer.AddGradientPoint(1.0000, new Color(255, 176, 192, 255));
}
private async void seq_save_Click(object sender, RoutedEventArgs e)
{
int width = 0;
int height = 0;
if (!string.IsNullOrWhiteSpace(MaxWidth.Text) && MaxWidth.Text != "0")
{
width = Convert.ToInt32(MaxWidth.Text);
}
if (!string.IsNullOrWhiteSpace(MaxHeight.Text) && MaxHeight.Text != "0")
{
height = Convert.ToInt32(MaxHeight.Text);
}
var text = msg_string.Text.TrimEnd(new char[] { '\r', '\n' });
List <string> stringsequenced = new List <string>();
for (int i = 1; i <= text.Length; i++)
{
char[] container = new char[i];
for (int x = 0; x < i; x++)
{
container[x] = text[x];
}
stringsequenced.Add(new string(container));
}
await Task.Run(() =>
{
int counter = 1;
foreach (var subtext in stringsequenced)
{
Dispatcher.Invoke(() =>
{
msg_string.Text = subtext;
var res = ImageRenderer.RenderToBWImg(Encoding.UTF8.GetBytes(subtext), ((scale_options)ScaleOption.SelectedItem).value, invert_checkbox.IsChecked ?? false, width, height);
PngBitmapEncoder pngencoder = new PngBitmapEncoder();
pngencoder.Frames.Add(BitmapFrame.Create(res));
using (var stream = new FileStream($"Test_{counter++}.png", FileMode.Create))
pngencoder.Save(stream);
});
}
});
}
public void Render_PassNullAsOutputStream_ShouldThrowException()
{
// Arrange
var renderer = new ImageRenderer();
var barcodeMock = new Mock <IBarcode>();
// Act
Action action = () => renderer.Render(barcodeMock.Object, null);
// Assert
action.Should().Throw <ArgumentNullException>()
.And.ParamName.Should().Be("outputStream");
}
