自学教程：C++ GPU_Log函数代码示例

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__);}