1956 lines
51 KiB
C
Executable file
1956 lines
51 KiB
C
Executable file
/*
|
|
Copyright (C) 2012-2014 Andreas Schiffler
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely.
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
|
|
#include "SDL_test_common.h"
|
|
|
|
#include "SDL2_gfxPrimitives.h"
|
|
|
|
static SDLTest_CommonState *state;
|
|
|
|
/* Screen size */
|
|
#define WIDTH DEFAULT_WINDOW_WIDTH
|
|
#define HEIGHT DEFAULT_WINDOW_HEIGHT
|
|
|
|
/* viewport border */
|
|
#define BORDER 10
|
|
|
|
#define NUM_RANDOM 4096
|
|
|
|
/* Coordinates */
|
|
static Sint16 rx[NUM_RANDOM], rx[NUM_RANDOM], ry[NUM_RANDOM], ry[NUM_RANDOM];
|
|
|
|
/* Triangles */
|
|
static Sint16 tx1[NUM_RANDOM][3], tx1[NUM_RANDOM][3], ty1[NUM_RANDOM][3], ty1[NUM_RANDOM][3];
|
|
|
|
/* Squares (made of 2 triangles) */
|
|
static Sint16 sx1[NUM_RANDOM][6], sx1[NUM_RANDOM][6], sy1[NUM_RANDOM][6], sy1[NUM_RANDOM][6];
|
|
|
|
/* Line widths */
|
|
static Uint8 lw[NUM_RANDOM];
|
|
|
|
/* Radii and offsets */
|
|
static Sint16 rr1[NUM_RANDOM], rr2[NUM_RANDOM];
|
|
|
|
/* Start and stop angles */
|
|
static Sint16 a1[NUM_RANDOM], a2[NUM_RANDOM];
|
|
|
|
/* RGB colors and alpha */
|
|
static char rr[NUM_RANDOM], rg[NUM_RANDOM], rb[NUM_RANDOM], ra[NUM_RANDOM];
|
|
|
|
/*!
|
|
\brief Generate an array of random screen coordinates, radii and RGBA values with an offset for drawing tests.
|
|
|
|
\param seed The seed for random number generation. If negative, uses current time as seed.
|
|
*/
|
|
void InitRandomPoints(int seed)
|
|
{
|
|
int i;
|
|
float af;
|
|
|
|
/* Initialize random number generator */
|
|
if (seed < 0) {
|
|
srand((unsigned int)time(NULL));
|
|
} else {
|
|
srand((unsigned int)seed);
|
|
}
|
|
|
|
for (i=0; i<NUM_RANDOM; i++) {
|
|
/* Random points in a quadrant */
|
|
rx[i]=rand() % (WIDTH/2);
|
|
ry[i]=rand() % (HEIGHT/2);
|
|
|
|
/* 5-Pixel Triangle */
|
|
tx1[i][0]=rx[i];
|
|
ty1[i][0]=ry[i];
|
|
tx1[i][1]=rx[i]+1;
|
|
ty1[i][1]=ry[i]+2;
|
|
tx1[i][2]=rx[i]+2;
|
|
ty1[i][2]=ry[i]+1;
|
|
|
|
/* 10x10 square made from 3 triangles */
|
|
sx1[i][0]=rx[i];
|
|
sy1[i][0]=ry[i];
|
|
sx1[i][1]=rx[i]+10;
|
|
sy1[i][1]=ry[i];
|
|
sx1[i][2]=rx[i];
|
|
sy1[i][2]=ry[i]+10;
|
|
sx1[i][3]=rx[i];
|
|
sy1[i][3]=ry[i]+10;
|
|
sx1[i][4]=rx[i]+10;
|
|
sy1[i][4]=ry[i];
|
|
sx1[i][5]=rx[i]+10;
|
|
sy1[i][5]=ry[i]+10;
|
|
|
|
/* Line widths */
|
|
lw[i]=2 + (rand() % 7);
|
|
|
|
/* Random Radii */
|
|
rr1[i]=rand() % 32;
|
|
rr2[i]=rand() % 32;
|
|
|
|
/* Random Angles */
|
|
a1[i]=rand() % 360;
|
|
a2[i]=rand() % 360;
|
|
|
|
/* Random Colors */
|
|
rr[i]=rand() & 255;
|
|
rg[i]=rand() & 255;
|
|
rb[i]=rand() & 255;
|
|
|
|
/* X-position dependent Alpha */
|
|
af=((float)rx[i]/(float)(WIDTH/2));
|
|
ra[i]=(int)(255.0*af);
|
|
}
|
|
}
|
|
|
|
/* Set a viewport based on a rect with a border */
|
|
void SetViewport(SDL_Renderer *renderer, int x1, int y1, int x2, int y2)
|
|
{
|
|
SDL_Rect clip;
|
|
clip.x = x1+BORDER;
|
|
clip.y = y1+BORDER;
|
|
clip.w = x2-x1-2*BORDER;
|
|
clip.h = y2-y1-2*BORDER;
|
|
SDL_RenderSetViewport(renderer, &clip);
|
|
}
|
|
|
|
/* Set a viewport rectangle based on a rect */
|
|
void SetViewportNoBorder(SDL_Renderer *renderer, int x1, int y1, int x2, int y2)
|
|
{
|
|
SDL_Rect clip;
|
|
clip.x = x1;
|
|
clip.y = y1;
|
|
clip.w = x2-x1;
|
|
clip.h = y2-y1;
|
|
SDL_RenderSetViewport(renderer, &clip);
|
|
}
|
|
|
|
/* Clear currently set viewport rectangle (if any) */
|
|
void ClearViewport(SDL_Renderer *renderer)
|
|
{
|
|
SDL_RenderSetViewport(renderer, NULL);
|
|
}
|
|
|
|
#define TLEN 256
|
|
|
|
/* Clear the screen, draw guides and color areas and titles */
|
|
void ClearScreen(SDL_Renderer *renderer, const char *title)
|
|
{
|
|
int x,y;
|
|
float stepx, stepy, fx, fy, fxy;
|
|
char titletext[TLEN+1];
|
|
Sint16 textlength;
|
|
|
|
/* Clear the screen */
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(renderer);
|
|
|
|
/* Draw the colored area */
|
|
stepx=1.0f/(WIDTH/2);
|
|
stepy=1.0f/((HEIGHT-80)/2);
|
|
fx=0.0;
|
|
for (x=WIDTH/2; x<WIDTH; x++) {
|
|
fy=0.0;
|
|
for (y=(HEIGHT-40)/2+60; y<HEIGHT; y++) {
|
|
fxy=1.0f-fx*fy;
|
|
pixelRGBA(renderer,x,y,(int)(128.0*fx*fx),(int)(128.0*fxy*fxy),(int)(128.0*fy*fy),255);
|
|
fy += stepy;
|
|
}
|
|
fx += stepx;
|
|
}
|
|
|
|
/* Segment and titles */
|
|
hlineRGBA(renderer, 0, WIDTH, 40-1, 255,255,255,255);
|
|
hlineRGBA(renderer, 0, WIDTH, 60-1, 255,255,255,255);
|
|
hlineRGBA(renderer, 0, WIDTH, (HEIGHT-40)/2+40+1, 255,255,255,255);
|
|
hlineRGBA(renderer, 0, WIDTH, (HEIGHT-40)/2+60-1, 255,255,255,255);
|
|
vlineRGBA(renderer, WIDTH/2, 40, HEIGHT, 255,255,255,255);
|
|
SDL_strlcpy(titletext,"Current Primitive: ",TLEN);
|
|
SDL_strlcat(titletext,title,TLEN);
|
|
SDL_strlcat(titletext," - Space to continue. ESC to Quit.",TLEN);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, WIDTH/2-4*textlength,10-4,titletext,255,255,0,255);
|
|
SDL_strlcpy(titletext,"A=255 on Black",TLEN);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, WIDTH/4-4*textlength,50-4,titletext,255,255,255,255);
|
|
SDL_strlcpy(titletext,"A=0-254 on Black",TLEN);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, 3*WIDTH/4-4*textlength,50-4,titletext,255,255,255,255);
|
|
SDL_strlcpy(titletext,"A=255, Color Test",TLEN);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, WIDTH/4-4*textlength,(HEIGHT-40)/2+50-4,titletext,255,255,255,255);
|
|
SDL_strlcpy(titletext,"A=0-254 on Color",TLEN);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, 3*WIDTH/4-4*textlength,(HEIGHT-40)/2+50-4,titletext,255,255,255,255);
|
|
}
|
|
|
|
/* Clear a center box for accuracy testing */
|
|
void ClearCenter(SDL_Renderer *renderer, const char *title)
|
|
{
|
|
SDL_Rect r;
|
|
int i, j;
|
|
Sint16 textlength;
|
|
|
|
r.x = WIDTH/2 - 60;
|
|
r.y = HEIGHT/2 - 30;
|
|
r.w = 2 * 60;
|
|
r.h = 2 * 25;
|
|
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
|
|
SDL_RenderFillRect(renderer, &r);
|
|
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
|
|
SDL_RenderDrawRect(renderer, &r);
|
|
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
|
|
for (i = -15; i < 15; i += 5) {
|
|
for (j = -15; j < 15; j += 5) {
|
|
SDL_RenderDrawPoint(renderer, WIDTH/2 + i, HEIGHT/2 + j);
|
|
}
|
|
}
|
|
textlength = (Sint16)strlen(title);
|
|
stringRGBA (renderer, WIDTH/2 - 4*textlength,r.y + 2,title,255,255,255,255);
|
|
}
|
|
|
|
/* !< Function pointer to a primitives test function */
|
|
typedef int (*PrimitivesTestCaseFp)(SDL_Renderer *renderer);
|
|
|
|
void ExecuteTest(SDL_Renderer *renderer, PrimitivesTestCaseFp testCase, int testNum, const char * testName)
|
|
{
|
|
char titletext[TLEN+1];
|
|
Uint32 then, now, numPrimitives;
|
|
Sint16 textlength;
|
|
|
|
ClearScreen(renderer, testName);
|
|
then = SDL_GetTicks();
|
|
numPrimitives = testCase(renderer);
|
|
now = SDL_GetTicks();
|
|
if (now > then) {
|
|
double fps = ((double) numPrimitives * 1000) / (now - then);
|
|
SDL_snprintf(titletext, TLEN, "Test %2i %20s: %10.1f /sec", testNum, testName, fps);
|
|
textlength = (Sint16)strlen(titletext);
|
|
stringRGBA (renderer, WIDTH/2-4*textlength,30-4,titletext,255,255,255,255);
|
|
SDL_Log(titletext);
|
|
}
|
|
}
|
|
|
|
/* --------------------- Tests ------------------------ */
|
|
|
|
int TestPixel(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 1;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pixelRGBA(renderer, rx[i], ry[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pixelRGBA(renderer, rx[i], ry[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pixelRGBA(renderer, rx[i], ry[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
pixelRGBA(renderer, rx[i], ry[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "1x1 pixel");
|
|
pixelRGBA(renderer, WIDTH/2, HEIGHT/2, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestHline(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
hlineRGBA(renderer, rx[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
hlineRGBA(renderer, rx[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
hlineRGBA(renderer, rx[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
hlineRGBA(renderer, rx[i], rx[i]+rr1[i], ry[i+1], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "5x1 hline");
|
|
hlineRGBA(renderer, WIDTH/2, WIDTH/2 + 5, HEIGHT/2, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestVline(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
vlineRGBA(renderer, rx[i], ry[i], ry[i+1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
vlineRGBA(renderer, rx[i], ry[i], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
vlineRGBA(renderer, rx[i], ry[i], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
vlineRGBA(renderer, rx[i], ry[i], ry[i]+rr1[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "1x5 vline");
|
|
vlineRGBA(renderer, WIDTH/2, HEIGHT/2, HEIGHT/2 + 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestRectangle(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
rectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
rectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
rectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
rectangleRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "5x10 rect");
|
|
rectangleRGBA(renderer, WIDTH/2, HEIGHT/2, WIDTH/2 + 5, HEIGHT/2 + 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestRoundedRectangle(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedRectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedRectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedRectangleRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
roundedRectangleRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], 4, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "20x10-r5 rect");
|
|
roundedRectangleRGBA(renderer, WIDTH/2 - 10, HEIGHT/2, WIDTH/2 + 10, HEIGHT/2 + 10, 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestBox(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
boxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
boxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
boxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
boxRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "5x10 box");
|
|
boxRGBA(renderer, WIDTH/2, HEIGHT/2, WIDTH/2 + 5, HEIGHT/2 + 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestRoundedBox(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedBoxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedBoxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
roundedBoxRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
roundedBoxRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], 4, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "20x15-r5 box");
|
|
roundedBoxRGBA(renderer, WIDTH/2 - 10, HEIGHT/2-5, WIDTH/2 + 10, HEIGHT/2 + 10, 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestLine(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
lineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
lineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
lineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
lineRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "14px a45 line");
|
|
lineRGBA(renderer, WIDTH/2, HEIGHT/2, WIDTH/2 + 10, HEIGHT/2 + 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestAALine(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r, g, b;
|
|
int step = 4;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer, 0, 60, WIDTH / 2, 60 + (HEIGHT - 80) / 2);
|
|
for (i = 0; i<NUM_RANDOM; i += step) {
|
|
aalineRGBA(renderer, rx[i], ry[i], rx[i + 1], ry[i + 1], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer, WIDTH / 2, 60, WIDTH, 60 + (HEIGHT - 80) / 2);
|
|
for (i = 0; i<NUM_RANDOM; i += step) {
|
|
aalineRGBA(renderer, rx[i], ry[i], rx[i + 1], ry[i + 1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer, WIDTH / 2, 80 + (HEIGHT - 80) / 2, WIDTH, HEIGHT);
|
|
for (i = 0; i<NUM_RANDOM; i += step) {
|
|
aalineRGBA(renderer, rx[i], ry[i], rx[i + 1], ry[i + 1], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer, 0, 80 + (HEIGHT - 80) / 2, WIDTH / 2, HEIGHT);
|
|
for (i = 0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH / 6)) {
|
|
r = 255; g = 0; b = 0;
|
|
}
|
|
else if (rx[i] < (WIDTH / 3)) {
|
|
r = 0; g = 255; b = 0;
|
|
}
|
|
else {
|
|
r = 0; g = 0; b = 255;
|
|
}
|
|
aalineRGBA(renderer, rx[i], ry[i], rx[i] + rr1[i], ry[i] + rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "14px a45 aaline");
|
|
aalineRGBA(renderer, WIDTH / 2, HEIGHT / 2, WIDTH / 2 + 10, HEIGHT / 2 + 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
|
|
int TestCircle(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
circleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
circleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
circleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
circleRGBA(renderer, rx[i], ry[i], rr1[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10 circle");
|
|
circleRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestAACircle(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 4;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aacircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aacircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aacircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
aacircleRGBA(renderer, rx[i], ry[i], rr1[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10 AA circle");
|
|
aacircleRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestFilledCircle(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledCircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledCircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledCircleRGBA(renderer, rx[i], ry[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
filledCircleRGBA(renderer, rx[i], ry[i], rr1[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10 F circle");
|
|
filledCircleRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestEllipse(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
ellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
ellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
ellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
ellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10r5 ellipse");
|
|
ellipseRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestAAEllipse(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 4;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aaellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aaellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
aaellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
aaellipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10r5 AA ellipse");
|
|
aaellipseRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestFilledEllipse(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 2;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledEllipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledEllipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledEllipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
filledEllipseRGBA(renderer, rx[i], ry[i], rr1[i], rr2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r10r5 F ellipse");
|
|
filledEllipseRGBA(renderer, WIDTH/2, HEIGHT/2, 10, 5, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestBezier(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 5;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
bezierRGBA(renderer, &rx[i], &ry[i], 3, 100, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
bezierRGBA(renderer, &rx[i], &ry[i], 3, 100, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
bezierRGBA(renderer, &rx[i], &ry[i], 3, 100, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
rx[i+1]=rx[i]+rr1[i];
|
|
rx[i+2]=rx[i];
|
|
ry[i+1]=ry[i];
|
|
ry[i+2]=ry[i]+rr2[i];
|
|
bezierRGBA(renderer, &rx[i], &ry[i], 3, 100, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3pt bezier");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 5; ry[1] = ry[0] + 5;
|
|
rx[2] = rx[0] + 10; ry[2] = ry[0] - 5;
|
|
bezierRGBA(renderer, rx, ry, 3, 100, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestPolygon(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 3;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
polygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
polygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
polygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
rx[i+1]=rx[i]+rr1[i];
|
|
rx[i+2]=rx[i];
|
|
ry[i+1]=ry[i];
|
|
ry[i+2]=ry[i]+rr2[i];
|
|
polygonRGBA(renderer, &rx[i], &ry[i], 3, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3pt poly");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 5; ry[1] = ry[0] + 5;
|
|
rx[2] = rx[0] + 10; ry[2] = ry[0] - 5;
|
|
polygonRGBA(renderer, rx, ry, 3, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestAAPolygon(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 4;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
aapolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
aapolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
aapolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
rx[i+1]=rx[i]+rr1[i];
|
|
rx[i+2]=rx[i];
|
|
ry[i+1]=ry[i];
|
|
ry[i+2]=ry[i]+rr2[i];
|
|
aapolygonRGBA(renderer, &rx[i], &ry[i], 3, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3pt AA poly");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 5; ry[1] = ry[0] + 5;
|
|
rx[2] = rx[0] + 10; ry[2] = ry[0] - 5;
|
|
aapolygonRGBA(renderer, rx, ry, 3, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestFilledPolygon(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 4;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
filledPolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
filledPolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
filledPolygonRGBA(renderer, &rx[i], &ry[i], 3, rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<(NUM_RANDOM-3); i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
rx[i+1]=rx[i]+rr1[i];
|
|
rx[i+2]=rx[i];
|
|
ry[i+1]=ry[i];
|
|
ry[i+2]=ry[i]+rr2[i];
|
|
filledPolygonRGBA(renderer, &rx[i], &ry[i], 3, r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3pt F poly");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 5; ry[1] = ry[0] + 5;
|
|
rx[2] = rx[0] + 10; ry[2] = ry[0] - 5;
|
|
filledPolygonRGBA(renderer, rx, ry, 3, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestTrigon(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 1;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
trigonRGBA(renderer, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
trigonRGBA(renderer, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
trigonRGBA(renderer, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
trigonRGBA(renderer, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3px 3pt trigon");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 1; ry[1] = ry[0] + 2;
|
|
rx[2] = rx[0] + 2; ry[2] = ry[0] + 1;
|
|
trigonRGBA(renderer, rx[0], ry[0], rx[1], ry[1], rx[2], ry[2], 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestArc(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 1;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
arcRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
arcRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
arcRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
arcRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r5 a45 arc");
|
|
arcRGBA(renderer, WIDTH/2, HEIGHT/2, 5, 0, 90, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestPie(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 1;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
pieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
pieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r5 a45 pie");
|
|
pieRGBA(renderer, WIDTH/2, HEIGHT/2, 5, 0, 90, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestFilledPie(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 1;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledPieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledPieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
filledPieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
filledPieRGBA(renderer, rx[i], ry[i], rr1[i], a1[i], a2[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "r5 a45 F pie");
|
|
filledPieRGBA(renderer, WIDTH/2, HEIGHT/2, 5, 0, 90, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestThickLine(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
char r,g,b;
|
|
int step = 6;
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
thickLineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], lw[i], rr[i], rg[i], rb[i], 255);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
thickLineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], lw[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
thickLineRGBA(renderer, rx[i], ry[i], rx[i+1], ry[i+1], lw[i], rr[i], rg[i], rb[i], ra[i]);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
r=255; g=0; b=0;
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
r=0; g=255; b=0;
|
|
} else {
|
|
r=0; g=0; b=255;
|
|
}
|
|
thickLineRGBA(renderer, rx[i], ry[i], rx[i]+rr1[i], ry[i]+rr2[i], lw[i], r, g, b, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "18px w2w3 line");
|
|
thickLineRGBA(renderer, WIDTH/2 - 10, HEIGHT/2 - 5, WIDTH/2, HEIGHT/2 + 10, 2, 255, 255, 255, 255);
|
|
thickLineRGBA(renderer, WIDTH/2, HEIGHT/2 - 5, WIDTH/2 + 10, HEIGHT/2 + 10, 3, 255, 255, 255, 255);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestThickLineAccuracy(SDL_Renderer *renderer)
|
|
{
|
|
int i;
|
|
int w;
|
|
int cx, cy;
|
|
int dx, dy, width;
|
|
int astep = 24;
|
|
int wstep = 3;
|
|
double a;
|
|
char localMessage[128];
|
|
|
|
cx = WIDTH/4;
|
|
cy = (HEIGHT-140)/4;
|
|
|
|
/* Test 4 different width */
|
|
for (w = 0; w < 4; w++) {
|
|
switch (w) {
|
|
case 0:
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
break;
|
|
case 1:
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
break;
|
|
case 2:
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
break;
|
|
case 3:
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
break;
|
|
}
|
|
|
|
/* Accuracy test #2 */
|
|
for (i = 0; i <= 360; i += astep) {
|
|
a = 2.0 * M_PI * (double)i / 360.0;
|
|
dx = (int)(84.0 * SDL_sin(a));
|
|
dy = (int)(84.0 * SDL_cos(a));
|
|
width = wstep * (w + 1);
|
|
thickLineRGBA(renderer, cx, cy, cx + dx, cy + dy, width, 255, 255, 255, 255);
|
|
}
|
|
|
|
/* Display current width */
|
|
SDL_snprintf(localMessage, 128, "w = %d", width);
|
|
stringRGBA(renderer, 8, 8, localMessage, 255, 255, 255, 255);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
return 4 * 360/astep;
|
|
}
|
|
|
|
|
|
int TestTexturedPolygon(SDL_Renderer *renderer)
|
|
{
|
|
/* Define masking bytes */
|
|
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
|
Uint32 rmask = 0xff000000;
|
|
Uint32 gmask = 0x00ff0000;
|
|
Uint32 bmask = 0x0000ff00;
|
|
Uint32 amask = 0x000000ff;
|
|
#else
|
|
Uint32 amask = 0xff000000;
|
|
Uint32 bmask = 0x00ff0000;
|
|
Uint32 gmask = 0x0000ff00;
|
|
Uint32 rmask = 0x000000ff;
|
|
#endif
|
|
int i;
|
|
int step = 24;
|
|
char *bmpfile;
|
|
SDL_Surface *picture, *picture_again;
|
|
|
|
/* Load an image into a surface */
|
|
bmpfile = "sample24.bmp";
|
|
picture = SDL_LoadBMP(bmpfile);
|
|
if ( picture == NULL ) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", bmpfile, SDL_GetError());
|
|
return -1;
|
|
}
|
|
|
|
/* Convert 24bit image into 32bit RGBA surface */
|
|
picture_again = SDL_CreateRGBSurface(SDL_SWSURFACE, picture->w, picture->h, 32, rmask, gmask, bmask, amask);
|
|
if (picture_again == NULL) {
|
|
SDL_FreeSurface(picture);
|
|
return -1;
|
|
}
|
|
|
|
/* Draw A=255 */
|
|
SetViewport(renderer,0,60,WIDTH/2,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
SDL_SetSurfaceColorMod(picture, rr[i], rg[i], rb[i]);
|
|
SDL_BlitSurface(picture, NULL, picture_again, NULL);
|
|
texturedPolygon(renderer, &rx[i], &ry[i], 3, picture_again, 0, 0);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
SDL_SetSurfaceColorMod(picture, rr[i], rg[i], rb[i]);
|
|
SDL_BlitSurface(picture, NULL, picture_again, NULL);
|
|
texturedPolygon(renderer, &rx[i], &ry[i], 3, picture_again, 0, 0);
|
|
}
|
|
|
|
/* Draw A=various */
|
|
SetViewport(renderer,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
SDL_SetSurfaceColorMod(picture, rr[i], rg[i], rb[i]);
|
|
SDL_BlitSurface(picture, NULL, picture_again, NULL);
|
|
texturedPolygon(renderer, &rx[i], &ry[i], 3, picture_again, 0, 0);
|
|
}
|
|
|
|
/* Draw Colortest */
|
|
SetViewport(renderer,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
|
|
for (i=0; i<NUM_RANDOM; i += step) {
|
|
if (rx[i] < (WIDTH/6)) {
|
|
SDL_FillRect(picture_again, NULL, SDL_MapRGB(picture_again->format, 255, 0, 0));
|
|
} else if (rx[i] < (WIDTH/3) ) {
|
|
SDL_FillRect(picture_again, NULL, SDL_MapRGB(picture_again->format, 0, 255, 0));
|
|
} else {
|
|
SDL_FillRect(picture_again, NULL, SDL_MapRGB(picture_again->format, 0, 0, 255));
|
|
}
|
|
|
|
texturedPolygon(renderer, &rx[i], &ry[i], 3, picture_again, 0, 0);
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
/* Accuracy test */
|
|
ClearCenter(renderer, "3pt T poly");
|
|
rx[0] = WIDTH/2; ry[0] = HEIGHT/2;
|
|
rx[1] = rx[0] + 5; ry[1] = ry[0] + 5;
|
|
rx[2] = rx[0] + 10; ry[2] = ry[0] - 5;
|
|
texturedPolygon(renderer, rx, ry, 3, picture_again, 0, 0);
|
|
|
|
SDL_FreeSurface(picture);
|
|
SDL_FreeSurface(picture_again);
|
|
|
|
return (4 * NUM_RANDOM) / step;
|
|
}
|
|
|
|
int TestBigCircle(SDL_Renderer *renderer)
|
|
{
|
|
int i, j, k;
|
|
Uint8 r, g, b, a;
|
|
int ad;
|
|
int count = 0;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
SetViewport(renderer, 0, 60, WIDTH / 2, 60 + (HEIGHT - 80) / 2);
|
|
ad = 0;
|
|
break;
|
|
case 1:
|
|
SetViewport(renderer, WIDTH / 2, 60, WIDTH, 60 + (HEIGHT - 80) / 2);
|
|
ad = 1;
|
|
break;
|
|
case 2:
|
|
SetViewport(renderer, WIDTH / 2, 80 + (HEIGHT - 80) / 2, WIDTH, HEIGHT);
|
|
ad = 0;
|
|
break;
|
|
case 3:
|
|
SetViewport(renderer, 0, 80 + (HEIGHT - 80) / 2, WIDTH / 2, HEIGHT);
|
|
ad = 1;
|
|
break;
|
|
}
|
|
|
|
/* Various radii around 255 and 511 */
|
|
for (k = 1; k <= 2; k++)
|
|
{
|
|
a = 255;
|
|
for (j = -32; j <= 32; j++)
|
|
{
|
|
switch (j & 3)
|
|
{
|
|
case 0:
|
|
r = 255; g = 0; b = 0;
|
|
break;
|
|
case 1:
|
|
r = 0; g = 255; b = 0;
|
|
break;
|
|
case 2:
|
|
r = 0; g = 0; b = 255;
|
|
break;
|
|
}
|
|
|
|
circleRGBA(renderer,
|
|
WIDTH / 2,
|
|
HEIGHT / (2 - k + 1),
|
|
(Sint16)(256 * k - 1 + 2 * j),
|
|
r,
|
|
g,
|
|
b,
|
|
a);
|
|
|
|
a = a - 2 * ad;
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
int TestBigEllipse(SDL_Renderer *renderer)
|
|
{
|
|
int i, j, k;
|
|
Uint8 r, g, b, a;
|
|
Uint8 ad;
|
|
int count = 0;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
SetViewport(renderer, 0, 60, WIDTH / 2, 60 + (HEIGHT - 80) / 2);
|
|
ad = 0;
|
|
break;
|
|
case 1:
|
|
SetViewport(renderer, WIDTH / 2, 60, WIDTH, 60 + (HEIGHT - 80) / 2);
|
|
ad = 1;
|
|
break;
|
|
case 2:
|
|
SetViewport(renderer, WIDTH / 2, 80 + (HEIGHT - 80) / 2, WIDTH, HEIGHT);
|
|
ad = 0;
|
|
break;
|
|
case 3:
|
|
SetViewport(renderer, 0, 80 + (HEIGHT - 80) / 2, WIDTH / 2, HEIGHT);
|
|
ad = 1;
|
|
break;
|
|
}
|
|
|
|
/* Various radii around 255 and 511 */
|
|
for (k = 1; k <= 2; k++)
|
|
{
|
|
a = 255;
|
|
for (j = -32; j <= 32; j++)
|
|
{
|
|
switch (j & 3)
|
|
{
|
|
case 0:
|
|
r = 255; g = 0; b = 0;
|
|
break;
|
|
case 1:
|
|
r = 0; g = 255; b = 0;
|
|
break;
|
|
case 2:
|
|
r = 0; g = 0; b = 255;
|
|
break;
|
|
}
|
|
|
|
ellipseRGBA(renderer,
|
|
WIDTH / 2,
|
|
HEIGHT / 2,
|
|
(Sint16)(256 * k - 1 + 2 * j),
|
|
(Sint16)(256 * k - 1 - 2 * j),
|
|
r,
|
|
g,
|
|
b,
|
|
a);
|
|
|
|
ellipseRGBA(renderer,
|
|
WIDTH / 2,
|
|
HEIGHT / 2,
|
|
(Sint16)(256 * k - 1 - 2 * j),
|
|
(Sint16)(256 * k - 1 + 2 * j),
|
|
r,
|
|
g,
|
|
b,
|
|
a);
|
|
|
|
a = a - 2 * ad;
|
|
count += 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clear viewport */
|
|
ClearViewport(renderer);
|
|
|
|
return count;
|
|
}
|
|
|
|
/* ====== Main */
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int i, done, drawn, test = 0;
|
|
SDL_Event event;
|
|
Uint32 then, now, frames;
|
|
int numTests;
|
|
|
|
/* Initialize test framework */
|
|
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
|
|
if (!state) {
|
|
return 1;
|
|
}
|
|
|
|
SDL_Log("SDL2_gfx %i.%i.%i: testgfx", SDL2_GFXPRIMITIVES_MAJOR, SDL2_GFXPRIMITIVES_MINOR, SDL2_GFXPRIMITIVES_MICRO);
|
|
SDL_Log("Platform: %s", SDL_GetPlatform());
|
|
|
|
for (i = 1; i < argc;) {
|
|
int consumed;
|
|
consumed = SDLTest_CommonArg(state, i);
|
|
if (consumed == 0) {
|
|
consumed = -1;
|
|
if (SDL_strcasecmp(argv[i], "--test") == 0) {
|
|
if (argv[i + 1]) {
|
|
test = SDL_atoi(argv[i + 1]);
|
|
consumed = 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (consumed < 0) {
|
|
fprintf(stderr,
|
|
"Usage: %s %s [--test N]\n",
|
|
argv[0], SDLTest_CommonUsage(state));
|
|
return 1;
|
|
}
|
|
i += consumed;
|
|
}
|
|
|
|
if (!SDLTest_CommonInit(state)) {
|
|
return 2;
|
|
}
|
|
|
|
/* Create the windows and initialize the renderers */
|
|
for (i = 0; i < state->num_windows; ++i) {
|
|
SDL_Renderer *renderer = state->renderers[i];
|
|
SDL_RendererInfo info;
|
|
SDL_GetRendererInfo(state->renderers[i], &info);
|
|
SDL_Log("Renderer %i: %s %s", i, info.name, (info.flags | SDL_RENDERER_ACCELERATED) ? "(Accelerated)" : "");
|
|
SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
|
|
SDL_RenderClear(renderer);
|
|
}
|
|
|
|
/* Main render loop */
|
|
frames = 0;
|
|
then = SDL_GetTicks();
|
|
done = 0;
|
|
drawn = 0;
|
|
while (!done) {
|
|
/* Check for events */
|
|
++frames;
|
|
while (SDL_PollEvent(&event)) {
|
|
SDLTest_CommonEvent(state, &event, &done);
|
|
switch (event.type) {
|
|
case SDL_KEYDOWN: {
|
|
switch (event.key.keysym.sym) {
|
|
case SDLK_SPACE: {
|
|
/* Switch to next test */
|
|
test++;
|
|
drawn = 0;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case SDL_MOUSEBUTTONDOWN: {
|
|
switch (event.button.button) {
|
|
case SDL_BUTTON_LEFT: {
|
|
/* Switch to next test */
|
|
test++;
|
|
drawn = 0;
|
|
break;
|
|
}
|
|
case SDL_BUTTON_RIGHT: {
|
|
/* Switch to prev test */
|
|
test--;
|
|
drawn = 0;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!drawn) {
|
|
/* Set test range */
|
|
numTests = 28;
|
|
if (test < 0) {
|
|
test = (numTests - 1);
|
|
} else {
|
|
test = test % numTests;
|
|
}
|
|
|
|
/* Create random points */
|
|
InitRandomPoints(test);
|
|
|
|
/* Draw */
|
|
for (i = 0; i < state->num_windows; ++i) {
|
|
SDL_Renderer *renderer = state->renderers[i];
|
|
|
|
switch (test) {
|
|
case 0: {
|
|
ExecuteTest(renderer, TestPixel, test, "Pixel");
|
|
break;
|
|
}
|
|
case 1: {
|
|
ExecuteTest(renderer, TestHline, test, "Hline");
|
|
break;
|
|
}
|
|
case 2: {
|
|
ExecuteTest(renderer, TestVline, test, "Vline");
|
|
break;
|
|
}
|
|
case 3: {
|
|
ExecuteTest(renderer, TestRectangle, test, "Rectangle");
|
|
break;
|
|
}
|
|
case 4: {
|
|
ExecuteTest(renderer, TestRoundedRectangle, test, "RoundedRectangle");
|
|
break;
|
|
}
|
|
case 5: {
|
|
ExecuteTest(renderer, TestBox, test, "Box");
|
|
break;
|
|
}
|
|
case 6: {
|
|
ExecuteTest(renderer, TestLine, test, "Line");
|
|
break;
|
|
}
|
|
case 7: {
|
|
ExecuteTest(renderer, TestAALine, test, "AALine");
|
|
break;
|
|
}
|
|
case 8: {
|
|
ExecuteTest(renderer, TestCircle, test, "Circle");
|
|
break;
|
|
}
|
|
case 9: {
|
|
ExecuteTest(renderer, TestAACircle, test, "AACircle");
|
|
break;
|
|
}
|
|
case 10: {
|
|
ExecuteTest(renderer, TestFilledCircle, test, "FilledCircle");
|
|
break;
|
|
}
|
|
case 11: {
|
|
ExecuteTest(renderer, TestEllipse, test, "Ellipse");
|
|
break;
|
|
}
|
|
case 12: {
|
|
ExecuteTest(renderer, TestAAEllipse, test, "AAEllipse");
|
|
break;
|
|
}
|
|
case 13: {
|
|
ExecuteTest(renderer, TestFilledEllipse, test, "FilledEllipse");
|
|
break;
|
|
}
|
|
case 14: {
|
|
ExecuteTest(renderer, TestBezier, test, "Bezier");
|
|
break;
|
|
}
|
|
case 15: {
|
|
ExecuteTest(renderer, TestPolygon, test, "Polygon");
|
|
break;
|
|
}
|
|
case 16: {
|
|
ExecuteTest(renderer, TestAAPolygon, test, "AAPolygon");
|
|
break;
|
|
}
|
|
case 17: {
|
|
ExecuteTest(renderer, TestFilledPolygon, test, "FilledPolygon");
|
|
break;
|
|
}
|
|
case 18: {
|
|
ExecuteTest(renderer, TestTrigon, test, "Trigon");
|
|
break;
|
|
}
|
|
case 19: {
|
|
ExecuteTest(renderer, TestArc, test, "Arc");
|
|
break;
|
|
}
|
|
case 20: {
|
|
ExecuteTest(renderer, TestPie, test, "Pie");
|
|
break;
|
|
}
|
|
case 21: {
|
|
ExecuteTest(renderer, TestFilledPie, test, "FilledPie");
|
|
break;
|
|
}
|
|
case 22: {
|
|
ExecuteTest(renderer, TestThickLine, test, "ThickLine");
|
|
break;
|
|
}
|
|
case 23: {
|
|
ExecuteTest(renderer, TestTexturedPolygon, test, "TexturedPolygon");
|
|
break;
|
|
}
|
|
case 24: {
|
|
ExecuteTest(renderer, TestRoundedBox, test, "RoundedBox");
|
|
break;
|
|
}
|
|
case 25: {
|
|
ExecuteTest(renderer, TestThickLineAccuracy, test, "ThickLine (Accuracy)");
|
|
break;
|
|
}
|
|
case 26: {
|
|
ExecuteTest(renderer, TestBigCircle, test, "Circle (Big)");
|
|
break;
|
|
}
|
|
case 27: {
|
|
ExecuteTest(renderer, TestBigEllipse, test, "Ellipse (Big)");
|
|
break;
|
|
}
|
|
default: {
|
|
ClearScreen(renderer, "Unknown Test");
|
|
break;
|
|
}
|
|
}
|
|
|
|
SDL_RenderPresent(renderer);
|
|
}
|
|
drawn = 1;
|
|
}
|
|
|
|
/* Adjust framerate */
|
|
SDL_Delay(25);
|
|
}
|
|
|
|
SDLTest_CommonQuit(state);
|
|
|
|
/* Print out some timing information */
|
|
now = SDL_GetTicks();
|
|
if (now > then) {
|
|
double fps = ((double) frames * 1000) / (now - then);
|
|
printf("%2.2f frames per second\n", fps);
|
|
}
|
|
return 0;
|
|
}
|