GPU_ShaderBlock load_shaders(Uint32* v, Uint32* f, Uint32* p) { *v = load_shader(GPU_VERTEX_SHADER, "data/shaders/time_mod.vert"); if(!*v) GPU_LogError("Failed to load vertex shader: %s\n", GPU_GetShaderMessage()); *f = load_shader(GPU_FRAGMENT_SHADER, "data/shaders/time_mod.frag"); if(!*f) GPU_LogError("Failed to load fragment shader: %s\n", GPU_GetShaderMessage()); *p = GPU_LinkShaders(*v, *f); if(!*p) { GPU_ShaderBlock b = {-1, -1, -1, -1}; GPU_LogError("Failed to link shader program: %s\n", GPU_GetShaderMessage()); return b; } { GPU_ShaderBlock block = GPU_LoadShaderBlock(*p, "gpu_Vertex", "gpu_TexCoord", "gpu_Color", "gpu_ModelViewProjectionMatrix"); GPU_ActivateShaderProgram(*p, &block); return block; } }
int main(int argc, char* argv[]) { GPU_Target* screen; printRenderers(); GPU_SetPreInitFlags(GPU_INIT_DISABLE_VSYNC); screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) return -1; printCurrentRenderer(); { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; float dt = 0.010f; int maxSprites = 50000; int numSprites = 101; float* x = (float*)malloc(sizeof(float)*maxSprites); float* y = (float*)malloc(sizeof(float)*maxSprites); float* velx = (float*)malloc(sizeof(float)*maxSprites); float* vely = (float*)malloc(sizeof(float)*maxSprites); int i; GPU_Image* image = GPU_LoadImage("data/small_test.png"); if(image == NULL) return -1; GPU_SetSnapMode(image, GPU_SNAP_NONE); startTime = SDL_GetTicks(); frameCount = 0; for(i = 0; i < maxSprites; i++) { x[i] = rand()%screen->w; y[i] = rand()%screen->h; velx[i] = 10 + rand()%screen->w/10; vely[i] = 10 + rand()%screen->h/10; if(rand()%2) velx[i] = -velx[i]; if(rand()%2) vely[i] = -vely[i]; } 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_EQUALS || event.key.keysym.sym == SDLK_PLUS) { if(numSprites < maxSprites) numSprites += 100; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(numSprites > 1) numSprites -= 100; if(numSprites < 1) numSprites = 1; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } } } for(i = 0; i < numSprites; i++) { x[i] += velx[i]*dt; y[i] += vely[i]*dt; if(x[i] < 0) { x[i] = 0; velx[i] = -velx[i]; } else if(x[i]> screen->w) { x[i] = screen->w; velx[i] = -velx[i]; } if(y[i] < 0) { y[i] = 0; vely[i] = -vely[i]; } else if(y[i]> screen->h) { y[i] = screen->h; vely[i] = -vely[i]; } } GPU_Clear(screen); for(i = 0; i < numSprites; i++) { GPU_Blit(image, NULL, screen, x[i], y[i]); } GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(x); free(y); free(velx); free(vely); GPU_FreeImage(image); } GPU_Quit(); return 0; }
// This demo doesn't work for SDL 1.2 because of the assumed windowing features here. int main(int argc, char* argv[]) { GPU_LogError("Sorry, this demo requires SDL 2.\n"); return 0; }
int main(int argc, char* argv[]) { GPU_Target* screen; printRenderers(); screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) { GPU_LogError("Failed to init SDL_gpu.\n"); return -1; } printCurrentRenderer(); { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; GPU_Image* image; GPU_Image* image1; GPU_LogError("Loading image\n"); image = GPU_LoadImage(IMAGE_FILE); if(image == NULL) { GPU_LogError("Failed to load image.\n"); return -1; } GPU_LogError("Saving image\n"); GPU_SaveImage(image, SAVE_FILE, GPU_FILE_AUTO); GPU_LogError("Reloading image\n"); image1 = GPU_LoadImage(SAVE_FILE); if(image1 == NULL) { GPU_LogError("Failed to reload image.\n"); return -1; } startTime = SDL_GetTicks(); frameCount = 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; } } GPU_Clear(screen); GPU_Blit(image, NULL, screen, screen->w/4, screen->h/2); GPU_Blit(image1, NULL, screen, 3*screen->w/4, screen->h/2); GPU_Flip(screen); frameCount++; if(frameCount%500 == 0) printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); GPU_FreeImage(image); GPU_FreeImage(image1); } GPU_Quit(); return 0; }
int main(int argc, char* argv[]) { GPU_Target* screen; printRenderers(); screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) return -1; printCurrentRenderer(); { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; int shapeType; int numShapeTypes; int i; #define NUM_COLORS 20 SDL_Color colors[NUM_COLORS]; #define NUM_PIXELS NUM_COLORS int px[NUM_PIXELS]; int py[NUM_PIXELS]; #define NUM_LINES NUM_COLORS int lx1[NUM_LINES]; int ly1[NUM_LINES]; int lx2[NUM_LINES]; int ly2[NUM_LINES]; #define NUM_TRIS NUM_COLORS int tx1[NUM_TRIS]; int ty1[NUM_TRIS]; int tx2[NUM_TRIS]; int ty2[NUM_TRIS]; int tx3[NUM_TRIS]; int ty3[NUM_TRIS]; #define NUM_RECTS NUM_COLORS int rx1[NUM_RECTS]; int ry1[NUM_RECTS]; int rx2[NUM_RECTS]; int ry2[NUM_RECTS]; float rr[NUM_RECTS]; #define NUM_ARCS NUM_COLORS int ax[NUM_ARCS]; int ay[NUM_ARCS]; float ar[NUM_ARCS]; float ar2[NUM_ARCS]; float aa1[NUM_ARCS]; float aa2[NUM_ARCS]; #define NUM_POLYS NUM_COLORS int pn[NUM_POLYS]; float* pv[NUM_POLYS]; Uint8 blend; float thickness; startTime = SDL_GetTicks(); frameCount = 0; shapeType = 0; numShapeTypes = 18; for(i = 0; i < NUM_COLORS; i++) { colors[i].r = rand()%256; colors[i].g = rand()%256; colors[i].b = rand()%256; GET_ALPHA(colors[i]) = rand()%256; } for(i = 0; i < NUM_PIXELS; i++) { px[i] = rand()%screen->w; py[i] = rand()%screen->h; } for(i = 0; i < NUM_LINES; i++) { lx1[i] = rand()%screen->w; ly1[i] = rand()%screen->h; lx2[i] = rand()%screen->w; ly2[i] = rand()%screen->h; } for(i = 0; i < NUM_TRIS; i++) { tx1[i] = rand()%screen->w; ty1[i] = rand()%screen->h; tx2[i] = rand()%screen->w; ty2[i] = rand()%screen->h; tx3[i] = rand()%screen->w; ty3[i] = rand()%screen->h; } for(i = 0; i < NUM_RECTS; i++) { rx1[i] = rand()%screen->w; ry1[i] = rand()%screen->h; rx2[i] = rand()%screen->w; ry2[i] = rand()%screen->h; rr[i] = rand()%10 + 2; } for(i = 0; i < NUM_ARCS; i++) { ax[i] = rand()%screen->w; ay[i] = rand()%screen->h; ar[i] = (rand()%screen->h)/10.0f; ar2[i] = ((rand()%101)/100.0f)*ar[i]; aa1[i] = rand()%360; aa2[i] = rand()%360; } for(i = 0; i < NUM_POLYS; i++) { float cx = rand()%screen->w; float cy = rand()%screen->h; float radius = 20 + rand()%(screen->w/8); int j; pn[i] = rand()%8 + 3; pv[i] = (float*)malloc(2*pn[i]*sizeof(float)); for(j = 0; j < pn[i]*2; j+=2) { pv[i][j] = cx + radius*cos(2*M_PI*(((float)j)/(pn[i]*2))) + rand()%((int)radius/2); pv[i][j+1] = cy + radius*sin(2*M_PI*(((float)j)/(pn[i]*2))) + rand()%((int)radius/2); } } blend = 0; thickness = 1.0f; GPU_SetShapeBlending(blend); 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) { shapeType++; if(shapeType >= numShapeTypes) shapeType = 0; } else if(event.key.keysym.sym == SDLK_BACKSPACE) { shapeType--; if(shapeType < 0) shapeType = numShapeTypes-1; } else if(event.key.keysym.sym == SDLK_b) { blend = !blend; GPU_SetShapeBlending(blend); } else if(event.key.keysym.sym == SDLK_UP || event.key.keysym.sym == SDLK_EQUALS) { thickness += 0.25f; GPU_LogError("thickness: %.2f\n", thickness); GPU_SetLineThickness(thickness); } else if(event.key.keysym.sym == SDLK_DOWN || event.key.keysym.sym == SDLK_MINUS) { if(thickness > 0.25f) thickness -= 0.25f; GPU_LogError("thickness: %.2f\n", thickness); GPU_SetLineThickness(thickness); } } else if(event.type == SDL_MOUSEBUTTONDOWN) { if(event.button.button == SDL_BUTTON_LEFT) { shapeType++; if(shapeType >= numShapeTypes) shapeType = 0; } else if(event.button.button == SDL_BUTTON_RIGHT) { shapeType--; if(shapeType < 0) shapeType = numShapeTypes-1; } } } GPU_Clear(screen); switch(shapeType) { case 0: for(i = 0; i < NUM_PIXELS; i++) { GPU_Pixel(screen, px[i], py[i], colors[i]); } break; case 1: for(i = 0; i < NUM_LINES; i++) { GPU_Line(screen, lx1[i], ly1[i], lx2[i], ly2[i], colors[i]); } break; case 2: for(i = 0; i < NUM_TRIS; i++) { GPU_Tri(screen, tx1[i], ty1[i], tx2[i], ty2[i], tx3[i], ty3[i], colors[i]); } break; case 3: for(i = 0; i < NUM_TRIS; i++) { GPU_TriFilled(screen, tx1[i], ty1[i], tx2[i], ty2[i], tx3[i], ty3[i], colors[i]); } break; case 4: for(i = 0; i < NUM_RECTS; i++) { GPU_Rectangle(screen, rx1[i], ry1[i], rx2[i], ry2[i], colors[i]); } break; case 5: for(i = 0; i < NUM_RECTS; i++) { GPU_RectangleFilled(screen, rx1[i], ry1[i], rx2[i], ry2[i], colors[i]); } break; case 6: for(i = 0; i < NUM_RECTS; i++) { GPU_RectangleRound(screen, rx1[i], ry1[i], rx2[i], ry2[i], rr[i], colors[i]); } break; case 7: for(i = 0; i < NUM_RECTS; i++) { GPU_RectangleRoundFilled(screen, rx1[i], ry1[i], rx2[i], ry2[i], rr[i], colors[i]); } break; case 8: for(i = 0; i < NUM_ARCS; i++) { GPU_Arc(screen, ax[i], ay[i], ar[i], aa1[i], aa2[i], colors[i]); } break; case 9: for(i = 0; i < NUM_ARCS; i++) { GPU_ArcFilled(screen, ax[i], ay[i], ar[i], aa1[i], aa2[i], colors[i]); } break; case 10: for(i = 0; i < NUM_ARCS; i++) { GPU_Circle(screen, ax[i], ay[i], ar[i], colors[i]); } break; case 11: for(i = 0; i < NUM_ARCS; i++) { GPU_CircleFilled(screen, ax[i], ay[i], ar[i], colors[i]); } break; case 12: for(i = 0; i < NUM_ARCS; i++) { GPU_Ellipse(screen, ax[i], ay[i], ar[i], ar2[i], aa1[i], colors[i]); } break; case 13: for(i = 0; i < NUM_ARCS; i++) { GPU_EllipseFilled(screen, ax[i], ay[i], ar[i], ar2[i], aa1[i], colors[i]); } break; case 14: for(i = 0; i < NUM_ARCS; i++) { GPU_Sector(screen, ax[i], ay[i], ar[i], ar2[i], aa1[i], aa2[i], colors[i]); } break; case 15: for(i = 0; i < NUM_ARCS; i++) { GPU_SectorFilled(screen, ax[i], ay[i], ar[i], ar2[i], aa1[i], aa2[i], colors[i]); } break; case 16: for(i = 0; i < NUM_POLYS; i++) { GPU_Polygon(screen, pn[i], pv[i], colors[i]); } break; case 17: for(i = 0; i < NUM_POLYS; i++) { GPU_PolygonFilled(screen, pn[i], pv[i], colors[i]); } break; } GPU_Flip(screen); frameCount++; if(frameCount%500 == 0) printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); for(i = 0; i < NUM_POLYS; i++) { free(pv[i]); } } GPU_Quit(); return 0; }
int do_interleaved(GPU_Target* screen) { GPU_LogError("do_interleaved()\n"); GPU_Image* image = GPU_LoadImage("data/small_test.png"); if(image == NULL) return -1; int return_value = 0; float dt = 0.010f; Uint32 startTime = SDL_GetTicks(); long frameCount = 0; int maxSprites = 50000; int numSprites = 101; int floats_per_sprite = 2 + 4 + 4; float* sprite_values = (float*)malloc(sizeof(float)*maxSprites*floats_per_sprite); float* velx = (float*)malloc(sizeof(float)*maxSprites); float* vely = (float*)malloc(sizeof(float)*maxSprites); int i; int val_n = 0; for(i = 0; i < maxSprites; i++) { sprite_values[val_n++] = rand()%screen->w; sprite_values[val_n++] = rand()%screen->h; sprite_values[val_n++] = 0; sprite_values[val_n++] = 0; sprite_values[val_n++] = image->w; sprite_values[val_n++] = image->h; sprite_values[val_n++] = rand()%256; sprite_values[val_n++] = rand()%256; sprite_values[val_n++] = rand()%256; sprite_values[val_n++] = rand()%256; velx[i] = 10 + rand()%screen->w/10; vely[i] = 10 + rand()%screen->h/10; if(rand()%2) velx[i] = -velx[i]; if(rand()%2) vely[i] = -vely[i]; } Uint8 done = 0; SDL_Event event; 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) { done = 1; return_value = 2; } else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { if(numSprites < maxSprites) numSprites += 100; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(numSprites > 1) numSprites -= 100; if(numSprites < 1) numSprites = 1; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } } } for(i = 0; i < numSprites; i++) { val_n = floats_per_sprite*i; sprite_values[val_n] += velx[i]*dt; sprite_values[val_n+1] += vely[i]*dt; if(sprite_values[val_n] < 0) { sprite_values[val_n] = 0; velx[i] = -velx[i]; } else if(sprite_values[val_n] > screen->w) { sprite_values[val_n] = screen->w; velx[i] = -velx[i]; } if(sprite_values[val_n+1] < 0) { sprite_values[val_n+1] = 0; vely[i] = -vely[i]; } else if(sprite_values[val_n+1] > screen->h) { sprite_values[val_n+1] = screen->h; vely[i] = -vely[i]; } } GPU_Clear(screen); GPU_BlitBatch(image, screen, numSprites, sprite_values, 0); GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(sprite_values); free(velx); free(vely); GPU_FreeImage(image); return return_value; }
int main(int argc, char* argv[]) { GPU_Target* screen; screen = initialize_demo(argc, argv, 800, 600); if(screen == NULL) return -1; GPU_LogError("Supports GPU_FEATURE_ALL_BASE: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_ALL_BASE))); GPU_LogError("Supports GPU_FEATURE_ALL_BLEND_PRESETS: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_ALL_BLEND_PRESETS))); GPU_LogError("Supports GPU_FEATURE_ALL_GL_FORMATS: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_ALL_GL_FORMATS))); GPU_LogError("Supports GPU_FEATURE_NON_POWER_OF_TWO: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_NON_POWER_OF_TWO))); GPU_LogError("Supports GPU_FEATURE_RENDER_TARGETS: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_RENDER_TARGETS))); GPU_LogError("Supports GPU_FEATURE_BLEND_EQUATIONS: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_BLEND_EQUATIONS))); GPU_LogError("Supports GPU_FEATURE_BLEND_FUNC_SEPARATE: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_BLEND_FUNC_SEPARATE))); GPU_LogError("Supports GPU_FEATURE_GL_BGR: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_GL_BGR))); GPU_LogError("Supports GPU_FEATURE_GL_BGRA: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_GL_BGRA))); GPU_LogError("Supports GPU_FEATURE_GL_ABGR: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_GL_ABGR))); GPU_LogError("Supports GPU_FEATURE_VERTEX_SHADER: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_VERTEX_SHADER))); GPU_LogError("Supports GPU_FEATURE_FRAGMENT_SHADER: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_FRAGMENT_SHADER))); GPU_LogError("Supports GPU_FEATURE_GEOMETRY_SHADER: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_GEOMETRY_SHADER))); GPU_LogError("Supports GPU_FEATURE_WRAP_REPEAT_MIRRORED: %s\n", bool_string(GPU_IsFeatureEnabled(GPU_FEATURE_WRAP_REPEAT_MIRRORED))); GPU_Quit(); return 0; }
int main(int argc, char* argv[]) { GPU_Target* screen; GPU_SetDebugLevel(GPU_DEBUG_LEVEL_MAX); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); GPU_SetRequiredFeatures(GPU_FEATURE_BASIC_SHADERS); screen = GPU_InitRenderer(GPU_RENDERER_OPENGL_3, 800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) { GPU_LogError("Initialization Error: Could not create a renderer with proper feature support for this demo.\n"); return 1; } glewExperimental = GL_TRUE; // Force GLEW to get exported functions instead of checking via extension string if(glewInit() != GLEW_OK) { GPU_LogError("Initialization Error: Failed to initialize GLEW.\n"); return 2; } { GPU_Image* image; float dt; Uint32 startTime; long frameCount; int maxSprites = 50; int numSprites; float x[50]; float y[50]; float velx[50]; float vely[50]; int i; Uint8 done; SDL_Event event; image = GPU_LoadImage("data/test.bmp"); if (image == NULL) return 3; v = GPU_LoadShader(GPU_VERTEX_SHADER, "data/shaders/untextured-150.vert"); f = GPU_LoadShader(GPU_FRAGMENT_SHADER, "data/shaders/untextured-150.frag"); p = GPU_LinkShaders(v, f); GPU_Log("%s\n", GPU_GetShaderMessage()); glUseProgram(p); vertex_loc = GPU_GetAttributeLocation(p, "gpu_Vertex"); color_loc = GPU_GetAttributeLocation(p, "gpu_Color"); modelViewProjection_loc = GPU_GetUniformLocation(p, "gpu_ModelViewProjectionMatrix"); glGenVertexArrays(1, &VAO); glBindVertexArray(VAO); glGenBuffers(1, &VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO); dt = 0.010f; startTime = SDL_GetTicks(); frameCount = 0; numSprites = 1; for (i = 0; i < maxSprites; i++) { x[i] = rand() % screen->w; y[i] = rand() % screen->h; velx[i] = 10 + rand() % screen->w / 10; vely[i] = 10 + rand() % screen->h / 10; } 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_EQUALS || event.key.keysym.sym == SDLK_PLUS) { if (numSprites < maxSprites) numSprites++; } else if (event.key.keysym.sym == SDLK_MINUS) { if (numSprites > 0) numSprites--; } } } for (i = 0; i < numSprites; i++) { x[i] += velx[i] * dt; y[i] += vely[i] * dt; if (x[i] < 0) { x[i] = 0; velx[i] = -velx[i]; } else if (x[i]> screen->w) { x[i] = screen->w; velx[i] = -velx[i]; } if (y[i] < 0) { y[i] = 0; vely[i] = -vely[i]; } else if (y[i]> screen->h) { y[i] = screen->h; vely[i] = -vely[i]; } } GPU_Clear(screen); draw_3d_stuff(screen); for (i = 0; i < numSprites; i++) { GPU_Blit(image, NULL, screen, x[i], y[i]); } draw_more_3d_stuff(screen); GPU_Flip(screen); frameCount++; if (frameCount % 500 == 0) printf("Average FPS: %.2f\n", 1000.0f*frameCount / (SDL_GetTicks() - startTime)); } printf("Average FPS: %.2f\n", 1000.0f*frameCount / (SDL_GetTicks() - startTime)); GPU_FreeImage(image); } GPU_Quit(); return 0; }
int do_attributes(GPU_Target* screen) { GPU_LogError("do_attributes()\n"); GPU_Image* image = GPU_LoadImage("data/small_test.png"); if(image == NULL) return -1; int return_value = 0; float dt = 0.010f; Uint32 startTime = SDL_GetTicks(); long frameCount = 0; int maxSprites = 50000; int numSprites = 101; // 2 pos floats per vertex, 2 texcoords, 4 color components int floats_per_vertex = 2 + 2 + 4; int floats_per_sprite = floats_per_vertex*4; float* sprite_values = (float*)malloc(sizeof(float)*maxSprites*floats_per_sprite); // Load attributes for the textured shader Uint32 program_object = 0; GPU_ActivateShaderProgram(program_object, NULL); // Disable the default shader's attributes (not a typical thing to do...) GPU_ShaderBlock block = {-1,-1,-1,GPU_GetUniformLocation(program_object, "gpu_ModelViewProjectionMatrix")}; GPU_ActivateShaderProgram(program_object, &block); GPU_Attribute attributes[3] = { GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Vertex"), sprite_values, GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 0)), GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_TexCoord"), sprite_values, GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 2*sizeof(float))), GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Color"), sprite_values, GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 4*sizeof(float))) }; float* velx = (float*)malloc(sizeof(float)*maxSprites); float* vely = (float*)malloc(sizeof(float)*maxSprites); int i; int val_n = 0; for(i = 0; i < maxSprites; i++) { float x = rand()%screen->w; float y = rand()%screen->h; sprite_values[val_n++] = x - image->w/2; sprite_values[val_n++] = y - image->h/2; sprite_values[val_n++] = 0; sprite_values[val_n++] = 0; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = x + image->w/2; sprite_values[val_n++] = y - image->h/2; sprite_values[val_n++] = 1; sprite_values[val_n++] = 0; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = x + image->w/2; sprite_values[val_n++] = y + image->h/2; sprite_values[val_n++] = 1; sprite_values[val_n++] = 1; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = x - image->w/2; sprite_values[val_n++] = y + image->h/2; sprite_values[val_n++] = 0; sprite_values[val_n++] = 1; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; sprite_values[val_n++] = rand()%101/100.0f; velx[i] = 10 + rand()%screen->w/10; vely[i] = 10 + rand()%screen->h/10; if(rand()%2) velx[i] = -velx[i]; if(rand()%2) vely[i] = -vely[i]; } Uint8 done = 0; SDL_Event event; 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) { done = 1; return_value = 1; } else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { if(numSprites < maxSprites) numSprites += 100; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(numSprites > 1) numSprites -= 100; if(numSprites < 1) numSprites = 1; GPU_LogError("Sprites: %d\n", numSprites); frameCount = 0; startTime = SDL_GetTicks(); } } } GPU_Clear(screen); for(i = 0; i < numSprites; i++) { val_n = floats_per_sprite*i; float x = sprite_values[val_n] + image->w/2; float y = sprite_values[val_n+1] + image->h/2; x += velx[i]*dt; y += vely[i]*dt; if(x < 0) { x = 0; velx[i] = -velx[i]; } else if(x > screen->w) { x = screen->w; velx[i] = -velx[i]; } if(y < 0) { y = 0; vely[i] = -vely[i]; } else if(y > screen->h) { y = screen->h; vely[i] = -vely[i]; } sprite_values[val_n] = x - image->w/2; sprite_values[val_n+1] = y - image->h/2; val_n += floats_per_vertex; sprite_values[val_n] = x + image->w/2; sprite_values[val_n+1] = y - image->h/2; val_n += floats_per_vertex; sprite_values[val_n] = x + image->w/2; sprite_values[val_n+1] = y + image->h/2; val_n += floats_per_vertex; sprite_values[val_n] = x - image->w/2; sprite_values[val_n+1] = y + image->h/2; } //float color[4] = {0.5f, 0, 0, 1.0f}; //GPU_SetAttributefv(attributes[2].location, 4, color); GPU_SetAttributeSource(numSprites*4, attributes[0]); GPU_SetAttributeSource(numSprites*4, attributes[1]); GPU_SetAttributeSource(numSprites*4, attributes[2]); GPU_BlitBatch(image, screen, numSprites, NULL, 0); GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(sprite_values); free(velx); free(vely); GPU_FreeImage(image); // Reset the default shader's block GPU_ActivateShaderProgram(screen->context->default_textured_shader_program, NULL); return return_value; }
int main(int argc, char* argv[]) { GPU_Target* screen; printRenderers(); screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) return -1; printCurrentRenderer(); { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; GPU_Image* image; #define MAX_SPRITES 100 int numSprites; float positions[2*MAX_SPRITES]; float colors[4*4*MAX_SPRITES]; float expanded_colors[4*MAX_SPRITES]; float src_rects[4*MAX_SPRITES]; Uint32 v, f, p; GPU_ShaderBlock block; Uint8 shader_index; int i; SDL_Color color = {255, 255, 255, 255}; SDL_Color red = {255, 0, 0, 255}; SDL_Color green = {0, 255, 0, 255}; SDL_Color blue = {0, 0, 255, 255}; GPU_Rect src_rect; int mx, my; Uint32 mouse_state; image = GPU_LoadImage("data/happy_50x50.bmp"); if(image == NULL) return -1; numSprites = 0; color_attr.format = GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, 4*sizeof(float), 0); color_attr.format.is_per_sprite = 0; color_attr.values = colors; block = load_shaders(&v, &f, &p); shader_index = 1; set_shader(p, &block); startTime = SDL_GetTicks(); frameCount = 0; src_rect.x = 0; src_rect.y = 0; src_rect.w = image->w; src_rect.h = image->h; add_sprite(positions, colors, expanded_colors, src_rects, &numSprites, color, src_rect); done = 0; while(!done) { while(SDL_PollEvent(&event)) { if(event.type == SDL_QUIT) done = 1; else if(event.type == SDL_MOUSEBUTTONDOWN) { if(event.button.x <= 150 && event.button.y <= 150) { if(event.button.button == SDL_BUTTON_LEFT) { float dx = event.button.x/3 - src_rect.x; float dy = event.button.y/3 - src_rect.y; src_rect.x = event.button.x/3; src_rect.y = event.button.y/3; src_rect.w -= dx; src_rect.h -= dy; } else if(event.button.button == SDL_BUTTON_RIGHT) { src_rect.w = event.button.x/3 - src_rect.x; src_rect.h = event.button.y/3 - src_rect.y; } } } else if(event.type == SDL_KEYDOWN) { if(event.key.keysym.sym == SDLK_ESCAPE) done = 1; else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { if(numSprites < MAX_SPRITES) add_sprite(positions, colors, expanded_colors, src_rects, &numSprites, color, src_rect); } else if(event.key.keysym.sym == SDLK_MINUS) { if(numSprites > 0) numSprites--; } else if(event.key.keysym.sym == SDLK_SPACE) { shader_index++; shader_index %= 2; if(shader_index == 0) set_shader(0, NULL); else if(shader_index == 1) set_shader(p, &block); } else if(event.key.keysym.sym == SDLK_RETURN) { use_color_expansion = !use_color_expansion; if(use_color_expansion) { GPU_LogError("Using attribute expansion.\n"); color_attr.format.is_per_sprite = 1; color_attr.values = expanded_colors; } else { GPU_LogError("Using per-vertex attributes.\n"); color_attr.format.is_per_sprite = 0; color_attr.values = colors; } } } } mouse_state = SDL_GetMouseState(&mx, &my); if(mouse_state & (SDL_BUTTON_LMASK | SDL_BUTTON_RMASK)) { if(mx <= 150 && my <= 150) { if(mouse_state & SDL_BUTTON_LMASK) { float dx = mx/3 - src_rect.x; float dy = my/3 - src_rect.y; src_rect.x = mx/3; src_rect.y = my/3; src_rect.w -= dx; src_rect.h -= dy; } else if(mouse_state & SDL_BUTTON_RMASK) { src_rect.w = mx/3 - src_rect.x; src_rect.h = my/3 - src_rect.y; } } } GPU_SetUniformf(timeloc, SDL_GetTicks()/1000.0f); GPU_Clear(screen); if(use_color_expansion) GPU_SetAttributeSource(numSprites, color_attr); else GPU_SetAttributeSource(4*numSprites, color_attr); for(i = 0; i < numSprites; i++) { GPU_Rect r = {src_rects[4*i], src_rects[4*i+1], src_rects[4*i+2], src_rects[4*i+3]}; GPU_Blit(image, &r, screen, positions[2*i], positions[2*i+1]); } //GPU_BlitBatchSeparate(image, screen, numSprites, positions, src_rects, expanded_colors, 0); set_shader(0, NULL); GPU_BlitScale(image, NULL, screen, 75, 75, 3.0f, 3.0f); GPU_Rectangle(screen, 3*src_rect.x, 3*src_rect.y, 3*(src_rect.x + src_rect.w), 3*(src_rect.y + src_rect.h), red); GPU_CircleFilled(screen, 3*src_rect.x, 3*src_rect.y, 4, blue); GPU_CircleFilled(screen, 3*(src_rect.x + src_rect.w), 3*(src_rect.y + src_rect.h), 4, green); if(shader_index == 1) set_shader(p, &block); GPU_Flip(screen); frameCount++; if(frameCount%500 == 0) printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); GPU_FreeImage(image); free_shaders(v, f, p); } GPU_Quit(); return 0; }
int do_interleaved(GPU_Target* screen) { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; int return_value = 0; float dt = 0.010f; int max_vertices = 60000; int num_vertices = 303; int floats_per_vertex = 2 + 2 + 4; float* vertex_values = (float*)malloc(sizeof(float)*max_vertices*floats_per_vertex); float* velx = (float*)malloc(sizeof(float)*max_vertices/3); float* vely = (float*)malloc(sizeof(float)*max_vertices/3); int i; GPU_Image* image = GPU_LoadImage("data/test3.png"); GPU_LogError("do_interleaved()\n"); if(image == NULL) return -1; startTime = SDL_GetTicks(); frameCount = 0; fill_vertex_values(vertex_values, velx, vely, max_vertices, screen, image); 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) { done = 1; return_value = 2; } else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { num_vertices += 300; if(num_vertices > max_vertices) num_vertices = max_vertices; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(num_vertices > 3) num_vertices -= 300; if(num_vertices < 3) num_vertices = 3; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } } } // FIXME: Can cause squishing when a vertex hits a wall... for(i = 0; i < num_vertices; i++) { int n = i/3; int val_n = floats_per_vertex*i; vertex_values[val_n] += velx[n]*dt; vertex_values[val_n+1] += vely[n]*dt; if(vertex_values[val_n] < 0) { vertex_values[val_n] = 0; velx[n] = -velx[n]; } else if(vertex_values[val_n] > screen->w) { vertex_values[val_n] = screen->w; velx[n] = -velx[n]; } if(vertex_values[val_n+1] < 0) { vertex_values[val_n+1] = 0; vely[n] = -vely[n]; } else if(vertex_values[val_n+1] > screen->h) { vertex_values[val_n+1] = screen->h; vely[n] = -vely[n]; } } GPU_Clear(screen); GPU_TriangleBatch(image, screen, num_vertices, vertex_values, 0, NULL, GPU_BATCH_XY_ST_RGBA); GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(vertex_values); free(velx); free(vely); GPU_FreeImage(image); return return_value; }
int do_untextured(GPU_Target* screen) { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; int return_value = 0; float dt = 0.010f; int max_vertices = 60000; int num_vertices = 303; float* velx = (float*)malloc(sizeof(float)*max_vertices/3); float* vely = (float*)malloc(sizeof(float)*max_vertices/3); int i; int val_n = 0; // 2 pos floats per vertex, 4 color components int floats_per_vertex = 2 + 4; float* vertex_values = (float*)malloc(sizeof(float)*max_vertices*floats_per_vertex); GPU_LogError("do_untextured()\n"); startTime = SDL_GetTicks(); frameCount = 0; fill_vertex_values(vertex_values, velx, vely, max_vertices, screen, NULL); 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) { done = 1; return_value = 1; } else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { num_vertices += 300; if(num_vertices > max_vertices) num_vertices = max_vertices; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(num_vertices > 3) num_vertices -= 300; if(num_vertices < 3) num_vertices = 3; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } } } GPU_Clear(screen); // FIXME: Can cause squishing when a vertex hits a wall... for(i = 0; i < num_vertices; i++) { int n = i/3; val_n = floats_per_vertex*i; vertex_values[val_n] += velx[n]*dt; vertex_values[val_n+1] += vely[n]*dt; if(vertex_values[val_n] < 0) { vertex_values[val_n] = 0; velx[n] = -velx[n]; } else if(vertex_values[val_n] > screen->w) { vertex_values[val_n] = screen->w; velx[n] = -velx[n]; } if(vertex_values[val_n+1] < 0) { vertex_values[val_n+1] = 0; vely[n] = -vely[n]; } else if(vertex_values[val_n+1] > screen->h) { vertex_values[val_n+1] = screen->h; vely[n] = -vely[n]; } } GPU_TriangleBatch(NULL, screen, num_vertices, vertex_values, 0, NULL, GPU_BATCH_XY | GPU_BATCH_RGBA); GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(vertex_values); free(velx); free(vely); // Reset the default shader's block GPU_ActivateShaderProgram(screen->context->default_textured_shader_program, NULL); return return_value; }
int do_attributes(GPU_Target* screen) { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; int return_value = 0; float dt = 0.010f; int max_vertices = 60000; int num_vertices = 303; float* velx = (float*)malloc(sizeof(float)*max_vertices/3); float* vely = (float*)malloc(sizeof(float)*max_vertices/3); int i; // 2 pos floats per vertex, 2 texcoords, 4 color components int floats_per_vertex = 2 + 2 + 4; float* vertex_values = (float*)malloc(sizeof(float)*max_vertices*floats_per_vertex); Uint32 program_object; GPU_Attribute attributes[3]; GPU_Image* image = GPU_LoadImage("data/small_test.png"); GPU_LogError("do_attributes()\n"); if(image == NULL) return -1; startTime = SDL_GetTicks(); frameCount = 0; fill_vertex_values(vertex_values, velx, vely, max_vertices, screen, image); // Load attributes for the textured shader program_object = 0; GPU_ActivateShaderProgram(program_object, NULL); // Disable the default shader's attributes (not a typical thing to do...) { GPU_ShaderBlock block = {-1,-1,-1,GPU_GetUniformLocation(program_object, "gpu_ModelViewProjectionMatrix")}; GPU_ActivateShaderProgram(program_object, &block); } attributes[0] = GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Vertex"), vertex_values, GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 0)); attributes[1] = GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_TexCoord"), vertex_values, GPU_MakeAttributeFormat(2, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 2 * sizeof(float))); attributes[2] = GPU_MakeAttribute(GPU_GetAttributeLocation(program_object, "gpu_Color"), vertex_values, GPU_MakeAttributeFormat(4, GPU_TYPE_FLOAT, 0, floats_per_vertex*sizeof(float), 4 * sizeof(float))); 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) { done = 1; return_value = 4; } else if(event.key.keysym.sym == SDLK_EQUALS || event.key.keysym.sym == SDLK_PLUS) { num_vertices += 300; if(num_vertices > max_vertices) num_vertices = max_vertices; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } else if(event.key.keysym.sym == SDLK_MINUS) { if(num_vertices > 3) num_vertices -= 300; if(num_vertices < 3) num_vertices = 3; GPU_LogError("Vertices: %d\n", num_vertices); frameCount = 0; startTime = SDL_GetTicks(); } } } GPU_Clear(screen); // FIXME: Can cause squishing when a vertex hits a wall... for(i = 0; i < num_vertices; i++) { int n = i/3; int val_n = floats_per_vertex*i; vertex_values[val_n] += velx[n]*dt; vertex_values[val_n+1] += vely[n]*dt; if(vertex_values[val_n] < 0) { vertex_values[val_n] = 0; velx[n] = -velx[n]; } else if(vertex_values[val_n] > screen->w) { vertex_values[val_n] = screen->w; velx[n] = -velx[n]; } if(vertex_values[val_n+1] < 0) { vertex_values[val_n+1] = 0; vely[n] = -vely[n]; } else if(vertex_values[val_n+1] > screen->h) { vertex_values[val_n+1] = screen->h; vely[n] = -vely[n]; } } GPU_SetAttributeSource(num_vertices, attributes[0]); GPU_SetAttributeSource(num_vertices, attributes[1]); GPU_SetAttributeSource(num_vertices, attributes[2]); GPU_TriangleBatch(image, screen, num_vertices, NULL, 0, NULL, GPU_NONE); GPU_Flip(screen); frameCount++; if(SDL_GetTicks() - startTime > 5000) { printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); frameCount = 0; startTime = SDL_GetTicks(); } } printf("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); free(vertex_values); free(velx); free(vely); GPU_FreeImage(image); // Reset the default shader's block GPU_ActivateShaderProgram(screen->context->default_textured_shader_program, NULL); return return_value; }
int main(int argc, char* argv[]) { GPU_Target* screen; printRenderers(); screen = GPU_Init(800, 600, GPU_DEFAULT_INIT_FLAGS); if(screen == NULL) return -1; printCurrentRenderer(); { Uint32 startTime; long frameCount; Uint8 done; SDL_Event event; const Uint8* keystates; GPU_Camera camera; float dt; SDL_Surface* surface; GPU_Image* image; GPU_Image* image1; GPU_Image* image2; GPU_Image* image3; GPU_Image* image4; image = GPU_LoadImage("data/test.bmp"); //image = GPU_LoadImage("data/big_test.png"); if(image == NULL) return -1; // Copying the annoying way image1 = GPU_CreateImage(image->w, image->h, GPU_FORMAT_RGBA); GPU_LoadTarget(image1); GPU_Blit(image, NULL, image1->target, image1->target->w/2, image1->target->h/2); GPU_FreeTarget(image1->target); // Copying the normal way image2 = GPU_CopyImage(image); // Copying from a surface dump surface = GPU_CopySurfaceFromImage(image); //GPU_SaveSurface(surface, "save_surf1.bmp", GPU_FILE_AUTO); image3 = GPU_CopyImageFromSurface(surface); SDL_FreeSurface(surface); // A buffer for window capture image4 = NULL; keystates = SDL_GetKeyState(NULL); camera = GPU_GetDefaultCamera(); startTime = SDL_GetTicks(); frameCount = 0; dt = 0.010f; 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) { // Take a window capture GPU_FreeImage(image4); image4 = GPU_CopyImageFromTarget(screen); } } } if(keystates[KEY_UP]) { camera.y -= 200*dt; } else if(keystates[KEY_DOWN]) { camera.y += 200*dt; } if(keystates[KEY_LEFT]) { camera.x -= 200*dt; } else if(keystates[KEY_RIGHT]) { camera.x += 200*dt; } if(keystates[KEY_MINUS]) { camera.zoom -= 1.0f*dt; } else if(keystates[KEY_EQUALS]) { camera.zoom += 1.0f*dt; } GPU_ClearRGBA(screen, 100, 100, 100, 255); GPU_SetCamera(screen, &camera); GPU_Blit(image, NULL, screen, 128, 128); GPU_Blit(image1, NULL, screen, 128 + 256, 128); GPU_Blit(image2, NULL, screen, 128 + 512, 128); GPU_Blit(image3, NULL, screen, 128, 128 + 256); if(image4 != NULL) GPU_BlitScale(image4, NULL, screen, 3*screen->w/4, 3*screen->h/4, 0.25f, 0.25f); GPU_Flip(screen); frameCount++; if(frameCount%500 == 0) GPU_LogError("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); } GPU_LogError("Average FPS: %.2f\n", 1000.0f*frameCount/(SDL_GetTicks() - startTime)); GPU_FreeImage(image); GPU_FreeImage(image1); GPU_FreeImage(image2); GPU_FreeImage(image3); GPU_FreeImage(image4); } GPU_Quit(); return 0; }