There are already a lot of good changes and new features in 0.11.0 that will be released as 0.12.0, but here are some more possibilities:

Direct VBO support GLES 3 renderer GL 4 renderer

After copying an image with GPU_CopyImage and then changing its target, such as with GPU_LoadTarget, there is a memory leak. gpu_copy_image_pixels_only creates a target for the newly copied image but does not free it. The user is not told that the copied image has a target that needs to be freed before creating a new one.

Hi,

It has been a big hassle to make it work on windows (with visual studio 2019) , hell I didn't even make it work, I just found a project that used sdl_gpu with an sln file in the repository and am testing that, but I saw there is only x64 compiler options, so I was wondering is it due sdl_gpu not supporting x86?

thank you

I'm trying to build the library on Cygwin:

mkdir build-cygwin
cd build-cygwin
cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(PREFIX)" -DSDL_gpu_DEFAULT_BUILD_DEMOS=OFF ..
make

This fails with errors about CALLBACK macro not being defined. It's defined in bundled GLEW/gl.h only if both _WIN32 and __CYGWIN__ macros are present, so I added this switch to cmake commandline:

 -DCMAKE_C_FLAGS="-D_WIN32"

The library now compiles, but linking step fails:

[  9%] Linking C shared library cygSDL2_gpu.dll
cd /cygdrive/c/Users/User/.../sdl-gpu/build-cygwin/src && /usr/bin/cmake.exe -E cmake_link_script CMakeFiles/SDL_gpu_shared.dir/link.txt --verbose=1
/usr/bin/cc  -D_WIN32   -shared -Wl,--enable-auto-import -o cygSDL2_gpu.dll -Wl,--out-implib,libSDL2_gpu.dll.a -Wl,--major-image-version,0,--minor-image-version,0 CMakeFiles/SDL_gpu_shared.dir/externals/glew/glew.c.o 
[skipped]
CMakeFiles/SDL_gpu_shared.dir/externals/stb_image_write/stb_image_write.c.o /cygdrive/c/Users/User/.../libroot/cygwin/lib/libSDL2.dll.a -Wl,-Bstatic -lm -Wl,-Bdynamic -lGL 
CMakeFiles/SDL_gpu_shared.dir/externals/glew/glew.c.o:glew.c:(.text+0x4ff): undefined reference to `__imp_wglGetProcAddress'
CMakeFiles/SDL_gpu_shared.dir/externals/glew/glew.c.o:glew.c:(.text+0x4ff): relocation truncated to fit: R_X86_64_PC32 against undefined symbol `__imp_wglGetProcAddress'
CMakeFiles/SDL_gpu_shared.dir/externals/glew/glew.c.o:glew.c:(.text+0x537): undefined reference to `__imp_wglGetProcAddress'
CMakeFiles/SDL_gpu_shared.dir/externals/glew/glew.c.o:glew.c:(.text+0x537): relocation truncated to fit: R_X86_64_PC32 against undefined symbol `__imp_wglGetProcAddress'

I've tried adding -lopengl32 to linker flags, but this didn't change anything. Any pointers are appreciated! I'm trying to link against native OpenGL, not the Cygwin's X11 OpenGL.

Is there a way to have a transparent main opengl window background that one can see what is behind the window? I checked the flags for GPU_Init but didn't found something regarding this.

I'm using Ubuntu 20.04 and have a project which currently already creates a native transparent xlib/xwindow opengl enabled and use SDL_CreateWindowFrom to be able to use SDL2 with it but now I want to integrate sdl-gpu. So I see two possibilities:

1. Passing gl context of this xwindow to sdl-gpu which should be used by this library.
2. Let do transparent background via GPU_Init / sdl-gpu without xwindow (should be preferred).

I would like to use option two because currently I have to manage events in XPending/XNextEvent but I would prefer to use SDLs SDL_PollEvent How can I manage this with sdl-gpu?

I'm building my project for 'Release' in vs2015. I'm using the libs generated from building SDL_gpu_shared for 'Release.' Using the latest SDL_gpu commit, building my project for 'Release' gets a lot of unresolved external errors for OpenGL functions. I must link opengl32.lib for my project to build. This is not the case when using the May 14th commit 7c3d8fa612465a452fe9baf4463db0fb422746c7. I do not need to link opengl32.lib in my project for the older commit. I'm not sure if this is desired behavior, but I wanted to let you know of the change.

Commit https://github.com/grimfang4/sdl-gpu/commit/d4a4b39e7defb2ff9728373d5f204d1dbe486a90 breaks our existing code, because the "fixed" order in that PR fails to scale the translate component of our MV matrices. So after the transforms we end up with a MVP matrix that looks something like this:

| | | | | | ---- | ---- | ---- | ---- | | tiny | 0 | 0 | 0 | | 0 | tiny | 0 | 0 | | 0 | 0 | tiny | 0 | | huge | huge | 0 | 1 |

... meaning all of our content is presumably rendered perfectly, but hundreds of screen-widths away.

The issue doesn't occur in the old version, or when we reverse the order of the matrix multiplication, as in this PR. Not sure if the old version was causing bugs, but we certainly get a blank screen on the latest master without the change in this PR.

Added GPU_Polygon2 function which draws optionally open polygons using line strips. Patched get_complete_color_mod to allow image = NULL.

Please accept my humble contribution.

SDL2 allows you to call SDL_CreateWindowFrom() on an existing GUI object's window handle, and then create a renderer on it. This technique doesn't appear to migrate well to SDL_GPU.

• Create a Windows form
• Create a control on it and obtain its HWND
• Create an SDL_Window on that HWND with SDL_CreateWindowFrom.
• Call SDL_GetWindowID on this window and GPU_SetInitWindow on the result
• Call GPU_Init

Expected: A working renderer Observed: GPU_Init fails. Could not initialize.

A bit of digging reveals that this happens because GLEW could not retrieve the version string, because SDL_GPU failed to initialize the first GL context before calling glewInit. After doing this manually on my end, GPU_Init now throws an access violation in the call to applyTargetCamera because GPU_GetContextTarget returns null.

As near as I can tell, this is returning null because earlier on, in the call to MakeCurrent, target->context->context is null and so the required initialization never takes place. I haven't been able to determine yet what's missing that's causing target->context->context to be null at this point.

~/sdl-gpu/tests/render-target/main.c:

#include "SDL.h"
#include "SDL_gpu.h"
#include <math.h>
#include "compat.h"
#include "common.h"
#include "demo-font.h"


int main(int argc, char* argv[])
{
	GPU_Target* screen;

	screen = initialize_demo(argc, argv, 800, 600);
	if(screen == NULL)
		return 1;

	{
		GPU_Image* image2;
		GPU_Image* image3;
		SDL_Surface* font_surface;
		DemoFont* font;
		GPU_Image* mode1image;
		GPU_Image* mode2image;
		SDL_Color circleColor = { 255, 0, 0, 128 };
		SDL_Color circleColor2 = { 0, 0, 255, 128 };
		Uint32 startTime;
		long frameCount;
		const Uint8* keystates;
		int mode;
		int x;
		int y;
		Uint8 done;
		SDL_Event event;

		image2 = GPU_LoadImage("data/test2.bmp");
		if (image2 == NULL)
			return 2;

		image3 = GPU_LoadImage("data/test.bmp");
		if (image3 == NULL)
			return 3;

		font_surface = GPU_LoadSurface("data/comic14.png");
		font = FONT_Alloc(font_surface);
		if(font == NULL)
        {
            GPU_LogError("Failed to load font.\n");
            return 4;
        }
		GPU_SetRGB(font->image, 255, 0, 0);
		SDL_FreeSurface(font_surface);

		mode1image = GPU_CreateImage(300, 300, GPU_FORMAT_RGBA);
		if (mode1image == NULL)
			return 5;

		mode2image = GPU_CreateImage(400, 400, GPU_FORMAT_RGBA);
		if (mode2image == NULL)
			return 6;

		GPU_LoadTarget(mode1image);
		GPU_LoadTarget(mode2image);

        int height = 400;
		GPU_Image* light = GPU_CreateImage(height, height, GPU_FORMAT_RGBA);
        GPU_SetBlending(light, true);
		GPU_LoadTarget(light);
        GPU_ClearRGBA(light->target, 0, 0, 0, 128);

        float centerX = height / 2.0f;
        float centerY = height / 2.0f;
        float radius = height/ 2.0f;
        SDL_Color color = {255,255,0, 128};
        GPU_CircleFilled(light->target, centerX, centerY, radius, color);

		startTime = SDL_GetTicks();
		frameCount = 0;

		keystates = SDL_GetKeyState(NULL);

		mode = 0;
		x = 0;
		y = 0;

		done = 0;
		while (!done)
		{
			while (SDL_PollEvent(&event))
			{
				if (event.type == SDL_QUIT)
					done = 1;
				else if (event.type == SDL_KEYDOWN)
				{
					if (event.key.keysym.sym == SDLK_ESCAPE)
						done = 1;
					else if (event.key.keysym.sym == SDLK_SPACE)
					{
						mode++;
						if (mode > 1)
							mode = 0;
					}
					else if (event.key.keysym.sym == SDLK_f)
						GPU_SetFullscreen(!GPU_GetFullscreen(), 0);
					else if (event.key.keysym.sym == SDLK_g)
						GPU_SetFullscreen(!GPU_GetFullscreen(), 1);
					else if (event.key.keysym.sym == SDLK_1)
						GPU_UnsetVirtualResolution(screen);
					else if (event.key.keysym.sym == SDLK_2)
						GPU_SetVirtualResolution(screen, 1200, 800);
				}
			}

			if (keystates[KEY_UP])
				y -= 1;
			else if (keystates[KEY_DOWN])
				y += 1;
			if (keystates[KEY_LEFT])
				x -= 1;
			else if (keystates[KEY_RIGHT])
				x += 1;

			GPU_Clear(screen);

			if (mode == 0)
			{
				GPU_Target* mode1target = mode1image->target;
				SDL_Color red = { 255, 0, 0, 255 };

				GPU_ClearRGBA(mode1target, 0, 255, 0, 255);
				GPU_Blit(image3, NULL, mode1target, image3->w / 2, image3->h / 2);


				//GPU_BlitScale(image2, NULL, mode1target, mode1target->w/2, mode1target->h/2, 0.7f, 0.7f);
				//GPU_BlitScale(image2, NULL, mode1target, x, y, 0.7f, 0.7f);

				GPU_BlitTransform(image2, NULL, mode1target, x, y, 360 * sin(SDL_GetTicks() / 1000.0f), 0.7f*sin(SDL_GetTicks() / 2000.0f), 0.7f*sin(SDL_GetTicks() / 2000.0f));

				//GPU_Line(mode1target, 0, 0, mode1target->w, mode1target->h, red);
				//GPU_CircleFilled(mode1target, 70, 70, 20, circleColor);

                GPU_Rect srcRect = GPU_MakeRect(0, 0, light->w, light->h);
                GPU_Rect destRect = GPU_MakeRect(0, 0, light->w, light->h);
                GPU_BlitRect(light, &srcRect, mode1target, &destRect);

				GPU_Blit(mode1image, NULL, screen, mode1image->w / 2 + 50, mode1image->h / 2 + 50);
				GPU_BlitScale(mode1image, NULL, screen, mode1image->w * 2 + 50, mode1image->h / 2 + 50, 0.7f, 0.7f);

				GPU_CircleFilled(screen, 50 + 70, 50 + 70, 20, circleColor2);

				GPU_Blit(image2, NULL, screen, screen->w - image3->w - image2->w / 2, screen->h - image2->h / 2);
				GPU_Blit(image3, NULL, screen, screen->w - image3->w / 2, screen->h - image3->h / 2);
			}
			else if (mode == 1)
			{
				GPU_Target* mode2target = mode2image->target;
				SDL_Color red = { 255, 0, 0, 255 };
				SDL_Color blue = { 0, 0, 255, 255 };

				GPU_ClearRGBA(mode2target, 255, 255, 255, 255);


				GPU_Line(mode2target, 0, 0, mode2target->w, mode2target->h, red);
				GPU_Line(mode2target, 0, mode2target->h, mode2target->w, 0, red);
				GPU_TriFilled(mode2target, mode2target->w / 2, mode2target->h / 2 + 10, mode2target->w / 2 - 10, mode2target->h / 2 + 20, mode2target->w / 2 + 10, mode2target->h / 2 + 20, red);

				GPU_Blit(image2, NULL, mode2target, x, y);



				GPU_Line(screen, 0, 0, screen->w, screen->h, blue);
				GPU_Line(screen, 0, screen->h, screen->w, 0, blue);

				GPU_Blit(mode2image, NULL, screen, mode2image->w / 2, mode2image->h / 2);
			}

			FONT_Draw(font, screen, 20, 20, "Testing");

			GPU_Flip(screen);

			frameCount++;
			if (frameCount % 500 == 0)
			{
				printf("Average FPS: %.2f\n", 1000.0f*frameCount / (SDL_GetTicks() - startTime));
				printf("x,y: (%d, %d)\n", x, y);
			}
		}

		printf("Average FPS: %.2f\n", 1000.0f*frameCount / (SDL_GetTicks() - startTime));

		FONT_Free(font);
		GPU_FreeImage(mode2image);
		GPU_FreeImage(mode1image);
	}

	GPU_Quit();

	return 0;
}

Since SDL_gpu does my image loading, I was wondering if a convenient GetHandle function could be added to get a texture handle without me depending on an IMAGE_DATA structure cast.

Hi, when I was trying your demosI saw an increase in RAM usage per frame and I realized that the problem was caused by GPU_Flip().

I am using the latest version (0.12) and the SDL version is 2.24.2.

Should resolve issues addressed in https://github.com/grimfang4/sdl-gpu/issues/220

• GPU_Pixel now renders on the center of the pixel
• GPU_Line renders from the center of pixels
• GPU_Rectangle borders are now rendered inside the rectangle instead of being centered on the bounds

If any of these behavioral changes are unwanted, maybe we can introduce a way to allow the users to decide on the behavior. E.g. enums/booleans, new functions, etc.

Here's an illustration of the changes made to GPU_Rectangle:

• The outer black rectangle represents the outer edges of the pixels
• The inner red rectangle represents the inner edges of the pixels
• The numbers are the indices of the vertexes of the triangles used to draw the rectangle sides

Hello, Im trying to use SDL2_gpu to draw a few primitive shapes but I'm running into some issues. Mainly that I just get a blank screen with the draw color and none of the shapes. I turned on debugging with GPU_SetDebugLevel(GPU_DEBUG_LEVEL_MAX); and I get:

GPU_CreateTargetFromWindow: BACKEND ERROR - Failed to create GL context.
GPU_InitRendererByID: BACKEND ERROR - Renderer OpenGL 4 failed to initialize properly

I think this has something todo with me needing to add:

find_package(OpenGL REQUIRED)
include_directories( ${OPENGL_INCLUDE_DIRS}  ${GLUT_INCLUDE_DIRS} )
target_link_libraries(flame_engine ${OPENGL_LIBRARIES} ${GLUT_LIBRARY} )

to my cmake file to avoid getting a bunch of symbol errors about OpenGL not being found. Does anybody know what might be causing this? Full CMake:

cmake_minimum_required(VERSION 3.22)
project(flame_engine)

set(CMAKE_CXX_STANDARD 14)

link_directories(/opt/homebrew/Cellar/sdl2/2.0.22/lib/)

add_executable(flame_engine main.cpp)

find_package(OpenGL REQUIRED)
include_directories( ${OPENGL_INCLUDE_DIRS}  ${GLUT_INCLUDE_DIRS} )
target_link_libraries(flame_engine ${OPENGL_LIBRARIES} ${GLUT_LIBRARY} )

target_link_libraries(flame_engine SDL2)
target_link_libraries(flame_engine SDL2_gpu)

target_include_directories(flame_engine
        PRIVATE
        /opt/homebrew/Cellar/sdl2/2.0.22/include/)

System: macOS Monterey MacBook Pro 14 inch (M1 Max) With 32GB of memory

I'm not sure how much work it would be to add this feature but it's something I had on my mind.

The way PrimitiveBatch currently works is by taking a single pointer to an interleaved buffer.

I would like if PrimitiveBatch also had a way to take multiple pointers to distinct subbuffers of packed data instead (implemented with glBufferSubData).

If this is the current PrimitiveBatch API

DECLSPEC void SDLCALL
GPU_PrimitiveBatch(
    GPU_Image* image,
    GPU_Target* target,
    GPU_PrimitiveEnum primitive_type,
    unsigned int num_vertices,
    float* values,
    unsigned int num_indices,
    unsigned int* indices,
    GPU_BatchFlagEnum flags);

This is what I imagine this new API could look like

typedef struct GPU_SubBuffers {
       float *x_values;
       float *y_values;
       float *z_values;
       float *s_values;
       float *t_values;
       float *r_values;
       float *g_values;
       float *b_values;
       float *a_values;
       uint8_t *r8_values;
       uint8_t *g8_values;
       uint8_t *b8_values;
       uint8_t *a8_values;
} GPU_SubBuffers;

DECLSPEC void SDLCALL
GPU_PrimitiveBatchSub(
    GPU_Image* image,
    GPU_Target* target,
    GPU_PrimitiveEnum primitive_type,
    unsigned int num_vertices,
    const GPU_SubBuffers *values,
    unsigned int num_indices,
    unsigned int* indices,
    GPU_BatchFlagEnum flags);

I'm running into an issue where one window stops showing blitted images after closing another one. What's strange is that this only happens when the first opened window is closed that the second's images disappear, and not the other way around.

To close windows, I'm calling SDL_DestroyWindow and GPU_FreeTarget on the target. And I've made sure to call GPU_MakeCurrent on the correct window before loading each GPU_Image. The loaded matrix appears to be unaffected at this point. Images are rendered with GPU_BlitRectX, and it appears that the parameters I'm passing are unchanged.

(Also the secondary window is opened using SDL_CreateWindow and GPU_CreateTargetFromWindow, although I've tried opening both this way after creating a dummy window with GPU_InitRenderer, but the problem persists.)

I'm out of ideas. Would anyone have any clue what might be causing this? Thank you.