win32_internal.h File Reference

#include "core/sbgl_input.h"
#include "sbgl_types.h"
#include <windows.h>

Include dependency graph for win32_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	sbgl_Window
	Native X11 window state. More...

Macros
#define	UNICODE
#define	WIN32_LEAN_AND_MEAN

Functions
void	win32_internal_process_message (sbgl_InputState *input, UINT msg, WPARAM wparam, LPARAM lparam)
void	win32_internal_update_input_states (sbgl_InputState *input, struct sbgl_Window *window)

Macro Definition Documentation

UNICODE

#define UNICODE

Definition at line 5 of file win32_internal.h.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 7 of file win32_internal.h.

Function Documentation

win32_internal_process_message()

void win32_internal_process_message	(	sbgl_InputState *	input,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam )

Definition at line 98 of file input.c.

                                                                                                    {
    if (!input) return;
    switch (msg) {
        case WM_KEYDOWN:
        case WM_SYSKEYDOWN: {
            SBGL_Scancode code = win32_vk_to_scancode(wparam);
            if (code < SBGL_SCANCODE_MAX) {
                // Filter auto-repeat: bit 30 of lparam indicates previous key state
                // If set, this is an auto-repeat message, not an initial press
                bool isRepeat = (lparam & (1 << 30)) != 0;
                if (!isRepeat) {
                    input->keysPressed[code] = true;
                }
                input->keysDown[code] = true;
            }
            break;
        }
        case WM_KEYUP:
        case WM_SYSKEYUP: {
            SBGL_Scancode code = win32_vk_to_scancode(wparam);
            if (code < SBGL_SCANCODE_MAX) input->keysDown[code] = false;
            break;
        }
        case WM_MOUSEMOVE: {
            input->mouseX = LOWORD(lparam);
            input->mouseY = HIWORD(lparam);
            break;
        }
        case WM_LBUTTONDOWN: input->mouseDown[SBGL_MOUSE_BUTTON_LEFT] = true; break;
        case WM_LBUTTONUP:   input->mouseDown[SBGL_MOUSE_BUTTON_LEFT] = false; break;
        case WM_RBUTTONDOWN: input->mouseDown[SBGL_MOUSE_BUTTON_RIGHT] = true; break;
        case WM_RBUTTONUP:   input->mouseDown[SBGL_MOUSE_BUTTON_RIGHT] = false; break;
        case WM_MBUTTONDOWN: input->mouseDown[SBGL_MOUSE_BUTTON_MIDDLE] = true; break;
        case WM_MBUTTONUP:   input->mouseDown[SBGL_MOUSE_BUTTON_MIDDLE] = false; break;
        case WM_KILLFOCUS: {
            /* Input states are cleared when the window loses focus to prevent 
               stuck keys or buttons from affecting the simulation. */
            memset(input->keysDown, 0, sizeof(input->keysDown));
            memset(input->mouseDown, 0, sizeof(input->mouseDown));
            break;
        }
    }
}

win32_internal_update_input_states()

void win32_internal_update_input_states	(	sbgl_InputState *	input,
		struct sbgl_Window *	window )

Definition at line 142 of file input.c.

                                                                                     {
    if (!input) return;
    
    if (window && window->cursorLocked) {
        // Use accumulated raw input deltas for high-precision camera control
        input->mouseDeltaX = window->accumulatedDeltaX;
        input->mouseDeltaY = window->accumulatedDeltaY;
        
        // Reset accumulators for next frame
        window->accumulatedDeltaX = 0;
        window->accumulatedDeltaY = 0;
        
        // Keep internal tracking in sync
        input->_internalMouseX = input->mouseX;
        input->_internalMouseY = input->mouseY;
    } else {
        // Use standard position-based delta calculation
        input->mouseDeltaX = input->mouseX - input->_internalMouseX;
        input->mouseDeltaY = input->mouseY - input->_internalMouseY;
        input->_internalMouseX = input->mouseX;
        input->_internalMouseY = input->mouseY;
    }
}