this repo has no description
Changed Arc and Sector angle parameters to non-camelcase.
+99
-99
+75
-75
SDL_gpu/GL_common/SDL_gpuShapes_GL_common.inl
+75
-75
SDL_gpu/GL_common/SDL_gpuShapes_GL_common.inl
···
122
122
// Arc() might call Circle()
123
123
static void Circle(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
124
124
125
-
static void Arc(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color)
125
+
static void Arc(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
126
126
{
127
-
float originalSA = startAngle;
127
+
float originalSA = start_angle;
128
128
129
-
if(startAngle > endAngle)
129
+
if(start_angle > end_angle)
130
130
{
131
-
float swapa = endAngle;
132
-
endAngle = startAngle;
133
-
startAngle = swapa;
131
+
float swapa = end_angle;
132
+
end_angle = start_angle;
133
+
start_angle = swapa;
134
134
}
135
-
if(startAngle == endAngle)
135
+
if(start_angle == end_angle)
136
136
return;
137
137
138
138
// Big angle
139
-
if(endAngle - startAngle >= 360)
139
+
if(end_angle - start_angle >= 360)
140
140
{
141
141
Circle(renderer, target, x, y, radius, color);
142
142
return;
143
143
}
144
144
145
145
// Shift together
146
-
while(startAngle < 0 && endAngle < 0)
146
+
while(start_angle < 0 && end_angle < 0)
147
147
{
148
-
startAngle += 360;
149
-
endAngle += 360;
148
+
start_angle += 360;
149
+
end_angle += 360;
150
150
}
151
-
while(startAngle > 360 && endAngle > 360)
151
+
while(start_angle > 360 && end_angle > 360)
152
152
{
153
-
startAngle -= 360;
154
-
endAngle -= 360;
153
+
start_angle -= 360;
154
+
end_angle -= 360;
155
155
}
156
156
157
157
// Check if the angle to be drawn crosses 0
158
-
Uint8 crossesZero = (startAngle < 0 && endAngle > 0) || (startAngle < 360 && endAngle > 360);
158
+
Uint8 crossesZero = (start_angle < 0 && end_angle > 0) || (start_angle < 360 && end_angle > 360);
159
159
160
-
if(endAngle == 0)
161
-
endAngle = 360;
160
+
if(end_angle == 0)
161
+
end_angle = 360;
162
162
else if(crossesZero)
163
163
{
164
164
float sa = originalSA;
···
168
168
Arc(renderer, target, x, y, radius, sa, 359.9f, color);
169
169
170
170
// Continue to render the right part
171
-
startAngle = 0;
172
-
while(endAngle >= 360)
173
-
endAngle -= 360;
171
+
start_angle = 0;
172
+
while(end_angle >= 360)
173
+
end_angle -= 360;
174
174
}
175
175
176
176
177
-
float t = startAngle;
178
-
float dt = ((endAngle - startAngle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
177
+
float t = start_angle;
178
+
float dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
179
179
float dx, dy;
180
180
181
-
int numSegments = fabs(endAngle - startAngle)/dt;
181
+
int numSegments = fabs(end_angle - start_angle)/dt;
182
182
if(numSegments == 0)
183
183
return;
184
184
···
200
200
}
201
201
202
202
// Last point
203
-
dx = radius*cos(endAngle*RADPERDEG);
204
-
dy = radius*sin(endAngle*RADPERDEG);
203
+
dx = radius*cos(end_angle*RADPERDEG);
204
+
dy = radius*sin(end_angle*RADPERDEG);
205
205
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a);
206
206
}
207
207
208
208
// ArcFilled() might call CircleFilled()
209
209
static void CircleFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
210
210
211
-
static void ArcFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color)
211
+
static void ArcFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
212
212
{
213
-
float originalSA = startAngle;
213
+
float originalSA = start_angle;
214
214
215
-
if(startAngle > endAngle)
215
+
if(start_angle > end_angle)
216
216
{
217
-
float swapa = endAngle;
218
-
endAngle = startAngle;
219
-
startAngle = swapa;
217
+
float swapa = end_angle;
218
+
end_angle = start_angle;
219
+
start_angle = swapa;
220
220
}
221
-
if(startAngle == endAngle)
221
+
if(start_angle == end_angle)
222
222
return;
223
223
224
224
// Big angle
225
-
if(endAngle - startAngle >= 360)
225
+
if(end_angle - start_angle >= 360)
226
226
{
227
227
CircleFilled(renderer, target, x, y, radius, color);
228
228
return;
229
229
}
230
230
231
231
// Shift together
232
-
while(startAngle < 0 && endAngle < 0)
232
+
while(start_angle < 0 && end_angle < 0)
233
233
{
234
-
startAngle += 360;
235
-
endAngle += 360;
234
+
start_angle += 360;
235
+
end_angle += 360;
236
236
}
237
-
while(startAngle > 360 && endAngle > 360)
237
+
while(start_angle > 360 && end_angle > 360)
238
238
{
239
-
startAngle -= 360;
240
-
endAngle -= 360;
239
+
start_angle -= 360;
240
+
end_angle -= 360;
241
241
}
242
242
243
243
// Check if the angle to be drawn crosses 0
244
-
Uint8 crossesZero = (startAngle < 0 && endAngle > 0) || (startAngle < 360 && endAngle > 360);
244
+
Uint8 crossesZero = (start_angle < 0 && end_angle > 0) || (start_angle < 360 && end_angle > 360);
245
245
246
-
if(endAngle == 0)
247
-
endAngle = 360;
246
+
if(end_angle == 0)
247
+
end_angle = 360;
248
248
else if(crossesZero)
249
249
{
250
250
float sa = originalSA;
···
255
255
ArcFilled(renderer, target, x, y, radius, sa, 359.9f, color);
256
256
257
257
// Continue to render the right part
258
-
startAngle = 0;
259
-
while(endAngle >= 360)
260
-
endAngle -= 360;
258
+
start_angle = 0;
259
+
while(end_angle >= 360)
260
+
end_angle -= 360;
261
261
}
262
262
263
-
float t = startAngle;
264
-
float dt = ((endAngle - startAngle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
263
+
float t = start_angle;
264
+
float dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
265
265
float dx, dy;
266
266
267
-
int numSegments = fabs(endAngle - startAngle)/dt;
267
+
int numSegments = fabs(end_angle - start_angle)/dt;
268
268
if(numSegments == 0)
269
269
return;
270
270
···
294
294
}
295
295
296
296
// Last triangle
297
-
dx = radius*cos(endAngle*RADPERDEG);
298
-
dy = radius*sin(endAngle*RADPERDEG);
297
+
dx = radius*cos(end_angle*RADPERDEG);
298
+
dy = radius*sin(end_angle*RADPERDEG);
299
299
SET_INDEXED_VERTEX(0); // center
300
300
SET_INDEXED_VERTEX(i); // last point
301
301
SET_UNTEXTURED_VERTEX(x+dx, y+dy, r, g, b, a); // new point
···
364
364
SET_INDEXED_VERTEX(1); // first point
365
365
}
366
366
367
-
static void Sector(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color)
367
+
static void Sector(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
368
368
{
369
369
if(inner_radius < 0.0f)
370
370
inner_radius = 0.0f;
···
380
380
381
381
if(inner_radius == outer_radius)
382
382
{
383
-
Arc(renderer, target, x, y, inner_radius, startAngle, endAngle, color);
383
+
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
384
384
return;
385
385
}
386
386
387
387
// Composited shape... But that means error codes may be confusing. :-/
388
388
float dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4;
389
-
Arc(renderer, target, x, y, inner_radius, startAngle, endAngle, color);
389
+
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
390
390
391
-
dx1 = inner_radius*cos(endAngle*RADPERDEG);
392
-
dy1 = inner_radius*sin(endAngle*RADPERDEG);
393
-
dx2 = outer_radius*cos(endAngle*RADPERDEG);
394
-
dy2 = outer_radius*sin(endAngle*RADPERDEG);
391
+
dx1 = inner_radius*cos(end_angle*RADPERDEG);
392
+
dy1 = inner_radius*sin(end_angle*RADPERDEG);
393
+
dx2 = outer_radius*cos(end_angle*RADPERDEG);
394
+
dy2 = outer_radius*sin(end_angle*RADPERDEG);
395
395
Line(renderer, target, x+dx1, y+dy1, x+dx2, y+dy2, color);
396
396
397
-
Arc(renderer, target, x, y, outer_radius, startAngle, endAngle, color);
397
+
Arc(renderer, target, x, y, outer_radius, start_angle, end_angle, color);
398
398
399
-
dx3 = inner_radius*cos(startAngle*RADPERDEG);
400
-
dy3 = inner_radius*sin(startAngle*RADPERDEG);
401
-
dx4 = outer_radius*cos(startAngle*RADPERDEG);
402
-
dy4 = outer_radius*sin(startAngle*RADPERDEG);
399
+
dx3 = inner_radius*cos(start_angle*RADPERDEG);
400
+
dy3 = inner_radius*sin(start_angle*RADPERDEG);
401
+
dx4 = outer_radius*cos(start_angle*RADPERDEG);
402
+
dy4 = outer_radius*sin(start_angle*RADPERDEG);
403
403
Line(renderer, target, x+dx3, y+dy3, x+dx4, y+dy4, color);
404
404
}
405
405
406
-
static void SectorFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color)
406
+
static void SectorFilled(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
407
407
{
408
408
if(inner_radius < 0.0f)
409
409
inner_radius = 0.0f;
···
419
419
420
420
if(inner_radius == outer_radius)
421
421
{
422
-
Arc(renderer, target, x, y, inner_radius, startAngle, endAngle, color);
422
+
Arc(renderer, target, x, y, inner_radius, start_angle, end_angle, color);
423
423
return;
424
424
}
425
425
426
426
427
-
if(startAngle > endAngle)
427
+
if(start_angle > end_angle)
428
428
{
429
-
float swapa = endAngle;
430
-
endAngle = startAngle;
431
-
startAngle = swapa;
429
+
float swapa = end_angle;
430
+
end_angle = start_angle;
431
+
start_angle = swapa;
432
432
}
433
-
if(startAngle == endAngle)
433
+
if(start_angle == end_angle)
434
434
return;
435
435
436
-
if(endAngle - startAngle >= 360)
437
-
endAngle = startAngle + 360;
436
+
if(end_angle - start_angle >= 360)
437
+
end_angle = start_angle + 360;
438
438
439
439
440
-
float t = startAngle;
441
-
float dt = ((endAngle - startAngle)/360)*(1.25f/sqrtf(outer_radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
440
+
float t = start_angle;
441
+
float dt = ((end_angle - start_angle)/360)*(1.25f/sqrtf(outer_radius)) * DEGPERRAD; // s = rA, so dA = ds/r. ds of 1.25*sqrt(radius) is good, use A in degrees.
442
442
float dx, dy;
443
443
444
-
int numSegments = fabs(endAngle - startAngle)/dt;
444
+
int numSegments = fabs(end_angle - start_angle)/dt;
445
445
if(numSegments == 0)
446
446
return;
447
447
···
485
485
}
486
486
487
487
// Last quad
488
-
t = endAngle;
488
+
t = end_angle;
489
489
if(use_inner)
490
490
{
491
491
dx = inner_radius*cos(t*RADPERDEG);
+16
-16
SDL_gpu/SDL_gpu.h
+16
-16
SDL_gpu/SDL_gpu.h
···
677
677
void (*Line)(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, SDL_Color color);
678
678
679
679
/*! \see GPU_Arc() */
680
-
void (*Arc)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color);
680
+
void (*Arc)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);
681
681
682
682
/*! \see GPU_ArcFilled() */
683
-
void (*ArcFilled)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color);
683
+
void (*ArcFilled)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);
684
684
685
685
/*! \see GPU_Circle() */
686
686
void (*Circle)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
···
689
689
void (*CircleFilled)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float radius, SDL_Color color);
690
690
691
691
/*! \see GPU_Sector() */
692
-
void (*Sector)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color);
692
+
void (*Sector)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);
693
693
694
694
/*! \see GPU_SectorFilled() */
695
-
void (*SectorFilled)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color);
695
+
void (*SectorFilled)(GPU_Renderer* renderer, GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);
696
696
697
697
/*! \see GPU_Tri() */
698
698
void (*Tri)(GPU_Renderer* renderer, GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color);
···
1200
1200
* \param x x-coord of center point
1201
1201
* \param y y-coord of center point
1202
1202
* \param radius The radius of the circle / distance from the center point that rendering will occur
1203
-
* \param startAngle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1204
-
* \param endAngle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1203
+
* \param start_angle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1204
+
* \param end_angle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1205
1205
* \param color The color of the shape to render
1206
1206
*/
1207
-
void GPU_Arc(GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color);
1207
+
void GPU_Arc(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);
1208
1208
1209
1209
/*! Renders a colored filled arc (circle segment / pie piece).
1210
1210
* \param target The destination render target
1211
1211
* \param x x-coord of center point
1212
1212
* \param y y-coord of center point
1213
1213
* \param radius The radius of the circle / distance from the center point that rendering will occur
1214
-
* \param startAngle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1215
-
* \param endAngle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1214
+
* \param start_angle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1215
+
* \param end_angle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1216
1216
* \param color The color of the shape to render
1217
1217
*/
1218
-
void GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color);
1218
+
void GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color);
1219
1219
1220
1220
/*! Renders a colored circle outline.
1221
1221
* \param target The destination render target
···
1241
1241
* \param y y-coord of center point
1242
1242
* \param inner_radius The inner radius of the ring
1243
1243
* \param outer_radius The outer radius of the ring
1244
-
* \param startAngle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1245
-
* \param endAngle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1244
+
* \param start_angle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1245
+
* \param end_angle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1246
1246
* \param color The color of the shape to render
1247
1247
*/
1248
-
void GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color);
1248
+
void GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);
1249
1249
1250
1250
/*! Renders a colored filled annular sector (ring segment).
1251
1251
* \param target The destination render target
···
1253
1253
* \param y y-coord of center point
1254
1254
* \param inner_radius The inner radius of the ring
1255
1255
* \param outer_radius The outer radius of the ring
1256
-
* \param startAngle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1257
-
* \param endAngle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1256
+
* \param start_angle The angle to start from, in degrees. Measured clockwise from the positive x-axis.
1257
+
* \param end_angle The angle to end at, in degrees. Measured clockwise from the positive x-axis.
1258
1258
* \param color The color of the shape to render
1259
1259
*/
1260
-
void GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color);
1260
+
void GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color);
1261
1261
1262
1262
/*! Renders a colored triangle outline.
1263
1263
* \param target The destination render target
+8
-8
SDL_gpu/SDL_gpuShapes.c
+8
-8
SDL_gpu/SDL_gpuShapes.c
···
44
44
}
45
45
46
46
47
-
void GPU_Arc(GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color)
47
+
void GPU_Arc(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
48
48
{
49
49
CHECK_RENDERER();
50
50
if(renderer->Arc == NULL)
51
51
return;
52
52
53
-
renderer->Arc(renderer, target, x, y, radius, startAngle, endAngle, color);
53
+
renderer->Arc(renderer, target, x, y, radius, start_angle, end_angle, color);
54
54
}
55
55
56
56
57
-
void GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float startAngle, float endAngle, SDL_Color color)
57
+
void GPU_ArcFilled(GPU_Target* target, float x, float y, float radius, float start_angle, float end_angle, SDL_Color color)
58
58
{
59
59
CHECK_RENDERER();
60
60
if(renderer->ArcFilled == NULL)
61
61
return;
62
62
63
-
renderer->ArcFilled(renderer, target, x, y, radius, startAngle, endAngle, color);
63
+
renderer->ArcFilled(renderer, target, x, y, radius, start_angle, end_angle, color);
64
64
}
65
65
66
66
void GPU_Circle(GPU_Target* target, float x, float y, float radius, SDL_Color color)
···
81
81
renderer->CircleFilled(renderer, target, x, y, radius, color);
82
82
}
83
83
84
-
void GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color)
84
+
void GPU_Sector(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
85
85
{
86
86
CHECK_RENDERER();
87
87
if(renderer->Sector == NULL)
88
88
return;
89
89
90
-
renderer->Sector(renderer, target, x, y, inner_radius, outer_radius, startAngle, endAngle, color);
90
+
renderer->Sector(renderer, target, x, y, inner_radius, outer_radius, start_angle, end_angle, color);
91
91
}
92
92
93
-
void GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float startAngle, float endAngle, SDL_Color color)
93
+
void GPU_SectorFilled(GPU_Target* target, float x, float y, float inner_radius, float outer_radius, float start_angle, float end_angle, SDL_Color color)
94
94
{
95
95
CHECK_RENDERER();
96
96
if(renderer->SectorFilled == NULL)
97
97
return;
98
98
99
-
renderer->SectorFilled(renderer, target, x, y, inner_radius, outer_radius, startAngle, endAngle, color);
99
+
renderer->SectorFilled(renderer, target, x, y, inner_radius, outer_radius, start_angle, end_angle, color);
100
100
}
101
101
102
102
void GPU_Tri(GPU_Target* target, float x1, float y1, float x2, float y2, float x3, float y3, SDL_Color color)