Pixel data is ARGB, 1 byte for alpha, 1 for red, 1 for green, 1 for blue. Alpha is the most significant byte, >blue is the least significant. On a little-endian machine, like yours and many others, the little end is >stored first so the byte order is bb gg rr aa. So 0 0 255 255 equals blue = 0, green = 0, red = 255, alpha = >255. That's red.

This endian-ness order detail disappears when you cast bd.Scan0 to an int* (pointer-to-integer) since integers >are stored little-endian as well.

Signed Distance Field

http://www.valvesoftware.com/publications/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf

http://http.developer.nvidia.com/GPUGems3/gpugems3_ch34.html

https://www.eventbrite.com/engineering/its-2015-and-drawing-text-is-still-hard-webgl-threejs/

https://github.com/libgdx/libgdx/wiki/Distance-field-fonts

https://www.mapbox.com/blog/text-signed-distance-fields/

http://forum.libcinder.org/#Topic/23286000001127007

https://www.youtube.com/watch?v=CGZRHJvJYIg

https://github.com/paulhoux/Cinder-Samples/tree/master/TextRendering

Multi-channel signed distance field

https://lambdacube3d.wordpress.com/2014/11/12/playing-around-with-font-rendering/

http://computergraphics.stackexchange.com/questions/306/sharp-corners-with-signed-distance-fields-fonts

https://github.com/Chlumsky/msdfgen

http://www.codeproject.com/Articles/1002533/Antialiasing-with-a-Signed-Distance-Field

http://www.numb3r23.net/2015/08/17/using-fwidth-for-distance-based-anti-aliasing/

GPU Text Rendering with Vector Texture

http://wdobbie.com/post/gpu-text-rendering-with-vector-textures/

The previous two techniques(1) were based on taking the original glyph description, which is a list of bezier curves, and using the CPU to produce an image of it that can be consumed by the GPU. What if we let the GPU render from the original vector data?

(1)= font atlas, pixel-based signed distance fields

http://wdobbie.com/post/gpu-text-rendering-with-vector-textures-details/

http://wdobbie.com/pdf/

http://www.pouet.net/topic.php?which=9119

https://twitter.com/adamjsimmons

https://www.shadertoy.com/view/ltXSDB

Scanline Rasterization

http://josiahmanson.com/research/scanline_rasterization/scanline_rasterization.pdf

Enable OpenGL ES Extensions

https://www.khronos.org/registry/gles/extensions/OES/OES_standard_derivatives.txt

https://github.com/AnalyticalGraphicsInc/cesium/issues/745

https://developer.mozilla.org/en-US/docs/Web/API/OES_standard_derivatives

https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Using_Extensions

Draw Text

http://jcgt.org/published/0002/01/04/paper.pdf

http://www.antigrain.com/research/font_rasterization/

http://iristech.co/fonts/

http://iristech.co/font-focus/

http://www.msr-waypoint.net/en-us/um/people/cloop/LoopBlinn05.pdf

http://jcgt.org/published/0002/01/04/paper.pdf (Journal of Computer Graphics Techniques Higher Quality 2D Text Rendering Vol. 2, No. 1, 2013)

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.403.5191&rep=rep1&type=pdf (GPU-accelerated Path Rendering Mark J. Kilgard Jeff Bolz NVIDIA Corporation)

http://prideout.net/blog/?p=22 (The Little Grasshopper Antialiased Cel Shading)

http://computergraphics.stackexchange.com/questions/61/what-is-fwidth-and-how-does-it-work

Glyph, GPU accelerated Font Rendering

https://vimeo.com/83732058

Microsoft Universal Shaping Engine

https://www.microsoft.com/typography/OpenTypeDev/USE/intro.htm

The Raster Tragedy at Low-Resolution Revisited

http://www.beatstamm.com/Typography/index.htm

DirectWrite Text Rendering in Firefox 6

https://blog.mozilla.org/nattokirai/2011/08/11/directwrite-text-rendering-in-firefox-6/

Manipulating colors in .NET - Part 1

http://www.codeproject.com/Articles/19045/Manipulating-colors-in-NET-Part

Race condition with static class

http://stackoverflow.com/questions/9792163/race-condition-with-static-class/9792537#9792537

https://ericlippert.com/2013/01/31/the-no-lock-deadlock/

Win32's Bitblt

https://msdn.microsoft.com/en-us/library/windows/desktop/dd183402(v=vs.85).aspx

Host .net runtime

https://github.com/dotnet/docs/tree/master/samples/core/hosting

http://druss.co/2016/08/deploy-and-run-net-core-application-without-installed-runtime-self-contained-applications/

Google C++ style

https://google.github.io/styleguide/cppguide.html

C++ Made Easier: The Rule of Three

http://www.drdobbs.com/c-made-easier-the-rule-of-three/184401400

https://github.com/prepare/opendiagram

https://github.com/prepare/Krypton

http://burtleburtle.net/bob/hash/perfect.html

https://stackoverflow.com/questions/553244/programmatic-way-to-get-all-the-available-languages-in-satellite-assemblies

Premultiplied alpha:

https://microsoft.github.io/Win2D/html/PremultipliedAlpha.htm

https://blogs.msdn.microsoft.com/shawnhar/2009/11/06/premultiplied-alpha/

https://blogs.msdn.microsoft.com/shawnhar/2009/11/07/premultiplied-alpha-and-image-composition/

https://gamedev.stackexchange.com/questions/129213/color-spaces-should-colors-be-converted-to-linear-color-before-applying-premult

http://ssp.impulsetrain.com/gamma-premult.html

https://taylorpetrick.com/portfolio/webgl/convolution

CreateDIBSection function

https://msdn.microsoft.com/en-us/library/windows/desktop/dd183494(v=vs.85).aspx

Chromium's GPU Accelerated Compositing in Chrome

https://www.chromium.org/developers/design-documents/gpu-accelerated-compositing-in-chrome

Chromium's slimming-paint

https://www.chromium.org/blink/slimming-paint

https://gamedev.stackexchange.com/questions/18777/how-do-i-implement-anti-aliasing-in-opengl

http://www.iryoku.com/mlaa/

http://www.iryoku.com/smaa/

http://iryoku.com/aacourse/

https://mattdesl.svbtle.com/drawing-lines-is-hard

http://cgg.mff.cuni.cz/projects/SkylightModelling/

Adaptive Temporal Antialiasing (2018)

https://casual-effects.com/research/Marrs2018Antialias/Marrs2018Antialias.pdf

http://www.realtimerendering.com/blog/webgl-2-new-features/

https://mattdesl.svbtle.com/

https://mattdesl.svbtle.com/material-design-on-the-gpu

http://www.angelcode.com/products/bmfont/

https://www.disneyanimation.com/technology/innovations/hyperion

https://software.intel.com/en-us/blogs/2013/10/10/conservative-morphological-anti-aliasing-cmaa

gamma

http://blog.johnnovak.net/2016/09/21/what-every-coder-should-know-about-gamma/

https://codelab.wordpress.com/2012/10/26/color-space-linearity-and-gamma-correction/

https://gamedevelopment.tutsplus.com/articles/gamma-correction-and-why-it-matters--gamedev-14466

https://gamedev.stackexchange.com/questions/74324/gamma-space-and-linear-space-with-shader

https://www.g-truc.net/post-0263.html

https://jmonkeyengine.github.io/wiki/jme3/advanced/jme3_srgbpipeline.html

https://www.w3.org/Graphics/Color/sRGB.html

https://stackoverflow.com/questions/16521003/gamma-correction-formula-gamma-or-1-gamma

https://docs.microsoft.com/en-us/windows/uwp/gaming/port-from-opengl-es-2-0-to-directx-11-1

https://stackoverflow.com/questions/2508818/how-to-debug-a-glsl-shader

https://www.davrous.com/2013/06/13/tutorial-series-learning-how-to-write-a-3d-soft-engine-from-scratch-in-c-typescript-or-javascript/

How a TV Works in Slow Motion - The Slow Mo Guys https://www.youtube.com/watch?v=3BJU2drrtCM

https://docs.microsoft.com/en-us/cpp/ide/deploying-native-desktop-applications-visual-cpp

https://blogs.msdn.microsoft.com/astebner/2010/10/20/mailbag-how-to-perform-a-silent-install-of-the-visual-c-2010-redistributable-packages/

Curve Flattener

http://tsunami.cis.usouthal.edu/~hain/general/Publications/Bezier/bezier%20cccg04%20paper.pdf

http://antigrain.com/research/adaptive_bezier/

https://pdfs.semanticscholar.org/afa0/260d90f4976cb902d8fd0da1313f7c1b3b51.pdf

Splines

https://www.tinaja.com/cubic01.shtml

https://pomax.github.io/bezierinfo/en-GB/

Polygon HitTest

https://stackoverflow.com/questions/217578/how-can-i-determine-whether-a-2d-point-is-within-a-polygon

https://wrf.ecse.rpi.edu//Research/Short_Notes/pnpoly.html

https://wrf.ecse.rpi.edu/pmwiki/pmwiki.php

Image Tracing , Bitmap to Vector

http://potrace.sourceforge.net/potrace.pdf , please note that the original potrace implementation is GPL code!, (I just add potrace doc paper, I don't use/see the actual code.)

Debug Tips:

https://github.com/SixLabors/Shapes/pull/43#issuecomment-390358702

A Brief History of .NET Standard:

https://blog.xamarin.com/history-dot-net-standard/?utm_source=vs_developer_news&utm_medium=referral

Using OpenGL ES 2.0 on the Raspberry Pi without X windows.

https://benosteen.wordpress.com/2012/04/27/using-opengl-es-2-0-on-the-raspberry-pi-without-x-windows/

http://www.reedbeta.com/blog/antialiasing-to-splat-or-not/

https://stackoverflow.com/questions/14456809/apply-clippath-to-transformed-g-element

https://www.sarasoueidan.com/blog/css-svg-clipping/

http://www.albahari.com/threading/part2.aspx

https://stackoverflow.com/questions/18333885/threadstatic-v-s-threadlocalt-is-generic-better-than-attribute

http://tylerbrooksdesigns.com/projects/icon-font/

https://learnopengl.com/Advanced-OpenGL/Anti-Aliasing

see some useful doc about gles3 =>

http://www.realtimerendering.com/blog/webgl-2-new-features/

https://github.com/shrekshao/MoveWebGL1EngineToWebGL2/blob/master/Move-a-WebGL-1-Engine-To-WebGL-2-Blog-1.md

https://github.com/shrekshao/MoveWebGL1EngineToWebGL2/blob/master/Move-a-WebGL-1-Engine-To-WebGL-2-Blog-2.md

https://developer.apple.com/library/archive/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/AdoptingOpenGLES3/AdoptingOpenGLES3.html

https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_multisampled_render_to_texture.txt

https://www.khronos.org/registry/OpenGL/extensions/APPLE/APPLE_framebuffer_multisample.txt

https://learnopengl.com/Advanced-OpenGL/Anti-Aliasing

https://learnopengl.com/Advanced-OpenGL/Framebuffers

http://www.g-truc.net/

sRGB

https://en.wikipedia.org/wiki/SRGB

https://www.pantone.com/the-srgb-color-space

https://www.g-truc.net/post-0263.html

https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch24.html

https://www.w3.org/Graphics/Color/sRGB.html

http://blog.johnnovak.net/2016/09/21/what-every-coder-should-know-about-gamma/

https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_texture_sRGB.txt

... Conventional texture formats assume a linear color space. So for a conventional internal texture format such as GL_RGB8, the 256 discrete values for each 8-bit color component map linearly and uniformly to the [0,1] range.

The sRGB color space is based on typical (non-linear) monitor characteristics expected in a dimly lit office. It has been standardized by the International Electrotechnical Commission (IEC) as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 gamma correction. ...

https://bartwronski.com/2018/05/14/checkerboard-rendering-rotated-anti-aliasing-and-grid-frequencies/

from https://www.opengl.org/archives/resources/features/KilgardTechniques/oglpitfall/

OpenGL's Lower Left Origin

Given a sheet of paper, people write from the top of the page to the bottom. The origin for writing text is at the upper left-hand margin of the page (at least in European languages). However, if you were to ask any decent math student to plot a few points on an X-Y graph, the origin would certainly be at the lower left-hand corner of the graph. Most 2D rendering APIs mimic writers and use a 2D coordinate system where the origin is in the upper left-hand corner of the screen or window (at least by default). On the other hand, 3D rendering APIs adopt the mathematically minded convention and assume a lower left-hand origin for their 3D coordinate systems.

If you are used to 2D graphics APIs, this difference of origin location can trip you up. When you specify 2D coordinates in OpenGL, they are generally based on a lower left-hand coordinate system. Keep this in mind when using glViewport, glScissor, glRasterPos2i, glBitmap, glTexCoord2f, glReadPixels, glCopyPixels, glCopyTexImage2D, glCopyTexSubImage2D, gluOrtho2D, and related routines.

Another common pitfall related to 2D rendering APIs having an upper left-hand coordinate system is that 2D image file formats start the image at the top scan line, not the bottom scan line. OpenGL assumes images start at the bottom scan line by default. If you do need to flip an image when rendering, you can use glPixelZoom(1,-1) to flip the image in the Y direction. Note that you can also flip the image in the X direction. Figure 4 demonstrates using glPixelZoom to flip an image.

Note that glPixelZoom only works when rasterizing image rectangles with glDrawPixels or glCopyPixels. It does not work with glBitmap or glReadPixels. Unfortunately, OpenGL does not provide an efficient way to read an image from the frame buffer into memory starting with the top scan line.

Setting Your Raster Position to a Pixel Location

A common task in OpenGL programming is to render in window coordinates. This is often needed when overlaying text or blitting images onto codecise screen locations. Often having a 2D window coordinate system with an upper left-hand origin matching the window system's default 2D coordinate system is useful.

Here is code to configure OpenGL for a 2D window coordinate system with an upper left-hand origin where w and h are the window's width and height in pixels:

glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, w, h, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

Note that the bottom and top parameters (the 3rd and 4th parameters) to glOrtho specify the window height as the top and zero as the bottom. This flips the origin to put the origin at the window's upper left-hand corner.

Now, you can safely set the raster position at a pixel position in window coordinates like this

glVertex2i(x, y);
glRasterPos2i(x, y);

One pitfall associated with setting up window coordinates is that switching to window coordinates involves loading both the modelview and projection matrices. If you need to "get back" to what was there before, use glPushMatrix and glPopMatrix (but remember the pitfall about assuming the projection matrix stack has more than two entries).

All this matrix manipulation can be a lot of work just to do something like place the raster position at some window coordinate. Brian Paul has implemented a freeware version of the OpenGL API called Mesa. Mesa implements an OpenGL extension called MESA_window_pos that permits direct efficient setting of the raster position without disturbing any other OpenGL state. The calls are:

glWindowPos4fMESA(x,y,z,w);
glWindowPos2fMESA(x,y)

Here is the equivalent implementation of these routines in unextended OpenGL:

void glWindowPos4fMESAemulate(GLfloat x,GLfloat y,GLfloat z,GLfloat w) { GLfloat fx, fy;

/* Push current matrix mode and viewport attributes. */ glPushAttrib(GL_TRANSFORM_BIT | GL_VIEWPORT_BIT);

/* Setup projection parameters. */
glMatrixMode(GL_PROJECTION);
glPushMatrix();
  glLoadIdentity();
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
    glLoadIdentity();
    glDepthRange(z, z);
    glViewport((int) x - 1, (int) y - 1, 2, 2);
    /* Set the raster (window) position. */
    fx = x - (int) x;
    fy = y - (int) y;
    glRasterPos4f(fx, fy, 0.0, w);
  /* Restore matrices, viewport and matrix mode. */
  glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();

glPopAttrib(); }

void glWindowPos2fMESAemulate(GLfloat x, GLfloat y) { glWindowPos4fMESAemulate(x, y, 0, 1); }

Note all the extra work the emulation routines go through to ensure that no OpenGL state is disturbed in the process of setting the raster position. Perhaps commercial OpenGL vendors will consider implementing this extension.

https://01.org/beignet/blogs/mkollaro/2017/how-modern-opengl-and-gpus-work

https://stackoverflow.com/questions/25457323/how-to-rasterize-opengl-triangle-on-half-integer-pixels-centers

http://www.ntu.edu.sg/home/ehchua/programming/opengl/cg_basicstheory.html

Text Layout

https://www.youtube.com/watch?v=QrNi9FmdlxY

OpenGL Tess/ Winding Rule Type Note:

gluTess_winding_rule_type