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