static void Quit(GPU_Renderer* renderer) { GPU_Log(" %s (dummy)\n", __func__); renderer->impl->FreeTarget(renderer, renderer->current_context_target); renderer->current_context_target = NULL; }
static void ActivateShaderProgram(GPU_Renderer* renderer, Uint32 program_object, GPU_ShaderBlock* block) { GPU_Target* target = renderer->current_context_target; GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return; if((renderer->enabled_features & GPU_FEATURE_BASIC_SHADERS) == GPU_FEATURE_BASIC_SHADERS) { if(program_object == 0) // Implies default shader { // Already using a default shader? if(target->context->current_shader_program == target->context->default_textured_shader_program || target->context->current_shader_program == target->context->default_untextured_shader_program) return; program_object = target->context->default_untextured_shader_program; } renderer->impl->FlushBlitBuffer(renderer); } target->context->current_shader_program = program_object; }
static void SetWrapMode(GPU_Renderer* renderer, GPU_Image* image, GPU_WrapEnum wrap_mode_x, GPU_WrapEnum wrap_mode_y) { GPU_Log(" %s (dummy)\n", __func__); image->wrap_mode_x = wrap_mode_x; image->wrap_mode_y = wrap_mode_y; }
static Uint8 SetWindowResolution(GPU_Renderer* renderer, Uint16 w, Uint16 h) { GPU_Target* target = renderer->current_context_target; GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return 0; // Don't need to resize (only update internals) when resolution isn't changing. SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h); if(target->context->window_w != w || target->context->window_h != h) { SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), w, h); SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h); } // Store the resolution for fullscreen_desktop changes target->context->stored_window_w = target->context->window_w; target->context->stored_window_h = target->context->window_h; // Update base dimensions target->base_w = target->context->window_w; target->base_h = target->context->window_h; // Resets virtual resolution target->w = target->base_w; target->h = target->base_h; target->using_virtual_resolution = 0; return 1; }
static void MakeCurrent(GPU_Renderer* renderer, GPU_Target* target, Uint32 windowID) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL || target->context == NULL) return; renderer->current_context_target = target; // Reset if the target's window was changed if(target->context->windowID != windowID) { // Update the window mappings GPU_RemoveWindowMapping(windowID); // Don't remove the target's current mapping. That lets other windows refer to it. target->context->windowID = windowID; GPU_AddWindowMapping(target); // Update target's window size SDL_GetWindowSize(SDL_GetWindowFromID(windowID), &target->context->window_w, &target->context->window_h); target->base_w = target->context->window_w; target->base_h = target->context->window_h; // Reset the camera here for this window } }
static GPU_Image* CopyImageFromSurface(GPU_Renderer* renderer, SDL_Surface* surface) { GPU_Log(" %s (dummy)\n", __func__); if(surface == NULL) return NULL; return renderer->impl->CreateImage(renderer, surface->w, surface->h, GPU_FORMAT_RGBA); }
static SDL_Surface* CopySurfaceFromTarget(GPU_Renderer* renderer, GPU_Target* target) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return NULL; return SDL_CreateRGBSurface(SDL_SWSURFACE, target->base_w, target->base_h, 32, 0, 0, 0, 0); }
static SDL_Surface* CopySurfaceFromImage(GPU_Renderer* renderer, GPU_Image* image) { GPU_Log(" %s (dummy)\n", __func__); if(image == NULL) return NULL; return SDL_CreateRGBSurface(SDL_SWSURFACE, image->texture_w, image->texture_h, 32, 0, 0, 0, 0); }
static void SetAsCurrent(GPU_Renderer* renderer) { GPU_Log(" %s (dummy)\n", __func__); if(renderer->current_context_target == NULL) return; renderer->impl->MakeCurrent(renderer, renderer->current_context_target, renderer->current_context_target->context->windowID); }
static GPU_Image* CopyImage(GPU_Renderer* renderer, GPU_Image* image) { GPU_Log(" %s (dummy)\n", __func__); if(image == NULL) return NULL; return renderer->impl->CreateImage(renderer, image->w, image->h, image->format); }
static GPU_Image* CopyImageFromTarget(GPU_Renderer* renderer, GPU_Target* target) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return NULL; return renderer->impl->CreateImage(renderer, target->w, target->h, GPU_FORMAT_RGBA); }
int main(int argc, char* argv[]) { GPU_Target* screen; // Prepare renderer for SDL_gpu to use GPU_RendererID rendererID = GPU_MakeRendererID("Dummy", GPU_ReserveNextRendererEnum(), 1, 0); GPU_RegisterRenderer(rendererID, &create_dummy_renderer, &free_dummy_renderer); printRenderers(); // Request this specific renderer screen = GPU_InitRenderer(rendererID.renderer, 800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) return -1; printCurrentRenderer(); { Uint8 done; SDL_Event event; GPU_Image* image = GPU_LoadImage("data/test.bmp"); if(image == NULL) GPU_Log("Failed to load image.\n"); 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; } } GPU_Clear(screen); GPU_Blit(image, NULL, screen, screen->w/2, screen->h/2); GPU_Flip(screen); // Long delay to keep the logging from piling up too much SDL_Delay(500); } GPU_FreeImage(image); } GPU_Quit(); return 0; }
static void SetVirtualResolution(GPU_Renderer* renderer, GPU_Target* target, Uint16 w, Uint16 h) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return; target->w = w; target->h = h; target->using_virtual_resolution = 1; }
static Uint8 SetFullscreen(GPU_Renderer* renderer, Uint8 enable_fullscreen, Uint8 use_desktop_resolution) { GPU_Target* target = renderer->current_context_target; // These values should actually come from the window Uint8 was_fullscreen = !enable_fullscreen; Uint8 is_fullscreen = enable_fullscreen; GPU_Log(" %s (dummy)\n", __func__); //if(SetWindowFullscreen(target->context->windowID, enable_fullscreen) >= 0) { // If we just went fullscreen, save the original resolution // We do this because you can't depend on the resolution to be preserved by SDL // SDL_WINDOW_FULLSCREEN_DESKTOP changes the resolution and SDL_WINDOW_FULLSCREEN can change it when a given mode is not available if(!was_fullscreen && is_fullscreen) { target->context->stored_window_w = target->context->window_w; target->context->stored_window_h = target->context->window_h; } // If we're in windowed mode now and a resolution was stored, restore the original window resolution if(was_fullscreen && !is_fullscreen && (target->context->stored_window_w != 0 && target->context->stored_window_h != 0)) SDL_SetWindowSize(SDL_GetWindowFromID(target->context->windowID), target->context->stored_window_w, target->context->stored_window_h); // Update window dims SDL_GetWindowSize(SDL_GetWindowFromID(target->context->windowID), &target->context->window_w, &target->context->window_h); } if(is_fullscreen != was_fullscreen) { // If virtual res is not set, we need to update the target dims and reset stuff that no longer is right if(!target->using_virtual_resolution) { // Update dims target->w = target->context->window_w; target->h = target->context->window_h; } // Reset viewport target->viewport = GPU_MakeRect(0, 0, target->context->window_w, target->context->window_h); // Update viewport here // Reset clip GPU_UnsetClip(target); // Update camera here } target->base_w = target->context->window_w; target->base_h = target->context->window_h; return is_fullscreen; }
static void UnsetVirtualResolution(GPU_Renderer* renderer, GPU_Target* target) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return; target->w = target->base_w; target->h = target->base_h; target->using_virtual_resolution = 0; }
static GPU_ShaderBlock LoadShaderBlock(GPU_Renderer* renderer, Uint32 program_object, const char* position_name, const char* texcoord_name, const char* color_name, const char* modelViewMatrix_name) { GPU_ShaderBlock b; GPU_Log(" %s (dummy)\n", __func__); b.position_loc = -1; b.texcoord_loc = -1; b.color_loc = -1; b.modelViewProjection_loc = -1; return b; }
static Uint8 SaveImage(GPU_Renderer* renderer, GPU_Image* image, const char* filename, GPU_FileFormatEnum format) { SDL_Surface* surface; GPU_Log(" %s (dummy)\n", __func__); surface = GPU_CopySurfaceFromImage(image); GPU_SaveSurface(surface, filename, format); SDL_FreeSurface(surface); return 1; }
static GPU_Target* Init(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags) { SDL_Window* window; GPU_Log(" %s (dummy)\n", __func__); renderer->requested_id = renderer_request; renderer->GPU_init_flags = GPU_GetPreInitFlags(); renderer->SDL_init_flags = SDL_flags; window = NULL; // Is there a window already set up that we are supposed to use? if(renderer->current_context_target != NULL) window = SDL_GetWindowFromID(renderer->current_context_target->context->windowID); else window = SDL_GetWindowFromID(GPU_GetInitWindow()); if(window == NULL) { // Set up window flags if(!(renderer->SDL_init_flags & SDL_WINDOW_HIDDEN)) renderer->SDL_init_flags |= SDL_WINDOW_SHOWN; window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, renderer->SDL_init_flags); if(window == NULL) { GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Window creation failed."); return NULL; } GPU_SetInitWindow(SDL_GetWindowID(window)); } else renderer->SDL_init_flags = SDL_flags; renderer->enabled_features = 0xFFFFFFFF; // Pretend to support them all renderer->current_context_target = renderer->impl->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target); if(renderer->current_context_target == NULL) return NULL; // If the dimensions of the window don't match what we asked for, then set up a virtual resolution to pretend like they are. if(!(renderer->GPU_init_flags & GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION) && w != 0 && h != 0 && (w != renderer->current_context_target->w || h != renderer->current_context_target->h)) renderer->impl->SetVirtualResolution(renderer, renderer->current_context_target, w, h); return renderer->current_context_target; }
static void FreeTarget(GPU_Renderer* renderer, GPU_Target* target) { GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return; if(target->refcount > 1) { target->refcount--; return; } if(target->context != NULL && target->context->failed) { if(target == renderer->current_context_target) renderer->current_context_target = NULL; // Remove all of the window mappings that refer to this target GPU_RemoveWindowMappingByTarget(target); free(target->context); free(target); return; } if(target == renderer->current_context_target) { renderer->impl->FlushBlitBuffer(renderer); renderer->current_context_target = NULL; } if(!target->is_alias && target->image != NULL) target->image->target = NULL; // Remove reference to this object if(target->context != NULL) { // Remove all of the window mappings that refer to this target GPU_RemoveWindowMappingByTarget(target); free(target->context); target->context = NULL; } free(target); }
static GPU_Target* LoadTarget(GPU_Renderer* renderer, GPU_Image* image) { GPU_Target* result; GPU_Log(" %s (dummy)\n", __func__); if(image == NULL) return NULL; if(image->target != NULL) { image->target->refcount++; return image->target; } if(!(renderer->enabled_features & GPU_FEATURE_RENDER_TARGETS)) return NULL; result = (GPU_Target*)malloc(sizeof(GPU_Target)); memset(result, 0, sizeof(GPU_Target)); result->refcount = 1; result->data = NULL; // Allocate a data structure as needed for other render target data result->renderer = renderer; result->context = NULL; result->image = image; result->w = image->w; result->h = image->h; result->base_w = image->texture_w; result->base_h = image->texture_h; result->viewport = GPU_MakeRect(0, 0, result->w, result->h); result->camera = GPU_GetDefaultCamera(); result->use_clip_rect = 0; result->clip_rect.x = 0; result->clip_rect.y = 0; result->clip_rect.w = result->w; result->clip_rect.h = result->h; result->use_color = 0; image->target = result; return result; }
static GPU_Image* CreateAliasImage(GPU_Renderer* renderer, GPU_Image* image) { GPU_Image* result; GPU_Log(" %s (dummy)\n", __func__); if(image == NULL) return NULL; result = (GPU_Image*)malloc(sizeof(GPU_Image)); // Copy the members *result = *image; // Alias info result->refcount = 1; result->is_alias = 1; return result; }
static GPU_Target* CreateAliasTarget(GPU_Renderer* renderer, GPU_Target* target) { GPU_Target* result; GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) return NULL; result = (GPU_Target*)malloc(sizeof(GPU_Target)); // Copy the members *result = *target; // Alias info if(target->image != NULL) target->image->refcount++; result->refcount = 1; result->is_alias = 1; return result; }
static void FreeImage(GPU_Renderer* renderer, GPU_Image* image) { GPU_Log(" %s (dummy)\n", __func__); if(image == NULL) return; if(image->refcount > 1) { image->refcount--; return; } // Delete the attached target first if(image->target != NULL) { GPU_Target* target = image->target; image->target = NULL; renderer->impl->FreeTarget(renderer, target); } free(image); }
static GPU_Camera SetCamera(GPU_Renderer* renderer, GPU_Target* target, GPU_Camera* cam) { GPU_Camera new_camera; GPU_Camera old_camera; GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) { GPU_PushErrorCode("GPU_SetCamera", GPU_ERROR_NULL_ARGUMENT, "target"); return GPU_GetDefaultCamera(); } if(cam == NULL) new_camera = GPU_GetDefaultCamera(); else new_camera = *cam; old_camera = target->camera; target->camera = new_camera; return old_camera; }
static GPU_Rect SetClip(GPU_Renderer* renderer, GPU_Target* target, Sint16 x, Sint16 y, Uint16 w, Uint16 h) { GPU_Rect r; GPU_Log(" %s (dummy)\n", __func__); if(target == NULL) { GPU_Rect r = {0,0,0,0}; return r; } target->use_clip_rect = 1; r = target->clip_rect; target->clip_rect.x = x; target->clip_rect.y = y; target->clip_rect.w = w; target->clip_rect.h = h; return r; }
bool WavingGrass::Init() { glfwSetErrorCallback(glfwErrorCallback_GPU); glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); mpWindow = glfwCreateWindow(DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT, "WavingGrass for LearnCG", nullptr, nullptr); if ( !mpWindow ) { GPU_Log("WavingGrass::Init failed!%d", 1); glfwTerminate(); return false; } glfwMakeContextCurrent(mpWindow); glfwSetFramebufferSizeCallback(mpWindow, OnFramebufferSize); if ( !LoadGrassShader() ) return false; if ( !mGrassTex.Load(g_AssetsPath+"Assets/Grass/grass_PNG4922.png")) return false; int width, height; glfwGetFramebufferSize(mpWindow, &width, &height); glViewport(0, 0, width, height); gCamera.LookAt(glm::vec3(0, 50, 120), glm::vec3(0, 0, 0), glm::vec3(0, 1, 0)); gPipeline.SetPerspective(90, (GLfloat)width/height, 1, 500); return true; }
static void SetUniformf(GPU_Renderer* renderer, int location, float value) { GPU_Log(" %s (dummy)\n", __func__); }
static void SetUniformuiv(GPU_Renderer* renderer, int location, int num_elements_per_value, int num_values, unsigned int* values) { GPU_Log(" %s (dummy)\n", __func__); }
static void GetUniformfv(GPU_Renderer* renderer, Uint32 program_object, int location, float* values) { GPU_Log(" %s (dummy)\n", __func__); }
static void SetUniformui(GPU_Renderer* renderer, int location, unsigned int value) { GPU_Log(" %s (dummy)\n", __func__); }