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

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

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

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

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;

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( )
{
}

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

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

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

View File

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

View File

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

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 )

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

View File

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

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

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"

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 )

View File

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

View File

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

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"

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;

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

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