opentk / learnopentk Goto Github PK

Trying to run a Project using the Texture class results in the following exception:

System.IO.FileLoadException: Could not load file or assembly 'System.Numerics.Vectors, Version=4.1.3.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies. The located assembly's manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)
at at LearnOpenTK.Common.Texture..ctor(String path)
at at LearnOpenTK.Window.OnLoad(EventArgs e)
at at OpenTK.GameWindow.OnLoadInternal(EventArgs e)
at at OpenTK.GameWindow.Run(Double updates_per_second, Double frames_per_second)
at at OpenTK.GameWindow.Run(Double updateRate)
at at LearnOpenTK.Program.Main(String[] args)

This seems to be a problem with ImageSharp. I'm currently using the old Texture class with System.Drawing instead which is working fine.

When i'm try to use code from chapter 1 leasson 2, i got error Fatal error. System.AccessViolationException: Attempted to read or write protected memory. This is often an indication that other memory is corrupt.

GameEngine.cs

`
using System;
using System.Drawing;
using GameTry.Common;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Windowing.Common;
using OpenTK.Windowing.Desktop;
using OpenTK.Windowing.GraphicsLibraryFramework;
namespace GameTry
{
public sealed class GameEngine : GameWindow
{
private readonly float[] _vertices =
{
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f,
};

    private Shader _shader;
    private int _vertexBufferObject;
    private int _vertexArrayObject;

    public GameEngine(GameWindowSettings gameWindowSettings, NativeWindowSettings nativeWindowSettings) : base(
        gameWindowSettings, nativeWindowSettings)
    {
    }

    /// <summary>Run immediately after Run() is called.</summary>
    /// <footer><a href="https://www.google.com/search?q=OpenTK.Windowing.Desktop.GameWindow.OnLoad">`GameWindow.OnLoad` on google.com</a></footer>
    protected override void OnLoad()
    {
        base.OnLoad();
        GL.ClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        _vertexBufferObject = GL.GenBuffer();
        GL.BufferData(BufferTarget.ArrayBuffer, _vertices.Length * sizeof(float), _vertices,
            BufferUsageHint.StaticDraw);
        CursorVisible = true;
        _vertexArrayObject = GL.GenVertexArray();
        GL.BindVertexArray(_vertexArrayObject);
        GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), 0);
        GL.EnableVertexAttribArray(0);
        _shader = new Shader("Shaders/shader.vert", "Shaders/shader.frag");
        _shader.Use();
    }

    protected override void OnRenderFrame(FrameEventArgs e)
    {
        base.OnRenderFrame(e);
        GL.Clear(ClearBufferMask.ColorBufferBit);

        _shader.Use();

        GL.BindVertexArray(_vertexArrayObject);
        GL.DrawArrays(PrimitiveType.Triangles, 0, 3);
        SwapBuffers();
    }

    protected override void OnUpdateFrame(FrameEventArgs e)
    {
        base.OnUpdateFrame(e);
        HandleKeybord();
    }


    private void HandleKeybord()
    {
        var input = KeyboardState;
        if (input.IsKeyDown(Keys.Escape))
        {
            Close();
        }
    }

    protected override void OnResize(ResizeEventArgs e)
    {
        base.OnResize(e);
        GL.Viewport(0, 0, Size.X, Size.Y);
    }

    protected override void OnUnload()
    {
        // Unbind all the resources by binding the targets to 0/null.
        GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
        GL.BindVertexArray(0);
        GL.UseProgram(0);

        // Delete all the resources.
        GL.DeleteBuffer(_vertexBufferObject);
        GL.DeleteVertexArray(_vertexArrayObject);

        GL.DeleteProgram(_shader.Handle);

        base.OnUnload();
    }
}

}`

`
using System;
using OpenTK.Mathematics;
using OpenTK.Windowing.Common;
using OpenTK.Windowing.Desktop;

namespace GameTry
{
class Programm
{

    public static void Main(string[] args)
    {
        var nativeWindowSettings = new NativeWindowSettings()
        {
            Size = new Vector2i(1920, 1024),
            Title = "FirstGameEngineTry",
            Flags = ContextFlags.ForwardCompatible
        };
        using (GameEngine gameEngine = new(GameWindowSettings.Default, nativeWindowSettings))
        {
            gameEngine.Run();
        }
    }
}

}`

what i do wrong?

I have seen many libraries matrix4 like Monogame or System.Numerics.Matrix4x4 ... support both Matrix4.CreatePerspective( ) and Matrix4.CreatePerspectiveFieldOfView( ) method.
So, why OpenTK decided to do not support Matrix4.CreatePerspective( ), but only Matrix4.CreatePerspectiveFieldOfView( ) ?

And show for me the differences between Matrix4.CreatePerspective( ) vs Matrix4.CreatePerspectiveFieldOfView( ).

Many thanks for your help.

How do I map System.Drawing.Imaging.PixelFormat to opentk.graphics.es30.pixelFormat? I can't find an example that uses ES30 when going from a call to Bitmap.LockBits to a call to GL.TexImage2D. I want my OpenTK code to work on mobile devices. I have a png that is a color gradient that I'm using to texture triangles using a shader with a texture. PixelFormat.Brga is not available, and the ES30 PixelFormat.Rgba doesn't seem to work.

TextureId = GL.GenTexture();
CheckError();
GL.BindTexture(TextureTarget.Texture2D, TextureId);
CheckError();

System.Drawing.Bitmap bmp = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile(TextureFilename);
System.Drawing.Imaging.BitmapData data = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height),
    System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb);

GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
CheckError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);
CheckError();

GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
CheckError();
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
CheckError();
GL.PixelStore(PixelStoreParameter.PackAlignment, 1);
CheckError();

GL.TexImage2D(TextureTarget2d.Texture2D, 0, TextureComponentCount.Rgba, data.Width, data.Height, 0, 
    PixelFormat.Rgba, PixelType.UnsignedByte, data.Scan0);
CheckError();

GL.GenerateMipmap(TextureTarget.Texture2D);
CheckError();

GL.BindTexture(TextureTarget.Texture2D, 0);
CheckError();
bmp.UnlockBits(data);

No link in readme to actual tutorial
add link to https://opentk.net/learn/index.html in readme pls
I spent 2h bc I thought this is the extent of the tutorial(

Hmmm... It seems the shader class is missing from the tutorial files of the Hello Triangle lesson...

In Lightning Sample, you will get strange edge artifacts, if you move a litte arround the cube. This is because you dont have face culling enabled. If you enable this, the cube is drawn only half. So, the clockwiese/counter-clockwise points have to be corrected.

This may out of scope of that tutorial, but even if you don't want enable face culling, you should at least correct the vertices to:

        private readonly float[] _vertices =
        {
             // Position          Normal
             0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f, // Front face
            -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
             0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
            -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
             0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
            -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

            -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f, // Back face
             0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
             0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
             0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
            -0.5f,  0.5f,  0.5f,  0.0f,  0.0f,  1.0f,
            -0.5f, -0.5f,  0.5f,  0.0f,  0.0f,  1.0f,

            -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f, // Left face
            -0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
            -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
            -0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
            -0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
            -0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,

             0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f, // Right face
             0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
             0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
             0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
             0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
             0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,

            -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f, // Bottom face
             0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
             0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
             0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
            -0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
            -0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,

            0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f, // Top face
           -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
            0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
           -0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
            0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
           -0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
        };

I started converting some of the LearnOpenGL tutorials to LearnOpenTK. You can find them here: https://github.com/mludlum/LearnOpenTK

I had copied the Shader class without initially thinking about it much. Today I was basically rewriting it and noticed the disposal logic, much of which originated with the tutorial code. This is a bit nitpicky, but the discussion of unmanaged resource cleanup in the 1.2 Hello Triangle chapter at the end of the Compiling the Shaders section may warrant reconsideration.

.NET finalizers aren't remotely equivalent to C++ destructors, so it doesn't make sense to state, "We can't do it in the finalizer due to the Object-Oriented Language Problem." Nobody should be contemplating resource cleanup in the finalizer as correct behavior in the first place, completely irrespective of whether or not it's problematic for OpenGL specifically.

The code, of course, is meant to output a warning if disposal wasn't correctly called but (a) that's detrimental to performance because declaring a finalizer adds it to .NET's finalizer tracking queue, (b) there's no guarantee about when a finalizer might be invoked, or whether it will be invoked at all, ever, and (c) in practice they are never invoked when the application is exiting, which is the most likely scenario here. So in short, while a warning message looks like a good idea, in reality it'll never actually be seen. It's wasted effort.

I'd say it makes the most sense just to show a Dispose method. Also, I suppose the sample code was cut-and-pasted from somewhere else since arguments like bool disposing aren't even used (that's an arguably-bad design when you want to know whether or not Dispose is being called from the finalizer.) Even though the class shouldn't have a finalizer, it should still call SuppressFinalize in case a derived class does declare a finalizer.

Just keep it simple:

private bool IsDisposed = false;

public virtual void Dispose()
{
    if (IsDisposed) return;

    GL.DeleteProgram(Handle);
    IsDisposed = true;
    GC.SuppressFinalize(this);
}

Like I said, nitpicky.

OpenTK4
https://opentk.net/learn/chapter1/2-hello-triangle.html?tabs=onload-opentk4%2Conrender-opentk4%2Cresize-opentk4#some-new-functions
What in sample is

protected override void OnFramebufferResize(ResizeEventArgs e)
{
    base.OnFramebufferResize(e);

    GL.Viewport(0, 0, e.Width, e.Height);
}

but the parameter in source is

protected virtual void OnFramebufferResize(FramebufferResizeEventArgs e)
{
  Action<FramebufferResizeEventArgs> framebufferResize = this.FramebufferResize;
  if (framebufferResize == null)
      return;
  framebufferResize(e);
}

vertex shader must be : PVM * position

gl_Position = u_projectionMatrix * u_viewMatrix * u_modelMatrix * vec4(a_position, 1.0);

encountered in visual studio 2019.

Forms designer actually calls the subscribed events when you do stuff like clicking, resizing the control that inherits/has a glcontrol.

To stop it from crashing:
make a private bool isInDesignMode = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);

and then do a if(isInDesignMode) {return} check before any other logic, in the affected methods (examples are onResize, onPaint).

OpenGL loads textures upside down by default, and the Texture.cs texture is not flipped before it is loaded. When you run the application this causes the textures to be rendered upside down.

Putting this on line 27 should fix this problem:

image.RotateFlip(RotateFlipType.RotateNoneFlipY);

Hi! I'm limited in the GL version due the old platform that I want to run the program, I have zero experience with OpenGL so I'm already stuck in the example 2 that use Shaders that can't be compiled in the ES20 and functions that aren't avaiable too, is there any example, maybe a working project, using OpenTK for ES2.0?

I set the window to (1280, 720) but the GL.Viewport is actually set to:

When I used ClientRectangle.Size.X and ClientRectangle.Size.Y it became proper:

Here is examples of the console. Where should I find examples of Winform?

in 1.2 Hello Triangle's documentation, section Compiling the Shaders, a Use() method is defined in the Shader class, but there was no explicit accessibility level defined for the method so it defaulted to private meaning that the program would compile with error CS0122. the method should've been defined as: public void Use() { GL.UseProgram(Handle); } so that it is accessible to members outside of its class. it has the correct accessibility level in this repository here though.

In the "In practice" section of the 1.6 Transformations tutorial - https://opentk.net/learn/chapter1/6-transformations.html#in-practice, the trans matrix in the first code box is incorrect. Based on the text description, the x and y values should be 1.0f, not 0.1f, i.e. it should be this:

Matrix4 trans = Matrix4.CreateTranslation(1.0f, 1.0f, 0.0f);

however it is written as this:

Matrix4 trans = Matrix4.CreateTranslation(0.1f, 0.1f, 0.0f);

Chapter 1 / 6 says ..

            // shader.frag has been modified yet again, take a look at it as well.
            _shader = new Shader("Shaders/shader.vert", "Shaders/shader.frag");
            _shader.Use();

when it should say...

            // shader.vert has been modified, take a look at it as well.
            _shader = new Shader("Shaders/shader.vert", "Shaders/shader.frag");
            _shader.Use();

I've copied the code from the repo commit d71bd15.

I've tried both versions 4.6.4 and 5.0.0-pre.6.

I've modified Program.cs like this:

--- a/Program.cs
+++ b/Program.cs
@@ -12,6 +12,7 @@ namespace LearnOpenTK
          {
             Size = new Vector2i(800, 600),
             Title = "LearnOpenTK - Creating a Window",
+            APIVersion = new Version(3, 2)
          };
 
          // To create a new window, create a class that extends GameWindow, then call Run() on it.

I've tried versions 3.2, 3.3 and 4.1. The comments in the NativeWindowSettings.cs indicate these should all work on MacOS.

I'm consistently getting this exception:

Unhandled exception. OpenTK.Windowing.GraphicsLibraryFramework.GLFWException: NSGL: The targeted version of macOS only supports forward-compatible core profile contexts for OpenGL 3.2 and above
at OpenTK.Windowing.Desktop.GLFWProvider.<>c.<.cctor>b__5_0(ErrorCode errorCode, String description)
Abort trap: 6

Here is the output of my "dotnet --info"

.NET SDK (reflecting any global.json):
Version: 5.0.102
Commit: 71365b4d42

Runtime Environment:
OS Name: Mac OS X
OS Version: 10.15
OS Platform: Darwin
RID: osx.10.15-x64
Base Path: /usr/local/share/dotnet/sdk/5.0.102/

Host (useful for support):
Version: 5.0.2
Commit: cb5f173b96

.NET SDKs installed:
3.1.201 [/usr/local/share/dotnet/sdk]
3.1.403 [/usr/local/share/dotnet/sdk]
3.1.404 [/usr/local/share/dotnet/sdk]
5.0.100 [/usr/local/share/dotnet/sdk]
5.0.101 [/usr/local/share/dotnet/sdk]
5.0.102 [/usr/local/share/dotnet/sdk]

.NET runtimes installed:
Microsoft.AspNetCore.App 3.1.9 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 3.1.10 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 5.0.0 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 5.0.1 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 5.0.2 [/usr/local/share/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.NETCore.App 2.1.23 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 2.2.8 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 3.1.9 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 3.1.10 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 5.0.0 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 5.0.1 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]
Microsoft.NETCore.App 5.0.2 [/usr/local/share/dotnet/shared/Microsoft.NETCore.App]

To install additional .NET runtimes or SDKs:
https://aka.ms/dotnet-download

using LearnOpenTK.Common; is not a valid using statement in Chapter 1 Lesson 2 and the lesson uses the Shader class from it

EDIT:
I realized it was in this repo in Common possibly a note of that on the tutorials or readme

GL.UniformMatrix4 is a fairly standard function, similar to the other Uniform functions we've seen so far. The parameters are as follows:

The location of the uniform on the shader.
A boolean, determining whether or not the matrices should be transposed. Since OpenTK uses row-major, whereas GLSL typically uses column-major, you'll almost always want to use true here.
A reference to the matrix we want to pass.]

It appears that at some point, the folder names in this repo wre changed to remove spaces, but some of the links in the book weren't updated for this, leading to broken links.

One other thought I had, it would be nice if there was a link from every page to the repo folder for that page, only a few pages have links.

The variable FragPos was removed in 14878e5 but there's still a leftover in line 39.

Chapter2/6-MultipleLights sample are crash for me (I'm run it on Intel HD 4600 video, if it matters at all, doesn't sure, i'm completely newbie in OpenGL).

The issue is what Shader.cs fills _uniformLocations by using call GL.GetProgram(Handle, GetProgramParameterName.ActiveUniforms, out var numberOfUniforms);. However this call doesn't report all locations.

I'm checked LearnOpenGL example, and it uses bit different way, so i'm put few changes:

diff --git a/Common/Shader.cs b/Common/Shader.cs
index 1ff74d2..3ec0c16 100644
--- a/Common/Shader.cs
+++ b/Common/Shader.cs
@@ -155,8 +155,9 @@ namespace LearnOpenTK.Common
         /// <param name="data">The data to set</param>
         public void SetFloat(string name, float data)
         {
+            var uniformLocation = GL.GetUniformLocation(Handle, name);
             GL.UseProgram(Handle);
-            GL.Uniform1(_uniformLocations[name], data);
+            GL.Uniform1(uniformLocation, data);
         }
 
         /// <summary>
@@ -182,8 +183,9 @@ namespace LearnOpenTK.Common
         /// <param name="data">The data to set</param>
         public void SetVector3(string name, Vector3 data)
         {
+            var uniformLocation = GL.GetUniformLocation(Handle, name);
             GL.UseProgram(Handle);
-            GL.Uniform3(_uniformLocations[name], data);
+            GL.Uniform3(uniformLocation, data);
         }
     }
 }

And that's makes example to run. Surely, this requires more accurate fix.

The current namespace (LearnOpenGL_TK) does not match the github repository and does not make a lot of sense (LearnOpenGL_ToolKit?).

I think the namespace should be changed to LearnOpenTK

Hi all,
Some of the information on the "Textures" page of the Learn OpenTK page may have fallen out of date, as unless my IDE (Visual Studio) is just being the usual bag of uselessness that it often is, one of the ImageSharp functions has changed.

It appears you can no longer create a byte array simply by using image.GetPixelSpan().ToArray().

Possibly related to: SixLabors/ImageSharp#1164.

I am having a hard time with it.. Using OpenGL4 - Thank you

When I try to build the latest LearnOpenTK, I get the subject error. Line 113 of Chapter1\8-Camera\Window.cs. The assignment
CursorVisible = false;
on line 112 has no error.

Big sur 11.2.2
OpenTK 4.7.4
libgdiplus
5-Textures
System.Drawing.Common is not supported on non-Windows platforms. See https://aka.ms/systemdrawingnonwindows for more information.
I uninstalled libgdiplus and nuget sixlabs Imagesharp, but the problem exists？

The current samples are not handling correctly the resizing of the window :

Current code :
GL.Viewport(0, 0, Size.X, Size.Y);

Proposal for fix :
Vector2i fb = this.FramebufferSize;
GL.Viewport(0, 0, fb.X, fb.Y);

Variable Light is not defined in lighting.frag (Tutorial 2.4).
The struct Light and the uniform light were mistaken

Hi.

I'm quite confusing about openTK name space "OpenTK.Graphics.OpenGL", and "OpenTK.Graphics.OpenGL4".

Does OpenTk only implement OpenGL2 and OpenGL4, where is openGL3
I read on Lean openTK site. It used openTK 3 but I can not see any code implement openGL 3 in opentk project.
Only 2 folder/ namespce for openGL2 and openGL4 (image bellow).

Help me resolve. Thanks

The project file in tutorial 2.5 has a typo (Ligh instead of Light)

Path: Chapter 2/5 - Light casters - directional lights/5 - Ligh casters - directional lights.csproj

The github source includes using OpenTK.Input; This is included, but not in the html documentation.(https://opentk.net/learn/chapter1/1-creating-a-window.html).

• Centered Orthographics camera
• Topleft Projection camera
• TopLeft Orthographics camera
• Scaling up vertices and uvs to pixel coordinates
• Custom 2D Drawing functions
• Custom 3D Drawing functions

Hi there. If I define buffers inside the OpenTkInit() method like in tutorials, it work OK. But if I do same in some other method after the OpenTK is already initialized, GL.GenBuffer() gets zero. How to solve it? I need to add buffered data during the runtime. For example, add some surface from the file or remove it.

When resizing on MacOS, the rendered objects are divided by 2.

The solution consists to use scale factor :

    // Initialise the Scale Factor
    float scaleFactorX = 1.0f;
    float scaleFactorY = 1.0f;

And to identify it correctly on MacOS (2.0f on my Mac) during the OnLoad():

        // Get the Scale Factor of the Monitor
        this.TryGetCurrentMonitorScale(out scaleFactorX, out scaleFactorY);

Then the OnResize() needs to use it :

        GL.Viewport(0, 0, (int)(Size.X * scaleFactorX), (int)(Size.Y * scaleFactorY));

With this method, the window once resized is displaying correctly the object :