Is it possible to use imgui-go with a pure opengl?

[qFlensT]

Hello! Is it possible to use imgui-go with a pure opengl? Pay no attention to "CreateWindowInBandEx" it's almost the same as "CreateWindowEx".
I have the following code (just prototype):

package main

import (
	"fmt"
	"syscall"
	"unsafe"

	"github.com/go-gl/gl/v4.1-core/gl"

	imgui "github.com/inkyblackness/imgui-go/v4"

	w32 "github.com/gonutz/w32/v2"
)

var dc w32.HDC
var rc w32.HGLRC

func main() {
	var overlay Overlay
	overlay.Run()
}

type Overlay struct {
}

func (o Overlay) wndProc(hwnd w32.HWND, msg uint32, wParam, lParam uintptr) uintptr {
	switch msg {
	case w32.WM_DESTROY:
		w32.ReleaseDC(hwnd, dc)
		w32.WglDeleteContext(rc)
		w32.PostQuitMessage(0)
	default:
		return w32.DefWindowProc(hwnd, msg, wParam, lParam)
	}
	return 0
}

func (o Overlay) registerClassEx(name *uint16, hInstance w32.HINSTANCE) {
	var wcex w32.WNDCLASSEX
	wcex.WndProc = syscall.NewCallback(o.wndProc)
	wcex.Instance = hInstance
	wcex.ClassName = name
	w32.RegisterClassEx(&wcex)
}

func (o Overlay) winMain() {
	user32 := syscall.MustLoadDLL("user32.dll")
	procCreateWindowExW := user32.MustFindProc("CreateWindowInBandEx")

	className, err := syscall.UTF16PtrFromString("Kezzo Overlay")
	if err != nil {
		fmt.Println("[className] Error: ", err.Error())
	}

	title, err := syscall.UTF16PtrFromString("Kezzo Overlay")
	if err != nil {
		fmt.Println("[title] Error: ", err.Error())
	}

	hInstance := w32.GetModuleHandle("")

	o.registerClassEx(className, hInstance)

	hwnd, _, err := procCreateWindowExW.Call(
		0, //w32.WS_EX_NOACTIVATE|w32.WS_EX_LAYERED|w32.WS_EX_TRANSPARENT,
		uintptr(unsafe.Pointer(className)),
		uintptr(unsafe.Pointer(title)),
		w32.WS_VISIBLE|w32.WS_OVERLAPPEDWINDOW,
		0,
		0,
		400,
		400,
		0,
		0,
		uintptr(hInstance),
		uintptr(unsafe.Pointer(nil)),
		1,
		0)

	if hwnd == 0 {
		fmt.Println("[CreateWindowInBandEx] Error: ", err.Error())
	}

	pfd := w32.PIXELFORMATDESCRIPTOR{
		uint16(unsafe.Sizeof(w32.PIXELFORMATDESCRIPTOR{})), //  size of this pfd
		1, // version number
		w32.PFD_DRAW_TO_WINDOW | // support window
			w32.PFD_SUPPORT_OPENGL | // support OpenGL
			w32.PFD_DOUBLEBUFFER, // double buffered
		w32.PFD_TYPE_RGBA, // RGBA type
		24,                // 24-bit color depth
		0, 0, 0, 0, 0, 0,  // color bits ignored
		0,          // no alpha buffer
		0,          // shift bit ignored
		0,          // no accumulation buffer
		0, 0, 0, 0, // accum bits ignored
		32,                 // 32-bit z-buffer
		0,                  // no stencil buffer
		0,                  // no auxiliary buffer
		w32.PFD_MAIN_PLANE, // main layer
		0,                  // reserved
		0, 0, 0,            // layer masks ignored
	}
	dc = w32.GetDC(w32.HWND(hwnd))
	pf := w32.ChoosePixelFormat(dc, &pfd)
	w32.SetPixelFormat(dc, pf, &pfd)
	rc = w32.WglCreateContext(dc)
	w32.WglMakeCurrent(dc, rc)
	gl.Init()
	gl.Viewport(0, 0, 400, 400)
	gl.PointSize(2)

	imgui.CreateContext(nil)
	imgui.StyleColorsClassic()
	imgui.CurrentIO().DisplayFrameBufferScale()

	w32.ShowWindow(w32.HWND(hwnd), w32.SW_SHOW)
	w32.UpdateWindow(w32.HWND(hwnd))
}

func (o Overlay) Run() {
	o.winMain()
	open := true
	var msg w32.MSG
	for w32.GetMessage(&msg, 0, 0, 0) > 0 {
		gl.ClearColor(.2, .2, 0.2, 1.0)
		gl.Clear(0x00004000)

		imgui.NewFrame()
		imgui.ShowDemoWindow(&open)
		imgui.Render()

		w32.SwapBuffers(dc)
		w32.TranslateMessage(&msg)
		w32.DispatchMessage(&msg)
	}
}

[dertseha]

Hi @qFlensT !
Thank you for your message. Do I understand you correctly, you want to be in control by yourself to create a window and the corresponding OpenGL context?

I don't see anything against this, as SDL and GLEW do the same thing in the background.

To better separate the three things of

• setting up the platform (direct Windows calls instead of wrapped via other library),
• setting up and utilizing OpenGL calls, and
• rendering a sample scenario,

I propose that you start off with https://github.com/inkyblackness/imgui-go-examples and you create a new platform implementation, where you only concentrate on the Win32 API. Then you can also get something running quicker.

When you got something working, then you extract the learnt details for your actual application.

[qFlensT]

@dertseha I want to create a window using the CreateWindowInBandEx function using winapi, so that I can turn it into an overlay, that runs on top of full-screen applications. Just using my code I am getting the error: g.IO.DisplaySize.x >= 0.0f && g.IO.DisplaySize.y >= 0.0f && "Invalid DisplaySize value!". Maybe I'm doing something wrong, sorry, I'm new to this scope.

[dertseha]

That error comes from some missing setup calls to imgui. In this case, the current display size is necessary; It hasn't been told to imgui yet.
The example application does this here for instance.

Though there might be more calls missing. Hence I recommend you try to integrate your window as a platform equivalent in the examples application. Because the example application does all the necessary setup, and you can use it as a reference to implement your "platform".
Pick the glfw.go file for instance, create an inband.go and write a similar implementation through side-by-side comparison. Skip what you won't need - for example keyboard handling.

[qFlensT]

I will try. Thank you

[dertseha]

Hey, @qFlensT - did the approach with a proper initialization help? What's your status?

[qFlensT]

@dertseha Thanks for the question! I was still trying to do something with it for a while, but I realized that it would be quite difficult to make it work and abandoned it! I think C++ is a better language for this.