262 lines
8.2 KiB
C++
262 lines
8.2 KiB
C++
#include "../config.h"
|
|
|
|
#include <azur/azur.h>
|
|
#include <azur/gint/render.h>
|
|
|
|
#include "utilities.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <fxlibc/printf.h>
|
|
#include <sys/types.h>
|
|
#include "vector2D.h"
|
|
|
|
|
|
extern font_t milifont_prop;
|
|
extern font_t font_shmup;
|
|
|
|
void Azur_draw_text(int x, int y, char const *fmt, ...)
|
|
{
|
|
char str[128];
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
vsnprintf(str, 128, fmt, args);
|
|
va_end(args);
|
|
|
|
dfont( &milifont_prop );
|
|
|
|
azrp_text( x, y, C_WHITE, str );
|
|
}
|
|
|
|
void Azur_draw_text_shmup(int x, int y, char const *fmt, ...)
|
|
{
|
|
char str[128];
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
vsnprintf(str, 128, fmt, args);
|
|
va_end(args);
|
|
|
|
dfont( &font_shmup );
|
|
|
|
azrp_text( x+1, y+1, C_RED, str );
|
|
azrp_text( x, y, C_WHITE, str );
|
|
}
|
|
|
|
bool AABB_Collision( SpriteLocator image1, SpriteLocator image2 )
|
|
{
|
|
if( (image2.x >= image1.x + image1.image->width)
|
|
|| (image2.x + image2.image->width <= image1.x)
|
|
|| (image2.y >= image1.y + image1.image->height)
|
|
|| (image2.y + image2.image->height <= image1.y) )
|
|
return false;
|
|
|
|
// no need to do pixel perfect detection
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool Pixel_Perfect_Collision( SpriteLocator image1, SpriteLocator image2 )
|
|
{
|
|
if( !AABB_Collision( image1, image2 ) )
|
|
return false; // bounding boxes not overlapping, impossible to have collision
|
|
|
|
/* if we reach that point, this means that we need to perform pixel perfect collsion detection */
|
|
|
|
/* First we will calculate the corners of the zone to be tested for collision */
|
|
/* as it is not usefull to check for all the surface of the image, only the */
|
|
/* overlapping area will be verified */
|
|
|
|
|
|
|
|
/* WARNING !! */
|
|
/* P4 format is not supported yet has it is currently focused on use with Azur */
|
|
/* that is mostly P8/RGB565 oriented for ultra fast performances */
|
|
if ( IMAGE_IS_P4(image1.image->format) || IMAGE_IS_P4(image2.image->format) )
|
|
return false;
|
|
|
|
int adeltax, adeltay;
|
|
int bdeltax, bdeltay;
|
|
int rows, columns;
|
|
|
|
if (image1.x <= image2.x)
|
|
{
|
|
adeltax = image2.x - image1.x;
|
|
columns = MIN(image1.image->width - adeltax, image2.image->width);
|
|
bdeltax = 0;
|
|
}
|
|
else
|
|
{
|
|
bdeltax = image1.x - image2.x;
|
|
columns = MIN(image2.image->width - bdeltax, image1.image->width);
|
|
adeltax = 0;
|
|
}
|
|
|
|
if (image1.y <= image2.y)
|
|
{
|
|
adeltay = image2.y - image1.y;
|
|
rows = MIN(image1.image->height - adeltay, image2.image->height);
|
|
bdeltay = 0;
|
|
}
|
|
else
|
|
{
|
|
bdeltay = image1.y - image2.y;
|
|
rows = MIN(image2.image->height - bdeltay, image1.image->height);
|
|
adeltay = 0;
|
|
}
|
|
|
|
/* if BOTH images are in a 16bits color format, we will not use masks and will quicken the process */
|
|
if ( IMAGE_IS_RGB16(image1.image->format) && IMAGE_IS_RGB16(image2.image->format) )
|
|
{
|
|
void *data1 = image1.image->data + adeltay * image1.image->stride;
|
|
void *data2 = image2.image->data + bdeltay * image2.image->stride;
|
|
|
|
uint16_t *data_u16_1 = (uint16_t *) data1;
|
|
uint16_t *data_u16_2 = (uint16_t *) data2;
|
|
|
|
int transp1 = image_alpha(image1.image->format);
|
|
int transp2 = image_alpha(image2.image->format);
|
|
|
|
for( int j=0; j<rows; j++)
|
|
{
|
|
for (int i=0; i<columns; i++)
|
|
{
|
|
if( (data_u16_1[ adeltax + i ] != transp1 )
|
|
&& (data_u16_2[ bdeltax + i ] != transp2 ) )
|
|
return true;
|
|
}
|
|
data1 += image1.image->stride;
|
|
data_u16_1 = (uint16_t *) data1;
|
|
data2 += image2.image->stride;
|
|
data_u16_2 = (uint16_t *) data2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* if BOTH images are in a 8bits color format, we will not use masks and will quicken the process */
|
|
|
|
if ( IMAGE_IS_P8(image1.image->format) && IMAGE_IS_P8(image2.image->format) )
|
|
{
|
|
void *data1 = image1.image->data + adeltay * image1.image->stride;
|
|
void *data2 = image2.image->data + bdeltay * image2.image->stride;
|
|
|
|
int8_t *data_u8_1 = (int8_t *) data1;
|
|
int8_t *data_u8_2 = (int8_t *) data2;
|
|
|
|
int transp1 = image_alpha(image1.image->format);
|
|
int transp2 = image_alpha(image2.image->format);
|
|
|
|
for( int j=0; j<rows; j++)
|
|
{
|
|
for (int i=0; i<columns; i++)
|
|
{
|
|
if( (data_u8_1[ adeltax + i ] != transp1 )
|
|
&& (data_u8_2[ bdeltax + i ] != transp2 ) )
|
|
return true;
|
|
}
|
|
data1 += image1.image->stride;
|
|
data_u8_1 = (int8_t *) data1;
|
|
data2 += image2.image->stride;
|
|
data_u8_2 = (int8_t *) data2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* if we reach that point, this means that images have differnt format and we need to manage this */
|
|
|
|
uint8_t d1;
|
|
uint8_t d2;
|
|
|
|
void *data1 = image1.image->data + adeltay * image1.image->stride;
|
|
void *data2 = image2.image->data + bdeltay * image2.image->stride;
|
|
|
|
int8_t *data_u8_1 = (int8_t *) data1;
|
|
uint16_t *data_u16_1 = (uint16_t *) data1;
|
|
|
|
int8_t *data_u8_2 = (int8_t *) data2;
|
|
uint16_t *data_u16_2 = (uint16_t *) data2;
|
|
|
|
int transp1 = image_alpha(image1.image->format);
|
|
int transp2 = image_alpha(image2.image->format);
|
|
|
|
bool im1_P16 = IMAGE_IS_RGB16(image1.image->format);
|
|
bool im1_P8 = IMAGE_IS_P8(image1.image->format);
|
|
|
|
bool im2_P16 = IMAGE_IS_RGB16(image2.image->format);
|
|
bool im2_P8 = IMAGE_IS_P8(image2.image->format);
|
|
|
|
for( int j=0; j<rows; j++)
|
|
{
|
|
for (int i=0; i<columns; i++)
|
|
{
|
|
/* d1 is set to 1 if pixel of image1 is not transparent and to 0 if transparent */
|
|
/* need to be format dependant here so quite time consumming test at each loop :( )*/
|
|
if (im1_P16)
|
|
d1 = data_u16_1[ adeltax + i ] == transp1 ? 0 : 1;
|
|
else if (im1_P8)
|
|
d1 = data_u8_1[ adeltax + i ] == transp1 ? 0 : 1;
|
|
else d1 = 0;
|
|
|
|
/* d2 is set to 1 if pixel of image2 is not transparent and to 0 if transparent */
|
|
/* need to be format dependant here so quite time consumming test at each loop :( )*/
|
|
if (im2_P16)
|
|
d2 = data_u16_2[ bdeltax + i ] == transp2 ? 0 : 1;
|
|
else if (im2_P8)
|
|
d2 = data_u8_2[ bdeltax + i ] == transp2 ? 0 : 1;
|
|
else d2 = 0;
|
|
|
|
/* if d1 + d2 = 2 means that both coincident pixels are not transparent and then we have collision*/
|
|
if (d1 + d2 == 2) return true;
|
|
}
|
|
/* we move the pointer to the next line of both images */
|
|
data1 += image1.image->stride;
|
|
data2 += image2.image->stride;
|
|
data_u8_1 = (int8_t *) data1;
|
|
data_u8_2 = (int8_t *) data2;
|
|
data_u16_1 = (uint16_t *) data1;
|
|
data_u16_2 = (uint16_t *) data2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
/* COHEN-SUTHERLAND Line/Rectangle intersection*/
|
|
|
|
typedef uint8_t OutCode;
|
|
const uint8_t INSIDE = 0; // 0000
|
|
const uint8_t LEFT = 1; // 0001
|
|
const uint8_t RIGHT = 2; // 0010
|
|
const uint8_t BOTTOM = 4; // 0100
|
|
const uint8_t TOP = 8; // 1000
|
|
|
|
OutCode ComputeOutCode( Vector2D Point, Vector2D Min, Vector2D Max )
|
|
{
|
|
OutCode code = INSIDE; // initialised as being inside of clip window
|
|
if (Point.x < Min.x) // to the left of clip window
|
|
code |= LEFT;
|
|
else if (Point.x > Max.x) // to the right of clip window
|
|
code |= RIGHT;
|
|
if (Point.y < Min.y) // below the clip window
|
|
code |= BOTTOM;
|
|
else if (Point.y > Max.y) // above the clip window
|
|
code |= TOP;
|
|
return code;
|
|
}
|
|
|
|
|
|
bool LineRectangle_Collision( Vector2D Start, Vector2D Direction, Vector2D Min, Vector2D Max )
|
|
{
|
|
Vector2D End = Start.Clone();
|
|
End.Add( Direction, libnum::num(400));
|
|
|
|
OutCode outcode0 = ComputeOutCode( Start, Min, Max );
|
|
OutCode outcode1 = ComputeOutCode( End, Min, Max );
|
|
bool accept = false;
|
|
|
|
|
|
if (!(outcode0 | outcode1)) return true; // both point inside so it hits
|
|
else if (outcode0 & outcode1) return false; // both point on the same sides outoff the rectangle --> no hit possible
|
|
else return true; // cross at least on one segment
|
|
} |