Slyvtt/Shmup
Slyvtt
/
Shmup
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

major refactoring of code and project structure phase 1

This commit is contained in:
Sylvain PILLOT 2023-08-31 09:58:35 +02:00
parent 8138a5e554
commit df5fcd900d
44 changed files with 1237 additions and 581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
CMakeLists.txt
View File

@ -28,25 +28,31 @@ add_custom_command(
set(SOURCES
src/main.cpp
src/fast_trig.cpp
src/extrakeyboard.cpp
src/collections.cpp
src/impact.cpp
src/player.cpp
src/utilities.cpp
src/particles.cpp
src/bullet.cpp
src/enemy.cpp
src/starfieldshader.cpp
src/background.cpp
src/bonus.cpp
src/boss.cpp
src/point2D.cpp
src/trajectory.cpp
src/utilities/fast_trig.cpp
src/utilities/extrakeyboard.cpp
src/utilities/utilities.cpp
src/utilities/vector2D.cpp
src/shaders/circle.cpp
src/shaders/poly.cpp
src/shaders/filledcircle.cpp
src/shaders/filledpoly.cpp
src/shaders/line.cpp
src/shaders/starfieldshader.cpp
src/shmup/collections.cpp
src/shmup/impact.cpp
src/shmup/player.cpp
src/shmup/particles.cpp
src/shmup/bullet.cpp
src/shmup/enemy.cpp
src/shmup/background.cpp
src/shmup/bonus.cpp
src/shmup/boss.cpp
src/shmup/trajectory.cpp
# ...
)
set(ASSETS_cg

BIN
assets-cg/__pycache__/converters.cpython-310.pyc
View File

Binary file not shown.

16
src/MyAzurShaders.h
View File

@ -1,16 +0,0 @@
#ifndef MYAZURSHADERS_H
#define MYAZURSHADERS_H
#include <vector>
#define SHOW_PIXELS 1
#define SHOW_STARS 2
void azrp_starfield( void );
void azrp_starfield_init( uint8_t nbstars );
void azrp_starfield_close( void );
void azrp_tilesmap( int shifttile, int *tilemap, bopti_image_t *image, int tileset_size );
#endif //MYAZURSHADERS_H

94
src/fast_trig.cpp
View File

@ -1,94 +0,0 @@
#include "fast_trig.h"
#include "num/num.h"
static libnum::num cosTable[360];
static libnum::num sinTable[360];
static bool is_fast_trig_initialised = false;
void Fast_Trig_Init( void )
{
for(int u=0; u<360; u++)
{
cosTable[u] = libnum::num( cos( u * PI / 180 ) );
sinTable[u] = libnum::num( sin( u * PI / 180 ) );
}
is_fast_trig_initialised = true;
}
libnum::num FastCosInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
if (angle>=0 and angle<360) return cosTable[ angle ];
else
{
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
return cosTable[ input ];
}
else
{
while (input>=360) input-=360;
return cosTable[ input ];
}
}
}
libnum::num FastSinInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
if (angle>=0 and angle<360) return sinTable[ angle ];
else
{
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
return sinTable[ input ];
}
else
{
while (input>=360) input-=360;
return sinTable[ input ];
}
}
}
libnum::num FastTanInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
}
else if (input>=360)
{
while (input>=360) input-=360;
}
libnum::num value;
if (input==90)
{
value.v = INT32_MAX;
return value;
}
else if (input==270)
{
value.v = INT32_MIN;
return value;
}
else
{
value = FastSinInt(input) / FastCosInt(input);
return value;
}
}

30
src/main.cpp
View File

@ -26,23 +26,24 @@
#include <num/num.h>
#include "fast_trig.h"
#include "extrakeyboard.h"
#include "utilities/fast_trig.h"
#include "utilities/extrakeyboard.h"
#include "utilities/utilities.h"
#include "collections.h"
#include "shmup/collections.h"
#include "MyAzurShaders.h"
#include "shaders/MyAzurShaders.h"
#include "player.h"
#include "utilities.h"
#include "particles.h"
#include "bullet.h"
#include "enemy.h"
#include "bonus.h"
#include "impact.h"
#include "background.h"
#include "boss.h"
#include "trajectory.h"
#include "shmup/player.h"
#include "shmup/particles.h"
#include "shmup/bullet.h"
#include "shmup/enemy.h"
#include "shmup/bonus.h"
#include "shmup/impact.h"
#include "shmup/background.h"
#include "shmup/boss.h"
#include "shmup/trajectory.h"
#include <vector>
#include <algorithm>
@ -83,6 +84,7 @@ std::vector<Bullet*> MyEnemiesBullets;
std::vector<Enemy*> MyEnemies;
std::vector<Impact*> MyImpacts;
std::vector<Bonus*> MyBonuses;
std::vector<Trajectory*> MyTrajectories;
Background MyBackground;

21
src/point2D.cpp
View File

@ -1,21 +0,0 @@
#include "point2D.h"
Point2D::Point2D( )
{
x = libnum::num( 0 );
y = libnum::num( 0 );
}
Point2D::Point2D( int16_t _x, int16_t _y )
{
x = libnum::num( _x );
y = libnum::num( _y );
}
Point2D::~Point2D( )
{
}

19
src/point2D.h
View File

@ -1,19 +0,0 @@
#ifndef POINT2D_H
#define POINT2D_H
#include <cstdint>
#include <stdlib.h>
#include <num/num.h>
class Point2D
{
public:
libnum::num x, y;
Point2D( );
Point2D( int16_t _x, int16_t _y );
~Point2D( );
};
#endif

39
src/shaders/MyAzurShaders.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef MYAZURSHADERS_H
#define MYAZURSHADERS_H
#include <vector>
#define SHOW_PIXELS 1
#define SHOW_STARS 2
void azrp_starfield( void );
void azrp_starfield_init( uint8_t nbstars );
void azrp_starfield_close( void );
void azrp_shader_line_configure(void);
void azrp_shader_circle_configure(void);
void azrp_shader_filledcircle_configure(void);
void azrp_shader_filledpoly_configure(void);
void azrp_shader_poly_configure(void);
/* azrp_line(): Draw a line with clipping to the screen resolution between point (x1,y1) and (x2,y2) */
void azrp_line( int x1, int y1, int x2, int y2, uint16_t color );
/* azrp_circle() : Draw a circle with clipping to the screen resolution with a center (xc,yc) and a radius rad */
void azrp_circle( int xc, int yx, uint16_t rad, uint16_t color );
/* azrp_filledcircle() : Draw a filled circle with clipping to the screen resolution with a center (xc,yc) and a radius rad */
void azrp_filledcircle( int xc, int yx, uint16_t rad, uint16_t color );
/* azrp_poly() : Draw a polygon with clipping*/
void azrp_poly(int *x, int *y, int nb_vertices, uint16_t color);
/* azrp_filledpoly() : Draw a filled polygon with clipping*/
void azrp_filledpoly(int *x, int *y, int nb_vertices, uint16_t color);
#endif //MYAZURSHADERS_H

147
src/shaders/circle.cpp Normal file
View File

@ -0,0 +1,147 @@
#include <azur/gint/render.h>
uint8_t AZRP_SHADER_CIRCLE = -1;
static void azrp_shader_circle_configure(void)
{
azrp_set_uniforms(AZRP_SHADER_CIRCLE, (void *)azrp_width);
}
__attribute__((constructor))
static void register_shader(void)
{
extern azrp_shader_t azrp_shader_circle;
AZRP_SHADER_CIRCLE = azrp_register_shader(azrp_shader_circle, azrp_shader_circle_configure);
}
static int min(int x, int y)
{
return (x < y) ? x : y;
}
static int max(int x, int y)
{
return (x > y) ? x : y;
}
//---
#define TABLE_WIDTH 256
struct command {
uint8_t shader_id;
uint16_t color;
uint8_t curr_frag;
uint16_t NbPixels[14]; // Nunmber of pixels in each fragment
uint16_t DataPixelsX[14*TABLE_WIDTH]; // 14 fragments each able to store as much pixels as width
uint16_t DataPixelsY[14*TABLE_WIDTH]; // 14 fragments each able to store as much pixels as width
};
void AddPixelCircle( int16_t xp, int16_t yp, struct command *cmd )
{
if (xp >= 0 && xp < azrp_width && yp >= 0 && yp < azrp_height)
{
uint8_t cfrag = yp / azrp_frag_height;
uint16_t nbpixinfrag = cmd->NbPixels[ cfrag ];
uint16_t index = cfrag * TABLE_WIDTH + nbpixinfrag;
cmd->DataPixelsX[ index ] = xp;
cmd->DataPixelsY[ index ] = yp & 15;
cmd->NbPixels[ cfrag ]++;
}
}
void azrp_circle(int xc, int yc, uint16_t rad, uint16_t color)
{
prof_enter(azrp_perf_cmdgen);
int xmin = xc - rad;
int xmax = xc + rad;
int ymin = yc - rad;
int ymax = yc + rad;
// The circle is fully outside the screen
if ((xmax < 0) || (xmin >= azrp_width) || (ymax < 0) || (ymin >= azrp_height))
{
prof_leave(azrp_perf_cmdgen);
return;
}
int ytop = max( ymin, 0 );
int ybot = min( ymax, azrp_height-1 );
int frag_first = ytop / azrp_frag_height;
int frag_last = ybot / azrp_frag_height;
int frag_count = frag_last - frag_first + 1;
struct command *cmd = (struct command *) azrp_new_command(sizeof *cmd, frag_first, frag_count);
if(!cmd) {
prof_leave(azrp_perf_cmdgen);
return;
}
cmd->shader_id = AZRP_SHADER_CIRCLE;
cmd->color = color;
cmd->curr_frag = frag_first;
// reset the point counters in each cell of the table
for( int i = 0; i < 14; i++ )
cmd->NbPixels[i]=0;
int x = 0;
int y = rad;
int m = 5 - 4*rad;
while (x <= y)
{
AddPixelCircle( xc+x, yc+y, cmd );
AddPixelCircle( xc+y, yc+x, cmd );
AddPixelCircle( xc-x, yc+y, cmd );
AddPixelCircle( xc-y, yc+x, cmd );
AddPixelCircle( xc+x, yc-y, cmd );
AddPixelCircle( xc+y, yc-x, cmd );
AddPixelCircle( xc-x, yc-y, cmd );
AddPixelCircle( xc-y, yc-x, cmd );
if (m > 0)
{
y--;
m -= 8*y;
}
x++;
m += 8*x + 4;
}
prof_leave(azrp_perf_cmdgen);
}
void azrp_shader_circle( void *uniforms, void *comnd, void *fragment )
{
struct command *cmd = (struct command *) comnd;
uint16_t *frag = (uint16_t *) fragment;
uint16_t *taille = (uint16_t *) cmd->NbPixels;
uint16_t *DX = (uint16_t *) cmd->DataPixelsX;
uint16_t *DY = (uint16_t *) cmd->DataPixelsY;
uint16_t nbpix = taille[ cmd->curr_frag ];
int BaseAdress = cmd->curr_frag * TABLE_WIDTH;
for( int i = 0; i < nbpix; i++ )
{
uint16_t X = DX[ BaseAdress + i ];
uint16_t Y = DY[ BaseAdress + i ];
frag[ azrp_width * Y + X ] = cmd->color;
}
cmd->curr_frag++;
}

124
src/shaders/filledcircle.cpp Normal file
View File

@ -0,0 +1,124 @@
#include <azur/gint/render.h>
uint8_t AZRP_SHADER_FILLEDCIRCLE = -1;
static void azrp_shader_filledcircle_configure(void) {
azrp_set_uniforms(AZRP_SHADER_FILLEDCIRCLE, (void *)azrp_width);
}
__attribute__((constructor)) static void register_shader(void) {
extern azrp_shader_t azrp_shader_filledcircle;
AZRP_SHADER_FILLEDCIRCLE = azrp_register_shader(azrp_shader_filledcircle, azrp_shader_filledcircle_configure);
}
static int min(int x, int y) { return (x < y) ? x : y; }
static int max(int x, int y) { return (x > y) ? x : y; }
//---
#define TABLE_WIDTH
struct command {
uint8_t shader_id;
uint16_t color;
uint8_t curr_frag;
int16_t DataFilling[2 * 224]; // Each line of the screen can have a xmin and
// a xmax value
};
void AddPixelFilledCircle(int16_t xpmin, int16_t xpmax, int16_t yp,
struct command *cmd) {
if (yp >= 0 && yp < azrp_height) {
if (xpmin >= 0)
cmd->DataFilling[2 * yp] = xpmin;
else
cmd->DataFilling[2 * yp] = 0;
if (xpmax < azrp_width)
cmd->DataFilling[2 * yp + 1] = xpmax;
else
cmd->DataFilling[2 * yp + 1] = azrp_width - 1;
}
}
void azrp_filledcircle(int xc, int yc, uint16_t rad, uint16_t color) {
prof_enter(azrp_perf_cmdgen);
int xmin = xc - rad;
int xmax = xc + rad;
int ymin = yc - rad;
int ymax = yc + rad;
// The circle is fully outside the screen
if ((xmax < 0) || (xmin >= azrp_width) || (ymax < 0) ||
(ymin >= azrp_height)) {
prof_leave(azrp_perf_cmdgen);
return;
}
int ytop = max(ymin, 0);
int ybot = min(ymax, azrp_height - 1);
int frag_first = ytop / azrp_frag_height;
int frag_last = ybot / azrp_frag_height;
int frag_count = frag_last - frag_first + 1;
struct command *cmd = (struct command *) azrp_new_command(sizeof *cmd, frag_first, frag_count);
if(!cmd) {
prof_leave(azrp_perf_cmdgen);
return;
}
cmd->shader_id = AZRP_SHADER_FILLEDCIRCLE;
cmd->color = color;
cmd->curr_frag = frag_first;
// reset the point counters in each cell of the table
for (int i = 0; i < 224; i++) {
cmd->DataFilling[2 * i] = -1; // reset with value equels -1
cmd->DataFilling[2 * i + 1] = -1; // reset with value equals -1
}
int x = 0;
int y = rad;
int m = 5 - 4 * rad;
while (x <= y) {
AddPixelFilledCircle(xc - x, xc + x, yc - y, cmd);
AddPixelFilledCircle(xc - y, xc + y, yc - x, cmd);
AddPixelFilledCircle(xc - x, xc + x, yc + y, cmd);
AddPixelFilledCircle(xc - y, xc + y, yc + x, cmd);
if (m > 0) {
y--;
m -= 8 * y;
}
x++;
m += 8 * x + 4;
}
prof_leave(azrp_perf_cmdgen);
}
void azrp_shader_filledcircle(void *uniforms, void *comnd, void *fragment) {
struct command *cmd = (struct command *)comnd;
uint16_t *frag = (uint16_t *)fragment;
int16_t *data = (int16_t *)cmd->DataFilling;
int BaseAdress = cmd->curr_frag * azrp_frag_height * 2;
for (int i = 0; i < azrp_frag_height; i++) {
int16_t Xmin = data[BaseAdress + 2 * i];
int16_t Xmax = data[BaseAdress + 2 * i + 1];
if (Xmin != -1 && Xmax != -1)
for (int j = Xmin; j <= Xmax; j++)
frag[azrp_width * i + j] = cmd->color;
}
cmd->curr_frag++;
}

171
src/shaders/filledpoly.cpp Normal file
View File

@ -0,0 +1,171 @@
#include <azur/gint/render.h>
#include <cstdlib>
uint8_t AZRP_SHADER_FILLEDPOLY = -1;
static void azrp_shader_filledpoly_configure(void) {
azrp_set_uniforms(AZRP_SHADER_FILLEDPOLY, (void *)azrp_width);
}
__attribute__((constructor)) static void register_shader(void) {
extern azrp_shader_t azrp_shader_filledpoly;
AZRP_SHADER_FILLEDPOLY = azrp_register_shader(azrp_shader_filledpoly, azrp_shader_filledpoly_configure);
}
static int min(int x, int y) { return (x < y) ? x : y; }
static int max(int x, int y) { return (x > y) ? x : y; }
//---
#define TABLE_WIDTH
struct command {
uint8_t shader_id;
uint16_t color;
uint8_t curr_frag;
int16_t xmin[224];
int16_t xmax[224];
uint8_t empty[224];
};
void AddPixelFilledPoly(int16_t xpmin, int16_t xpmax, int16_t yp,
struct command *cmd) {
if (yp >= 0 && yp < azrp_height) {
if (xpmin >= 0)
cmd->xmin[yp] = xpmin;
else
cmd->xmin[yp] = 0;
if (xpmax < azrp_width)
cmd->xmax[yp] = xpmax;
else
cmd->xmax[yp] = azrp_width - 1;
}
}
void azrp_filledpoly(int *x, int *y, int nb_vertices, uint16_t color) {
prof_enter(azrp_perf_cmdgen);
int i, ymin, ymax, xmin2, xmax2, *xmin, *xmax;
char *empty;
if(nb_vertices < 3) {
prof_leave(azrp_perf_cmdgen);
return;
}
ymin = ymax = y[0];
xmin2 = xmax2 = x[0];
for(i=0 ; i<nb_vertices ; i++) {
if(y[i] < ymin) ymin = y[i];
if(y[i] > ymax) ymax = y[i];
if(x[i] < xmin2) xmin2 = x[i];
if(x[i] > xmax2) xmax2 = x[i];
}
// The polygon is fully outside the screen
if ((xmax2 < 0) || (xmin2 >= azrp_width) || (ymax < 0) ||
(ymin >= azrp_height)) {
prof_leave(azrp_perf_cmdgen);
return;
}
xmin = (int*) malloc((ymax-ymin+1)*sizeof(int));
xmax = (int*) malloc((ymax-ymin+1)*sizeof(int));
empty = (char*) malloc(ymax-ymin+1);
int ytop = max(ymin, 0);
int ybot = min(ymax, azrp_height - 1);
int frag_first = ytop / azrp_frag_height;
int frag_last = ybot / azrp_frag_height;
int frag_count = frag_last - frag_first + 1;
struct command *cmd = (struct command *) azrp_new_command(sizeof *cmd, frag_first, frag_count);
if(!cmd) {
prof_leave(azrp_perf_cmdgen);
return;
}
cmd->shader_id = AZRP_SHADER_FILLEDPOLY;
cmd->color = color;
cmd->curr_frag = frag_first;
// reset the point counters in each cell of the table
for (int i = 0; i < 224; i++) {
cmd->xmin[i] = -1; // reset with value equels -1
cmd->xmax[i] = -1; // reset with value equals -1
}
if(xmin && xmax && empty) {
for(i=0 ; i<ymax-ymin+1 ; i++) empty[i] = 1;
for(i=0 ; i<nb_vertices ; i++) {
int j, px, py, dx, dy, sx, sy, cumul;
px = x[i];
py = y[i];
dx = x[(i+1)%nb_vertices]-px;
dy = y[(i+1)%nb_vertices]-py;
sx = (dx > 0) ? 1 : -1;
sy = (dy > 0) ? 1 : -1;
dx = (dx > 0) ? dx : -dx;
dy = (dy > 0) ? dy : -dy;
if(empty[py-ymin]) xmax[py-ymin]=xmin[py-ymin]=px, empty[py-ymin]=0; else xmax[py-ymin]=px;
if(dx > dy) {
cumul = dx >> 1;
for(j=1 ; j<dx ; j++) {
px += sx;
cumul += dy;
if(cumul > dx) cumul -= dx, py += sy;
if(empty[py-ymin]) xmax[py-ymin]=xmin[py-ymin]=px, empty[py-ymin]=0; else xmax[py-ymin]=px;
}
} else {
cumul = dy >> 1;
for(j=1 ; j<dy ; j++) {
py += sy;
cumul += dx;
if(cumul > dy) cumul -= dy, px += sx;
if(empty[py-ymin]) xmax[py-ymin]=xmin[py-ymin]=px, empty[py-ymin]=0; else xmax[py-ymin]=px;
}
}
}
for(i=0 ; i<ymax-ymin+1 ; i++)
AddPixelFilledPoly(xmin[i], xmax[i], ymin+i, cmd);
}
free(xmin);
free(xmax);
free(empty);
prof_leave(azrp_perf_cmdgen);
}
void azrp_shader_filledpoly(void *uniforms, void *comnd, void *fragment) {
struct command *cmd = (struct command *)comnd;
uint16_t *frag = (uint16_t *)fragment;
int16_t *Xmindata = (int16_t *)cmd->xmin;
int16_t *Xmaxdata = (int16_t *)cmd->xmax;
int BaseAdress = cmd->curr_frag * azrp_frag_height;
for (int i = 0; i < azrp_frag_height; i++)
{
int16_t Xmin = Xmindata[BaseAdress + i];
int16_t Xmax = Xmaxdata[BaseAdress + i];
if (Xmin != -1 && Xmax != -1)
{
if (Xmin<=Xmax)
for (int j = Xmin; j <= Xmax; j++) frag[azrp_width * i + j] = cmd->color;
else
for (int j = Xmax; j <= Xmin; j++) frag[azrp_width * i + j] = cmd->color;
}
}
cmd->curr_frag++;
}

211
src/shaders/line.cpp Normal file
View File

@ -0,0 +1,211 @@
#include <azur/gint/render.h>
uint8_t AZRP_SHADER_LINE = -1;
static void azrp_shader_line_configure(void)
{
azrp_set_uniforms(AZRP_SHADER_LINE, (void *)azrp_width);
}
__attribute__((constructor))
static void register_shader(void)
{
extern azrp_shader_t azrp_shader_line;
AZRP_SHADER_LINE = azrp_register_shader(azrp_shader_line, azrp_shader_line_configure );
}
//---
struct command {
uint8_t shader_id;
uint16_t color;
uint16_t curr_y;
uint16_t curr_x;
int16_t dx, dy, sx, sy;
int16_t cumul;
int16_t i;
};
int ABS( int x1 )
{
if (x1 >= 0) return x1;
else return (-1 * x1);
}
int SGN( int x1 )
{
if (x1 > 0) return 1;
else if (x1 == 0) return 0;
else return -1;
}
void azrp_line(int xA, int yA, int xB, int yB, uint16_t color)
{
prof_enter(azrp_perf_cmdgen);
//clipping algorithm as per "Another Simple but Faster Method for 2D Line Clipping"
//from Dimitrios Matthes and Vasileios Drakopoulos
//International Journal of Computer Graphics & Animation (IJCGA) Vol.9, No.1/2/3, July 2019
int xmin = 0;
int xmax = azrp_width-1;
int ymin = 0;
int ymax = azrp_height-1;
//step 1 line are fully out of the screen
if ((xA<xmin && xB<xmin) || (xA>xmax && xB>xmax) || (yA<ymin && yB<ymin) || (yA>ymax && yB>ymax)) {
prof_leave(azrp_perf_cmdgen);
return;
}
int x1, x2, y1, y2;
// step 1.5 - specific to Azur fragment approach
// we swap to always start with the point on top as the fragment are updated from top to bottom
// (x1,y1) is the most top point and (x2,y2) is the most bottom point (rankig as per y values only
if (yA <= yB) {
x1 = xA; y1 = yA;
x2 = xB; y2 = yB;
}
else {
x1 = xB; y1 = yB;
x2 = xA; y2 = yA;
}
//step 2 line clipping within the box (xmin,ymin) --> (xmax,ymax)
int x[2];
int y[2];
x[0] = x1; x[1] = x2;
y[0] = y1; y[1] = y2;
for(int i=0; i<2; i++) {
if (x[i] < xmin) {
x[i] = xmin; y[i] = ((y2-y1) * (xmin-x1)) / (x2-x1) + y1;
}
else if (x[i] > xmax) {
x[i] = xmax; y[i] = ((y2-y1) * (xmax-x1)) / (x2-x1) + y1;
}
if (y[i] < ymin) {
x[i] = ((x2-x1) * (ymin-y1)) / (y2-y1) + x1; y[i] = ymin;
}
else if (y[i] > ymax) {
x[i] = ((x2-x1) * (ymax-y1)) / (y2-y1) + x1; y[i] = ymax;
}
}
if((x[0] < xmin && x[1] < xmin) || (x[0] > xmax && x[1] > xmax)) {
prof_leave(azrp_perf_cmdgen);
return;
}
x1 = x[0];
y1 = y[0];
x2 = x[1];
y2 = y[1];
int frag_first = y1 / azrp_frag_height;
int frag_last = y2 / azrp_frag_height;
int frag_count = frag_last - frag_first + 1;
struct command *cmd = (struct command *) azrp_new_command(sizeof *cmd, frag_first, frag_count);
if(!cmd) {
prof_leave(azrp_perf_cmdgen);
return;
}
cmd->shader_id = AZRP_SHADER_LINE;
cmd->color = color;
cmd->curr_x = x1;
cmd->curr_y = y1 & 15;
cmd->dx = ABS(x2-x1);
cmd->sx = SGN(x2-x1);
cmd->dy = ABS(y2-y1);
cmd->sy = SGN(y2-y1);
cmd->i = 0;
cmd->cumul = (cmd->dx >= cmd->dy) ? cmd->dx/2 : cmd->dy/2;
prof_leave(azrp_perf_cmdgen);
}
void azrp_shader_line( void *uniforms, void *comnd, void *fragment )
{
struct command *cmd = (struct command *) comnd;
uint16_t *frag = (uint16_t *) fragment;
frag[ azrp_width * cmd->curr_y + cmd->curr_x ] = cmd->color;
int i;
if (cmd->dy == 0)
{
for( i = cmd->i; i < cmd->dx ; i++ )
{
cmd->curr_x += cmd->sx;
frag[ azrp_width * cmd->curr_y + cmd->curr_x ] = cmd->color;
}
}
else if (cmd->dx == 0)
{
for( i = cmd->i; i < cmd->dy ; i++ )
{
cmd->curr_y += cmd->sy;
// if curr_y=16, this means we are changing to next fragment
if (cmd->curr_y == azrp_frag_height) break;
frag[ azrp_width * cmd->curr_y + cmd->curr_x ] = cmd->color;
}
}
else if (cmd->dx >= cmd->dy)
{
for( i = cmd->i; i < cmd->dx; i++ )
{
cmd->curr_x += cmd->sx;
cmd->cumul += cmd->dy;
if (cmd->cumul > cmd->dx)
{
cmd->cumul -= cmd->dx;
cmd->curr_y += cmd->sy;
}
// if curr_y=16, this means we are changing to next fragment
if (cmd->curr_y == azrp_frag_height ) break;
frag[ azrp_width * cmd->curr_y + cmd->curr_x ] = cmd->color;
}
}
else
{
for( i = cmd->i; i < cmd->dy; i++ )
{
cmd->curr_y += cmd->sy;
cmd->cumul += cmd->dx;
if (cmd->cumul > cmd->dy)
{
cmd->cumul -= cmd->dy;
cmd->curr_x += cmd->sx;
}
// if curr_y=16, this means we are changing to next fragment
if (cmd->curr_y == azrp_frag_height) break;
frag[ azrp_width * cmd->curr_y + cmd->curr_x ] = cmd->color;
}
}
cmd->curr_y = cmd->curr_y & 15;
cmd->i = i+1;
}

16
src/shaders/poly.cpp Normal file
View File

@ -0,0 +1,16 @@
#include <azur/gint/render.h>
#include "MyAzurShaders.h"
void azrp_poly(int *x, int *y, int nb_vertices, uint16_t color) {
prof_enter(azrp_perf_cmdgen);
for( int i=0 ; i<nb_vertices ; i++) {
int px = x[i];
int py = y[i];
int px2 = x[(i+1)%nb_vertices];
int py2 = y[(i+1)%nb_vertices];
azrp_line( px, py, px2, py2, color );
}
prof_leave(azrp_perf_cmdgen);
}

2
src/starfieldshader.cpp → src/shaders/starfieldshader.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include <azur/gint/render.h>
#include "MyAzurShaders.h"

2
src/background.cpp → src/shmup/background.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "background.h"
#include <azur/azur.h>

0
src/background.h → src/shmup/background.h
View File

4
src/bonus.cpp → src/shmup/bonus.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "bonus.h"
#include <num/num.h>
@ -43,7 +43,7 @@ Bonus::Bonus( int16_t _x, int16_t _y, uint8_t _id )
Bonus::~Bonus()
{
if (hasTrajectory)
delete(pathToFollow);
pathToFollow->DeleteRegistry();
}
void Bonus::Update( float dt )

0
src/bonus.h → src/shmup/bonus.h
View File

8
src/boss.cpp → src/shmup/boss.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "boss.h"
#include "bullet.h"
@ -6,13 +6,13 @@
#include <num/num.h>
#include <gint/rtc.h>
#include <sys/types.h>
#include "fast_trig.h"
#include "../utilities/fast_trig.h"
#include <gint/gint.h>
#include "collections.h"
#include "player.h"
#include "vector2D.h"
#include "../utilities/vector2D.h"
extern bopti_image_t img_Lifebar;
extern bopti_image_t img_Boss1;
@ -163,7 +163,7 @@ Boss::Boss( int16_t _x, int16_t _y, uint8_t _id )
Boss::~Boss()
{
if (hasTrajectory)
delete(pathToFollow);
pathToFollow->DeleteRegistry();
}

0
src/boss.h → src/shmup/boss.h
View File

2
src/bullet.cpp → src/shmup/bullet.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "bullet.h"

0
src/bullet.h → src/shmup/bullet.h
View File

58
src/collections.cpp → src/shmup/collections.cpp
View File

@ -1,19 +1,18 @@
#include "config.h"
#include "../config.h"
#include "collections.h"
#include "trajectory.h"
#include <vector>
#include <gint/rtc.h>
extern std::vector<Particle*> MyParticles;
extern std::vector<Bullet*> MyPlayerBullets;
extern std::vector<Bullet*> MyEnemiesBullets;
extern std::vector<Enemy*> MyEnemies;
extern std::vector<Impact*> MyImpacts;
extern std::vector<Trajectory*> MyTrajectories;
extern Player *MyPlayer;
@ -50,6 +49,7 @@ void Create_Player_Shoot( uint8_t id )
void Create_Enemies( void )
{
/*
Enemy* e1 = new Enemy( 348, 112, 0);
e1->Set_Speed_Vector( 1, 1, -6 );
MyEnemies.push_back( e1 );
@ -65,42 +65,45 @@ void Create_Enemies( void )
Enemy* e4 = new Enemy( 348, 112, 1);
e4->Set_Speed_Vector( 1, 3, 3 );
MyEnemies.push_back( e4 );
*/
Point2D *A = new Point2D( 348, 112 );
Point2D *B = new Point2D( 371, 199 );
Point2D *C = new Point2D( 198, 149 );
Point2D *D = new Point2D( 25, 199 );
Point2D *E = new Point2D( 25, 25 );
Point2D *F = new Point2D( 198, 75 );
Point2D *G = new Point2D( 371, 25 );
Vector2D *A = new Vector2D( 348, 112 );
Vector2D *B = new Vector2D( 371, 199 );
Vector2D *C = new Vector2D( 198, 149 );
Vector2D *D = new Vector2D( 25, 199 );
Vector2D *E = new Vector2D( 25, 25 );
Vector2D *F = new Vector2D( 198, 75 );
Vector2D *G = new Vector2D( 371, 25 );
Trajectory *MyTrajectory= new Trajectory();
MyTrajectory->AddPoint( A );
MyTrajectory->AddPoint( B );
MyTrajectory->AddPoint( C );
MyTrajectory->AddPoint( D );
MyTrajectory->AddPoint( E );
MyTrajectory->AddPoint( F );
MyTrajectory->AddPoint( G );
Trajectory *MyPath= new Trajectory();
MyPath->AddPoint( A );
MyPath->AddPoint( B );
MyPath->AddPoint( C );
MyPath->AddPoint( D );
MyPath->AddPoint( E );
MyPath->AddPoint( F );
MyPath->AddPoint( G );
MyTrajectories.push_back( MyPath );
Enemy* e5 = new Enemy( 348, 112, 2);
e5->hasTrajectory = true;
e5->pathToFollow = MyTrajectory;
e5->pathToFollow = MyPath;
MyPath->AddRegistry();
e5->Set_Accumulated_Time(0.0f);
Enemy* e6 = new Enemy( 348, 112, 2);
e6->hasTrajectory = true;
e6->pathToFollow = MyTrajectory;
e6->pathToFollow = MyPath;
MyPath->AddRegistry();
e6->Set_Accumulated_Time(-1.0f);
Enemy* e7 = new Enemy( 348, 112, 2);
e7->hasTrajectory = true;
e7->pathToFollow = MyTrajectory;
e7->pathToFollow = MyPath;
MyPath->AddRegistry();
e7->Set_Accumulated_Time(-2.0f);
@ -167,6 +170,13 @@ void Clean_Everything( void )
}
MyImpacts.clear();
for(unsigned int i=0; i<MyTrajectories.size(); i++)
{
delete( MyTrajectories[i] );
MyTrajectories.erase( MyTrajectories.begin() + i );
}
MyTrajectories.clear();
}

4
src/collections.h → src/shmup/collections.h
View File

@ -3,11 +3,11 @@
#include "player.h"
#include "utilities.h"
#include "../utilities/utilities.h"
#include "particles.h"
#include "bullet.h"
#include "enemy.h"
#include "MyAzurShaders.h"
#include "../shaders/MyAzurShaders.h"
#include "impact.h"
#include "trajectory.h"

4
src/enemy.cpp → src/shmup/enemy.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "enemy.h"
#include "bullet.h"
@ -62,7 +62,7 @@ Enemy::Enemy( int16_t _x, int16_t _y, uint8_t _id )
Enemy::~Enemy()
{
if (hasTrajectory)
delete(pathToFollow);
pathToFollow->DeleteRegistry();
}
void Enemy::Update( float dt )

0
src/enemy.h → src/shmup/enemy.h
View File

2
src/impact.cpp → src/shmup/impact.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "impact.h"

0
src/impact.h → src/shmup/impact.h
View File

2
src/particles.cpp → src/shmup/particles.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "particles.h"

0
src/particles.h → src/shmup/particles.h
View File

4
src/player.cpp → src/shmup/player.cpp
View File

@ -1,11 +1,11 @@
#include "config.h"
#include "../config.h"
#include "player.h"
#include "bullet.h"
#include "enemy.h"
#include <num/num.h>
#include <gint/rtc.h>
#include "fast_trig.h"
#include "../utilities/fast_trig.h"
#include "background.h"

0
src/player.h → src/shmup/player.h
View File

23
src/trajectory.cpp → src/shmup/trajectory.cpp
View File

@ -1,28 +1,39 @@
#include "config.h"
#include "../config.h"
#include "trajectory.h"
Trajectory::Trajectory( )
{
registration = 0;
//accumulatedTime = 0.0f;
}
Trajectory::~Trajectory( )
{
for( auto& p : ControlPoints )
delete( p );
ControlPoints.clear();
for( auto& p : ControlPoints )
delete( p );
ControlPoints.clear();
}
void Trajectory::AddPoint( Point2D *p )
void Trajectory::AddPoint( Vector2D *p )
{
ControlPoints.push_back( p );
}
void Trajectory::AddRegistry( void )
{
registration++;
}
void Trajectory::DeleteRegistry( void )
{
registration--;
}
void Trajectory::CalculatePosition( float *accumulatedTime, float time, uint16_t speed, bool looped, libnum::num *xreturn, libnum::num *yreturn )
{
*accumulatedTime += speed * time / 2000000.0f;

12
src/trajectory.h → src/shmup/trajectory.h
View File

@ -1,12 +1,13 @@
#ifndef TRAJECTORY_H
#define TRAJECTORY_H
#include <cstdint>
#include <stdlib.h>
#include <num/num.h>
#include <vector>
#include "point2D.h"
#include "../utilities/vector2D.h"
#include "num/num.h"
class Trajectory
@ -15,11 +16,16 @@ class Trajectory
Trajectory( );
~Trajectory( );
void AddPoint( Point2D *p );
void AddPoint( Vector2D *p );
void AddRegistry( void );
void DeleteRegistry( void );
void CalculatePosition( float *accumulatedTime, float time, uint16_t speed, bool looped, libnum::num *xreturn, libnum::num *yreturn );
std::vector<Point2D*> ControlPoints;
std::vector<Vector2D*> ControlPoints;
bool isLoop;
uint16_t registration;
//float accumulatedTime;
};

68
src/tilesmapshader.cpp
View File

@ -1,68 +0,0 @@
#include "config.h"
#include <azur/gint/render.h>
#include "MyAzurShaders.h"
#include <cstdlib>
#include <cstdio>
#include <gint/rtc.h>
uint8_t AZRP_SHADER_TILESMAP = -1;
__attribute__((constructor))
static void register_shader(void)
{
extern azrp_shader_t azrp_shader_tilesmap;
AZRP_SHADER_TILESMAP = azrp_register_shader(azrp_shader_tilesmap);
}
void azrp_shader_tilesmap_configure(void)
{
azrp_set_uniforms(AZRP_SHADER_TILESMAP, (void *)azrp_width);
}
struct command {
uint8_t shader_id;
uint8_t current_frag;
int shifttile;
int *tilemap;
bopti_image_t *image;
int tileset_size;
};
void azrp_tilesmap( int shifttile, int *tilemap, bopti_image_t *image, int tileset_size );
{
prof_enter(azrp_perf_cmdgen);
struct command cmd;
cmd.shader_id = AZRP_SHADER_TILESMAP;
cmd.current_frag = 0;
cmd.shifttile = shifttile;
cmd.tilemap = tilemap;
cmd.image = image;
cmd.tileset_size = tileset_size;
azrp_queue_command(&cmd, sizeof cmd, 0, azrp_frag_count);
prof_leave(azrp_perf_cmdgen);
}
void azrp_shader_tilesmap( void *uniforms, void *comnd, void *fragment )
{
struct command *cmd = (struct command *) comnd;
uint16_t *frag = (uint16_t *) fragment;
int currentile = cmd->tilemap[cmd->current_frag*25];
for(int u=0; u<=25;u++)
cmd->current_frag++;
}

2
src/extrakeyboard.cpp → src/utilities/extrakeyboard.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include "extrakeyboard.h"
#include <gint/keyboard.h>

0
src/extrakeyboard.h → src/utilities/extrakeyboard.h
View File

183
src/utilities/fast_trig.cpp Normal file
View File

@ -0,0 +1,183 @@
#include "fast_trig.h"
#include "num/num.h"
static libnum::num cosTable[360];
static libnum::num sinTable[360];
static bool is_fast_trig_initialised = false;
void Fast_Trig_Init( void )
{
for(int u=0; u<360; u++)
{
cosTable[u] = libnum::num( cos( u * PI / 180 ) );
sinTable[u] = libnum::num( sin( u * PI / 180 ) );
}
is_fast_trig_initialised = true;
}
libnum::num FastCosInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
if (angle>=0 and angle<360) return cosTable[ angle ];
else
{
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
return cosTable[ input ];
}
else
{
while (input>=360) input-=360;
return cosTable[ input ];
}
}
}
libnum::num FastSinInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
if (angle>=0 and angle<360) return sinTable[ angle ];
else
{
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
return sinTable[ input ];
}
else
{
while (input>=360) input-=360;
return sinTable[ input ];
}
}
}
libnum::num FastTanInt( int16_t angle )
{
if (!is_fast_trig_initialised) Fast_Trig_Init();
int16_t input = angle;
if (input<0)
{
while (input<0) input+=360;
}
else if (input>=360)
{
while (input>=360) input-=360;
}
libnum::num value;
if (input==90)
{
value.v = INT32_MAX;
return value;
}
else if (input==270)
{
value.v = INT32_MIN;
return value;
}
else
{
value = FastSinInt(input) / FastCosInt(input);
return value;
}
}
libnum::num32 sqrt_num32(libnum::num32 v) {
uint32_t t, q, b, r;
r = v.v;
b = 0x40000000;
q = 0;
while (b > 0x40) {
t = q + b;
if (r >= t) {
r -= t;
q = t + b;
}
r <<= 1;
b >>= 1;
}
q >>= 8;
libnum::num32 ret;
ret.v = q;
return ret;
}
/* TO DO : rework these functions for sine and cosine calculation */
libnum::num32 cos_num32(libnum::num32 angle) {
// Taylor serie for cos(x) = 1 - x²/2! + x⁴/4! + x⁶/6! + x⁸/8! + ...
// Cosine function is even
if (angle < libnum::num32(0))
return cos_num32(-angle);
// Look for an angle in the range [0, 2*pi [
libnum::num32 anglereduced = angle;
while (anglereduced >= libnum::num32(2 * PI))
anglereduced -= libnum::num32(2 * PI);
// Exploit the symetry for angle and angle+Pi to reduce the order of the
// limited developpement
if (anglereduced >= libnum::num(PI))
return -cos_num32(anglereduced - libnum::num(PI));
libnum::num32 sum = libnum::num32(1);
libnum::num32 angle2 = anglereduced * anglereduced;
// set first value of the Taylor serie : x⁰/0! = 1/1
libnum::num32 numerator = libnum::num32(1);
libnum::num32 denominator = libnum::num32(1);
for (int i = 2; i <= 8; i += 2) {
numerator *= (-angle2);
denominator *= libnum::num32(i - 1) * libnum::num32(i);
sum += (numerator / denominator);
}
return sum;
}
libnum::num32 sin_num32(libnum::num32 angle) {
// Taylor serie for cos(x) = x/1! - x³/3! + x⁵/5! - x⁷/7! + x⁹/9! + ...
// Sine function is odd
if (angle < libnum::num32(0))
return -sin_num32(-angle);
// Look for an angle in the range [0, 2*pi [
libnum::num32 anglereduced = angle;
while (anglereduced >= libnum::num32(2 * PI))
anglereduced -= libnum::num32(2 * PI);
// Exploit the symetry for angle and angle+Pi to reduce the order of the
// limited developpement
if (anglereduced >= libnum::num(PI))
return -sin_num32(anglereduced - libnum::num(PI));
libnum::num32 sum = anglereduced;
libnum::num32 angle2 = anglereduced * anglereduced;
// set first value of the Taylor serie : x¹/1! = x/1
libnum::num32 numerator = anglereduced;
libnum::num32 denominator = libnum::num32(1);
for (int i = 2; i <= 8; i += 2) {
numerator *= (-angle2);
denominator *= libnum::num32(i) * libnum::num32(i + 1);
sum += (numerator / denominator);
}
return sum;
}

9
src/fast_trig.h → src/utilities/fast_trig.h
View File

@ -5,9 +5,7 @@
#include <cmath>
#include <num/num.h>
#define PI 3.141592
#define PI 3.14159265
void Fast_Trig_Init( void );
@ -15,5 +13,10 @@ libnum::num FastCosInt( int16_t angle );
libnum::num FastSinInt( int16_t angle );
libnum::num FastTanInt( int16_t angle );
libnum::num32 sqrt_num32(libnum::num32 v);
libnum::num32 cos_num32(libnum::num32 angle);
libnum::num32 sin_num32(libnum::num32 angle);
#endif

2
src/utilities.cpp → src/utilities/utilities.cpp
View File

@ -1,4 +1,4 @@
#include "config.h"
#include "../config.h"
#include <azur/azur.h>
#include <azur/gint/render.h>

0
src/utilities.h → src/utilities/utilities.h
View File

111
src/utilities/vector2D.cpp Normal file
View File

@ -0,0 +1,111 @@
#include "vector2D.h"
#include "fast_trig.h"
Vector2D::Vector2D() {
this->x = libnum::num32(0);
this->y = libnum::num32(0);
}
Vector2D::Vector2D(float x, float y) {
this->x = libnum::num32(x);
this->y = libnum::num32(y);
}
Vector2D::Vector2D(libnum::num32 x, libnum::num32 y) {
this->x = x;
this->y = y;
}
Vector2D::Vector2D(const Vector2D &v) {
this->x = v.x;
this->y = v.y;
}
Vector2D::~Vector2D() {}
void Vector2D::Set(Vector2D v) {
this->x = v.x;
this->y = v.y;
}
void Vector2D::Normalise(void) {
libnum::num32 len = this->Length();
this->x /= len;
this->y /= len;
}
Vector2D Vector2D::Clone(void) {
Vector2D NewVector(this->x, this->y);
return NewVector;
}
Vector2D Vector2D::MakeVector(Vector2D A, Vector2D B) {
Vector2D NewVector(B.x - A.x, B.y - A.y);
return NewVector;
}
void Vector2D::AddVectors(Vector2D a, Vector2D b) {
this->x = a.x + b.x;
this->y = a.y + b.y;
}
void Vector2D::Add(Vector2D v, libnum::num32 scale) {
this->x += v.x * scale;
this->y += v.y * scale;
}
void Vector2D::SubtractVectors(Vector2D a, Vector2D b) {
this->x = a.x - b.x;
this->y = a.y - b.y;
}
void Vector2D::Subtract(Vector2D v, libnum::num32 scale) {
this->x -= v.x * scale;
this->y -= v.y * scale;
}
libnum::num32 Vector2D::Length(void) {
return sqrt_num32(this->x * this->x + this->y * this->y);
}
void Vector2D::Scale(libnum::num32 scale) {
this->x *= scale;
this->y *= scale;
}
libnum::num32 Vector2D::Dot(Vector2D v) { return (this->x * v.x + this->y * v.y); }
libnum::num32 Vector2D::Det(Vector2D v) { return (this->x * v.y - this->y * v.x); }
Vector2D Vector2D::PerpCW(void) {
Vector2D temp(-this->y, this->x);
return temp;
}
Vector2D Vector2D::PerpCCW(void) {
Vector2D temp(this->y, -this->x);
return temp;
}
Vector2D ClosestPointOnSegment(Vector2D P, Vector2D A, Vector2D B) {
Vector2D AB = B - A;
libnum::num32 t = AB.Dot(AB);
if (t == 0)
return A;
libnum::num32 t2 = (P.Dot(AB) - A.Dot(AB)) / t;
if (t2 < libnum::num32(0))
t2 = libnum::num32(0);
if (t2 > libnum::num32(1))
t2 = libnum::num32(1);
Vector2D C = A.Clone();
C.Add(AB, t2);
return C;
}

112
src/utilities/vector2D.h Normal file
View File

@ -0,0 +1,112 @@
#ifndef VECTOR2D_H
#define VECTOR2D_H
#include <num/num.h>
#include <stdint.h>
#include "fast_trig.h"
class Vector2D {
public:
Vector2D();
Vector2D(float x, float y);
Vector2D(libnum::num32 x, libnum::num32 y);
Vector2D(const Vector2D &v);
~Vector2D();
void Set(Vector2D v);
void Normalise(void);
Vector2D Clone(void);
Vector2D MakeVector(Vector2D A, Vector2D B);
void AddVectors(Vector2D a, Vector2D b);
void Add(Vector2D v, libnum::num32 scale);
void SubtractVectors(Vector2D a, Vector2D b);
void Subtract(Vector2D v, libnum::num32 scale);
libnum::num32 Length(void);
void Scale(libnum::num32 scale);
libnum::num32 Dot(Vector2D v);
libnum::num32 Det(Vector2D v);
Vector2D PerpCW(void);
Vector2D PerpCCW(void);
/* overloading of most interesting operators */
libnum::num32 operator[](uint8_t pos) { return pos == 0 ? x : y; }
Vector2D &operator=(const Vector2D &v) {
this->x = v.x;
this->y = v.y;
return *this;
}
Vector2D operator+(const Vector2D &v) const {
return Vector2D(x + v.x, y + v.y);
}
Vector2D operator-(const Vector2D &v) const {
return Vector2D(x - v.x, y - v.y);
}
Vector2D &operator+=(Vector2D const &other) {
this->x += other.x;
this->y += other.y;
return *this;
}
Vector2D operator-() const { return (Vector2D(-x, -y)); }
Vector2D operator+() const { return *this; }
Vector2D &operator-=(Vector2D const &other) {
this->x -= other.x;
this->y -= other.y;
return *this;
}
Vector2D &operator*=(libnum::num32 scale) {
this->x *= scale;
this->y *= scale;
return *this;
}
Vector2D &operator/=(libnum::num32 scale) {
this->x /= scale;
this->y /= scale;
return *this;
}
friend Vector2D operator*(libnum::num32 scale, Vector2D const &v) {
Vector2D r;
r.x = v.x * scale;
r.y = v.y * scale;
return r;
}
friend Vector2D operator*(Vector2D const &v, libnum::num32 scale) {
Vector2D r;
r.x = v.x * scale;
r.y = v.y * scale;
return r;
}
friend Vector2D operator/(Vector2D const &v, libnum::num32 scale) {
Vector2D r;
r.x = v.x / scale;
r.y = v.y / scale;
return r;
}
libnum::num32 x;
libnum::num32 y;
};
Vector2D ClosestPointOnSegment(Vector2D P, Vector2D A, Vector2D B);
#endif

278
src/vector2D.h
View File

@ -1,278 +0,0 @@
#ifndef VECTOR2D_H
#define VECTOR2D_H
#include <num/num.h>
#include <stdint.h>
#define numPI 3.14159265
libnum::num32 sqrt_num32(libnum::num32 v) {
uint32_t t, q, b, r;
r = v.v;
b = 0x40000000;
q = 0;
while (b > 0x40) {
t = q + b;
if (r >= t) {
r -= t;
q = t + b;
}
r <<= 1;
b >>= 1;
}
q >>= 8;
libnum::num32 ret;
ret.v = q;
return ret;
}
/* TO DO : rework these functions for sine and cosine calculation */
libnum::num32 cos_num32(libnum::num32 angle) {
// Taylor serie for cos(x) = 1 - x²/2! + x⁴/4! + x⁶/6! + x⁸/8! + ...
// Cosine function is even
if (angle < libnum::num32(0))
return cos_num32(-angle);
// Look for an angle in the range [0, 2*pi [
libnum::num32 anglereduced = angle;
while (anglereduced >= libnum::num32(2 * numPI))
anglereduced -= libnum::num32(2 * numPI);
// Exploit the symetry for angle and angle+Pi to reduce the order of the
// limited developpement
if (anglereduced >= libnum::num(numPI))
return -cos_num32(anglereduced - libnum::num(numPI));
libnum::num32 sum = libnum::num32(1);
libnum::num32 angle2 = anglereduced * anglereduced;
// set first value of the Taylor serie : x⁰/0! = 1/1
libnum::num32 numerator = libnum::num32(1);
libnum::num32 denominator = libnum::num32(1);
for (int i = 2; i <= 8; i += 2) {
numerator *= (-angle2);
denominator *= libnum::num32(i - 1) * libnum::num32(i);
sum += (numerator / denominator);
}
return sum;
}
libnum::num32 sin_num32(libnum::num32 angle) {
// Taylor serie for cos(x) = x/1! - x³/3! + x⁵/5! - x⁷/7! + x⁹/9! + ...
// Sine function is odd
if (angle < libnum::num32(0))
return -sin_num32(-angle);
// Look for an angle in the range [0, 2*pi [
libnum::num32 anglereduced = angle;
while (anglereduced >= libnum::num32(2 * numPI))
anglereduced -= libnum::num32(2 * numPI);
// Exploit the symetry for angle and angle+Pi to reduce the order of the
// limited developpement
if (anglereduced >= libnum::num(numPI))
return -sin_num32(anglereduced - libnum::num(numPI));
libnum::num32 sum = anglereduced;
libnum::num32 angle2 = anglereduced * anglereduced;
// set first value of the Taylor serie : x¹/1! = x/1
libnum::num32 numerator = anglereduced;
libnum::num32 denominator = libnum::num32(1);
for (int i = 2; i <= 8; i += 2) {
numerator *= (-angle2);
denominator *= libnum::num32(i) * libnum::num32(i + 1);
sum += (numerator / denominator);
}
return sum;
}
class Vector2D {
public:
Vector2D() {
this->x = libnum::num32(0);
this->y = libnum::num32(0);
}
Vector2D(float x, float y) {
this->x = libnum::num32(x);
this->y = libnum::num32(y);
}
Vector2D(libnum::num32 x, libnum::num32 y) {
this->x = x;
this->y = y;
}
Vector2D(const Vector2D &v) {
this->x = v.x;
this->y = v.y;
}
~Vector2D() {}
void Set(Vector2D v) {
this->x = v.x;
this->y = v.y;
}
void Normalise(void) {
libnum::num32 len = this->Length();
this->x /= len;
this->y /= len;
}
Vector2D Clone(void) {
Vector2D NewVector(this->x, this->y);
return NewVector;
}
Vector2D MakeVector(Vector2D A, Vector2D B) {
Vector2D NewVector(B.x - A.x, B.y - A.y);
return NewVector;
}
void AddVectors(Vector2D a, Vector2D b) {
this->x = a.x + b.x;
this->y = a.y + b.y;
}
void Add(Vector2D v, libnum::num32 scale) {
this->x += v.x * scale;
this->y += v.y * scale;
}
void SubtractVectors(Vector2D a, Vector2D b) {
this->x = a.x - b.x;
this->y = a.y - b.y;
}
void Subtract(Vector2D v, libnum::num32 scale) {
this->x -= v.x * scale;
this->y -= v.y * scale;
}
libnum::num32 Length(void) {
return sqrt_num32(this->x * this->x + this->y * this->y);
}
void Scale(libnum::num32 scale) {
this->x *= scale;
this->y *= scale;
}
libnum::num32 Dot(Vector2D v) { return (this->x * v.x + this->y * v.y); }
libnum::num32 Det(Vector2D v) { return (this->x * v.y - this->y * v.x); }
Vector2D PerpCW(void) {
Vector2D temp(-this->y, this->x);
return temp;
}
Vector2D PerpCCW(void) {
Vector2D temp(this->y, -this->x);
return temp;
}
/* overloading of most interesting operators */
libnum::num32 operator[](uint8_t pos) { return pos == 0 ? x : y; }
Vector2D &operator=(const Vector2D &v) {
this->x = v.x;
this->y = v.y;
return *this;
}
Vector2D operator+(const Vector2D &v) const {
return Vector2D(x + v.x, y + v.y);
}
Vector2D operator-(const Vector2D &v) const {
return Vector2D(x - v.x, y - v.y);
}
Vector2D &operator+=(Vector2D const &other) {
this->x += other.x;
this->y += other.y;
return *this;
}
Vector2D operator-() const { return (Vector2D(-x, -y)); }
Vector2D operator+() const { return *this; }
Vector2D &operator-=(Vector2D const &other) {
this->x -= other.x;
this->y -= other.y;
return *this;
}
Vector2D &operator*=(libnum::num32 scale) {
this->x *= scale;
this->y *= scale;
return *this;
}
Vector2D &operator/=(libnum::num32 scale) {
this->x /= scale;
this->y /= scale;
return *this;
}
friend Vector2D operator*(libnum::num32 scale, Vector2D const &v) {
Vector2D r;
r.x = v.x * scale;
r.y = v.y * scale;
return r;
}
friend Vector2D operator*(Vector2D const &v, libnum::num32 scale) {
Vector2D r;
r.x = v.x * scale;
r.y = v.y * scale;
return r;
}
friend Vector2D operator/(Vector2D const &v, libnum::num32 scale) {
Vector2D r;
r.x = v.x / scale;
r.y = v.y / scale;
return r;
}
libnum::num32 x;
libnum::num32 y;
};
Vector2D ClosestPointOnSegment(Vector2D P, Vector2D A, Vector2D B) {
Vector2D AB = B - A;
libnum::num32 t = AB.Dot(AB);
if (t == 0)
return A;
libnum::num32 t2 = (P.Dot(AB) - A.Dot(AB)) / t;
if (t2 < libnum::num32(0))
t2 = libnum::num32(0);
if (t2 > libnum::num32(1))
t2 = libnum::num32(1);
Vector2D C = A.Clone();
C.Add(AB, t2);
return C;
}
#endif