void draw_sector(gs_scalar x, gs_scalar y, gs_scalar rx, gs_scalar ry, float a1, float a2, bool outline)
{
// TODO(JoshDreamland): Replace with settings macro to get from preferred unit to radians
a1 *= M_PI/180;
a2 *= M_PI/180;
gs_scalar pr = 2*M_PI/enigma::circleprecision;
if (outline) {
draw_primitive_begin(pr_linestrip);
draw_vertex(x, y);
for (float a = a1; a < a2; a += pr) {
draw_vertex(x + rx * cos(a), y - ry * sin(a));
}
draw_vertex(x + rx * cos(a2), y - ry * sin(a2));
draw_vertex(x, y);
draw_primitive_end();
} else {
draw_primitive_begin(pr_trianglefan);
draw_vertex(x, y);
for (float a = a1; a < a2; a += pr) {
draw_vertex(x + rx * cos(a), y - ry * sin(a));
}
draw_primitive_end();
}
}
void draw_ellipse(gs_scalar x1, gs_scalar y1, gs_scalar x2, gs_scalar y2, bool outline)
{
gs_scalar
x=(x1+x2)/2,y=(y1+y2)/2,
hr=fabs(x2-x),vr=fabs(y2-y),
pr=2*M_PI/enigma::circleprecision;
if (outline)
{
draw_primitive_begin(pr_linelist);
for(gs_scalar i=pr;i<M_PI;i+=pr)
{
gs_scalar xc1 = cos(i)*hr, yc1 = sin(i)*vr;
i += pr;
gs_scalar xc2=cos(i)*hr,yc2=sin(i)*vr;
draw_vertex(x+xc1,y+yc1);draw_vertex(x+xc2,y+yc2);
draw_vertex(x-xc1,y+yc1);draw_vertex(x-xc2,y+yc2);
draw_vertex(x+xc1,y-yc1);draw_vertex(x+xc2,y-yc2);
draw_vertex(x-xc1,y-yc1);draw_vertex(x-xc2,y-yc2);
}
draw_primitive_end();
} else {
for(float i = pr; i < M_PI; i += pr)
{
float xc1=cos(i)*hr,yc1=sin(i)*vr;
i+=pr;
float xc2=cos(i)*hr,yc2=sin(i)*vr;
draw_primitive_begin(pr_trianglestrip);
draw_vertex(x-xc1,y+yc1);draw_vertex(x+xc1,y+yc1);draw_vertex(x-xc2,y+yc2);draw_vertex(x+xc2,y+yc2);
draw_primitive_end();
draw_primitive_begin(pr_trianglestrip);
draw_vertex(x-xc1,y-yc1);draw_vertex(x+xc1,y-yc1);draw_vertex(x-xc2,y-yc2);draw_vertex(x+xc2,y-yc2);
draw_primitive_end();
}
}
}
void draw_button(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, gs_scalar border_width, bool up)
{
if(x1>x2) {
x2=x1;
x1=x2;
}
if(y1>y2) {
y2=y1;
y1=y2;
}
if (x2-x1<border_width*2){border_width=(x2-x1)/2;}
if (y2-y1<border_width*2){border_width=(y2-y1)/2;}
draw_primitive_begin(pr_trianglestrip);
draw_vertex(x1,y1);
draw_vertex(x2,y1);
draw_vertex(x1,y2);
draw_vertex(x2,y2);
draw_primitive_end();
int color;
float alpha = 0.5;
if (up == true){ color = make_color_rgb(127,127,127); } else { color = make_color_rgb(255,255,255); }
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1+border_width,y2-border_width,color,alpha);
draw_vertex_color(x2-border_width,y1-border_width,color,alpha);
draw_vertex_color(x1,y2,color,alpha);
draw_vertex_color(x2,y2,color,alpha);
draw_primitive_end();
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x2-border_width,y1+border_width,color,alpha);
draw_vertex_color(x2,y1,color,alpha);
draw_vertex_color(x1-border_width,y1-border_width,color,alpha);
draw_vertex_color(x2,y2,color,alpha);
draw_primitive_end();
if (up == true){ color = make_color_rgb(255,255,255); } else { color = make_color_rgb(127,127,127); }
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1,y1,color,alpha);
draw_vertex_color(x2,y1,color,alpha);
draw_vertex_color(x1+border_width,y1+border_width,color,alpha);
draw_vertex_color(x2-border_width,y2+border_width,color,alpha);
draw_primitive_end();
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1,y1,color,alpha);
draw_vertex_color(x1+border_width,y1+border_width,color,alpha);
draw_vertex_color(x1,y2,color,alpha);
draw_vertex_color(x1+border_width,y2-border_width,color,alpha);
draw_primitive_end();
}
void draw_roundrect_precise(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, float rad, bool outline)
{
if (x1>x2) {
float t=x2;
x2=x1;
x1=t;
}
if (y1>y2) {
float t=y2;
y2=y1;
y1=t;
}
if (x2-x1<rad*2){rad=(x2-x1)/2;}
if (y2-y1<rad*2){rad=(y2-y1)/2;}
if (rad<0){rad=0;}
float r2=rad*rad,r12=rad*M_SQRT1_2,
bx1=x1+rad,by1=y1+rad,
bx2=x2-rad,by2=y2-rad;
if (outline) {
draw_primitive_begin(pr_linelist);
draw_vertex(x1,by1);draw_vertex(x1,by2);
draw_vertex(x2,by1);draw_vertex(x2,by2);
draw_vertex(bx1,y1);draw_vertex(bx2,y1);
draw_vertex(bx1,y2);draw_vertex(bx2,y2);
draw_primitive_end();
draw_primitive_begin(pr_pointlist);
for(float xc=0,yc=rad;xc<=r12;xc++) {
if (xc*xc+yc*yc>r2) yc--;
draw_vertex(bx2+xc,by2+yc);
draw_vertex(bx2+xc,by1-yc);
draw_vertex(bx1-xc,by2+yc);
draw_vertex(bx1-xc,by1-yc);
draw_vertex(bx2+yc,by2+xc);
draw_vertex(bx2+yc,by1-xc);
draw_vertex(bx1-yc,by2+xc);
draw_vertex(bx1-yc,by1-xc);
}
draw_primitive_end();
} else {
draw_primitive_begin(pr_linelist);
for(float xc=0,yc=rad;xc<=r12;xc++) {
if (xc*xc+yc*yc>r2) yc--;
draw_vertex(bx2+xc,by2+yc);
draw_vertex(bx2+xc,by1-yc);
draw_vertex(bx1-xc,by2+yc);
draw_vertex(bx1-xc,by1-yc);
draw_vertex(bx2+yc,by2+xc);
draw_vertex(bx2+yc,by1-xc);
draw_vertex(bx1-yc,by2+xc);
draw_vertex(bx1-yc,by1-xc);
}
draw_primitive_end();
draw_rectangle(bx1,y1,bx2,y2,false);
}
}
void draw_background_general(int back, gs_scalar left, gs_scalar top, gs_scalar width, gs_scalar height, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale, double rot, int c1, int c2, int c3, int c4, gs_scalar alpha)
{
alpha=clamp_alpha(alpha);
get_background(bck2d, back);
const gs_scalar tbx = bck2d->texturex, tby = bck2d->texturey,
tbw = bck2d->texturew, tbh = bck2d->textureh,
ttbw = bck2d->width/tbw, ttbh = bck2d->height/tbh,
tbx1 = tbx+left/ttbw, tby1 = tby+top/ttbh,
tbx2 = tbx+(left+width)/ttbw, tby2 = tby+(top+height)/ttbh,
w = width*xscale, h = height*yscale;
rot *= M_PI/180;
const gs_scalar wcosrot = w*cos(rot), wsinrot = w*sin(rot);
gs_scalar ulcx = x + xscale * cos(M_PI+rot) + yscale * cos(M_PI/2+rot),
ulcy = y - yscale * sin(M_PI+rot) - yscale * sin(M_PI/2+rot);
draw_primitive_begin_texture(pr_trianglestrip, bck2d->texture);
draw_vertex_texture_color(ulcx, ulcy, tbx1, tby1,c1,alpha);
draw_vertex_texture_color((ulcx + wcosrot), (ulcy - wsinrot), tbx2,tby1, c2, alpha);
ulcx += h * cos(3*M_PI/2 + rot);
ulcy -= h * sin(3*M_PI/2 + rot);
draw_vertex_texture_color(ulcx, ulcy, tbx1, tby2,c3,alpha);
draw_vertex_texture_color((ulcx + wcosrot), (ulcy - wsinrot), tbx2, tby2,c4,alpha);
draw_primitive_end();
}
void draw_line(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2)
{
draw_primitive_begin(pr_linestrip);
draw_vertex(x1, y1);
draw_vertex(x2, y2);
draw_primitive_end();
}
void draw_sprite_tiled_ext(int spr, int subimg, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale, int color, gs_scalar alpha)
{
get_spritev(spr2d,spr);
const int usi = subimg >= 0 ? (subimg % spr2d->subcount) : int(((enigma::object_graphics*)enigma::instance_event_iterator->inst)->image_index) % spr2d->subcount;
const float
tbx = spr2d->texbordxarray[usi], tby = spr2d->texbordyarray[usi],
width_scaled = spr2d->width*xscale, height_scaled = spr2d->height*yscale,
xoff = fmod(spr2d->xoffset*xscale+x,width_scaled)-width_scaled, yoff = fmod(spr2d->yoffset*yscale+y,height_scaled)-height_scaled;
const int
hortil = int(ceil((view_enabled ? int(view_xview[view_current] + view_wview[view_current]) : room_width) / (width_scaled*tbx))) + 1,
vertil = int(ceil((view_enabled ? int(view_yview[view_current] + view_hview[view_current]) : room_height) / (height_scaled*tby))) + 1;
float xvert1 = xoff, xvert2 = xvert1 + width_scaled, yvert1, yvert2;
for (int i=0; i<hortil; i++)
{
yvert1 = yoff; yvert2 = yvert1 + height_scaled;
for (int c=0; c<vertil; c++)
{
draw_primitive_begin_texture(pr_trianglestrip, spr2d->texturearray[usi]);
draw_vertex_texture_color(xvert1,yvert1,0,0,color,alpha);
draw_vertex_texture_color(xvert2,yvert1,tbx,0,color,alpha);
draw_vertex_texture_color(xvert1,yvert2,0,tby,color,alpha);
draw_vertex_texture_color(xvert2,yvert2,tbx,tby,color,alpha);
draw_primitive_end();
yvert1 = yvert2;
yvert2 += height_scaled;
}
xvert1 = xvert2;
xvert2 += width_scaled;
}
}
void draw_circle_color_perfect(gs_scalar x, gs_scalar y, float rad, int c1, int c2, bool outline)
{
gs_scalar r2=rad*rad;
gs_scalar alpha = draw_get_alpha();
if (outline)
{
draw_primitive_begin(pr_pointlist);
gs_scalar r12=rad*M_SQRT1_2;
for(gs_scalar xc=0,yc=rad;xc<=r12;xc++)
{
if(xc*xc+yc*yc>r2) yc--;
draw_vertex_color(x+xc, y+yc, c2, alpha);
draw_vertex_color(x+xc, y-yc, c2, alpha);
draw_vertex_color(x-xc, y+yc, c2, alpha);
draw_vertex_color(x-xc, y-yc, c2, alpha);
draw_vertex_color(x+xc, y+yc, c2, alpha);
draw_vertex_color(x+xc, y-yc, c2, alpha);
draw_vertex_color(x-xc, y+yc, c2, alpha);
draw_vertex_color(x-xc, y-yc, c2, alpha);
}
} else {
draw_primitive_begin(pr_trianglefan);
draw_vertex_color(x,y,c1,alpha);
draw_vertex_color(x-rad,y,c2,alpha);
for(gs_scalar xc=-rad+1;xc<rad;xc++)
draw_vertex_color(x+xc,y+sqrt(r2-(xc*xc)),c2,alpha);
for(gs_scalar xc=rad;xc>-rad;xc--)
draw_vertex_color(x+xc,y-sqrt(r2-(xc*xc)),c2,alpha);
draw_vertex_color(x-rad,y,c2,alpha);
}
draw_primitive_end();
}
void draw_sprite_ext(int spr, int subimg, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale, double rot, int color, gs_scalar alpha)
{
get_spritev(spr2d,spr);
const int usi = subimg >= 0 ? (subimg % spr2d->subcount) : int(((enigma::object_graphics*)enigma::instance_event_iterator->inst)->image_index) % spr2d->subcount;
rot *= M_PI/180;
const float
w = spr2d->width*xscale, h = spr2d->height*yscale,
tbx = spr2d->texbordxarray[usi], tby = spr2d->texbordyarray[usi],
wsinrot = w*sin(rot), wcosrot = w*cos(rot);
draw_primitive_begin_texture(pr_trianglestrip, spr2d->texturearray[usi]);
float
ulcx = x - xscale * spr2d->xoffset * cos(rot) + yscale * spr2d->yoffset * cos(M_PI/2+rot),
ulcy = y + xscale * spr2d->xoffset * sin(rot) - yscale * spr2d->yoffset * sin(M_PI/2+rot);
draw_vertex_texture_color(ulcx,ulcy, 0,0, color, alpha);
draw_vertex_texture_color(ulcx + wcosrot, ulcy - wsinrot, tbx, 0, color, alpha);
const double mpr = 3*M_PI/2 + rot;
ulcx += h * cos(mpr);
ulcy -= h * sin(mpr);
draw_vertex_texture_color(ulcx,ulcy, 0,tby, color, alpha);
draw_vertex_texture_color(ulcx + wcosrot, ulcy - wsinrot, tbx,tby, color, alpha);
draw_primitive_end();
}
void draw_sprite_tiled(int spr, int subimg, gs_scalar x, gs_scalar y, int color, gs_scalar alpha)
{
get_spritev(spr2d,spr);
const int usi = subimg >= 0 ? (subimg % spr2d->subcount) : int(((enigma::object_graphics*)enigma::instance_event_iterator->inst)->image_index) % spr2d->subcount;
x = ((spr2d->xoffset+x)<0?0:spr2d->width)-fmod(spr2d->xoffset+x,spr2d->width);
y = ((spr2d->yoffset+y)<0?0:spr2d->height)-fmod(spr2d->yoffset+y,spr2d->height);
const gs_scalar tbx = spr2d->texbordxarray[usi], tby = spr2d->texbordyarray[usi];
const int
hortil = int(ceil((view_enabled ? (gs_scalar)(view_xview[view_current] + view_wview[view_current]) : (gs_scalar)room_width) / ((gs_scalar)spr2d->width))) + 1,
vertil = int(ceil((view_enabled ? (gs_scalar)(view_yview[view_current] + view_hview[view_current]) : (gs_scalar)room_height) / ((gs_scalar)spr2d->height))) + 1;
gs_scalar xvert1 = -x, xvert2 = xvert1 + spr2d->width, yvert1, yvert2;
for (int i=0; i<hortil; ++i)
{
yvert1 = -y; yvert2 = yvert1 + spr2d->height;
for (int c=0; c<vertil; ++c)
{
draw_primitive_begin_texture(pr_trianglestrip, spr2d->texturearray[usi]);
draw_vertex_texture_color(xvert1,yvert1,0,0,color,alpha);
draw_vertex_texture_color(xvert2,yvert1,tbx,0,color,alpha);
draw_vertex_texture_color(xvert1,yvert2,0,tby,color,alpha);
draw_vertex_texture_color(xvert2,yvert2,tbx,tby,color,alpha);
draw_primitive_end();
yvert1 = yvert2;
yvert2 += spr2d->height;
}
xvert1 = xvert2;
xvert2 += spr2d->width;
}
}
void draw_background_tiled(int back, gs_scalar x, gs_scalar y, int color, gs_scalar alpha)
{
alpha=clamp_alpha(alpha);
get_background(bck2d,back);
x = (x<0?0:bck2d->width)-fmod(x,bck2d->width);
y = (y<0?0:bck2d->height)-fmod(y,bck2d->height);
const gs_scalar tbx = bck2d->texturex, tby = bck2d->texturey,
tbw = bck2d->texturew, tbh = bck2d->textureh;
const int hortil = int (ceil((gs_scalar)room_width/((gs_scalar)bck2d->width))) + 1,
vertil = int (ceil((gs_scalar)room_height/((gs_scalar)bck2d->height))) + 1;
gs_scalar xvert1 = -x, xvert2 = xvert1 + bck2d->width, yvert1, yvert2;
for (int i=0; i<hortil; ++i)
{
yvert1 = -y; yvert2 = yvert1 + bck2d->height;
for (int c=0; c<vertil; ++c)
{
draw_primitive_begin_texture(pr_trianglestrip, bck2d->texture);
draw_vertex_texture_color(xvert1,yvert1,tbx,tby,color,alpha);
draw_vertex_texture_color(xvert2,yvert1,tbx+tbw,tby,color,alpha);
draw_vertex_texture_color(xvert1,yvert2,tbx,tby+tbh,color,alpha);
draw_vertex_texture_color(xvert2,yvert2,tbx+tbw,tby+tbh,color,alpha);
draw_primitive_end();
yvert1 = yvert2;
yvert2 += bck2d->height;
}
xvert1 = xvert2;
xvert2 += bck2d->width;
}
}
void draw_sprite_general(int spr, int subimg, gs_scalar left, gs_scalar top, gs_scalar width, gs_scalar height, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale, double rot, int c1, int c2, int c3, int c4, gs_scalar alpha)
{
get_spritev(spr2d,spr);
const int usi = subimg >= 0 ? (subimg % spr2d->subcount) : int(((enigma::object_graphics*)enigma::instance_event_iterator->inst)->image_index) % spr2d->subcount;
const float
tbx = spr2d->texbordxarray[usi], tby = spr2d->texbordyarray[usi],
tbw = spr2d->width/tbx, tbh = spr2d->height/tby,
w = width*xscale, h = height*yscale;
rot *= M_PI/180;
const float wcosrot = w*cos(rot), wsinrot = w*sin(rot);
draw_primitive_begin_texture(pr_trianglestrip, spr2d->texturearray[usi]);
float
ulcx = x + xscale * cos(M_PI+rot) + yscale * cos(M_PI/2+rot),
ulcy = y - yscale * sin(M_PI+rot) - yscale * sin(M_PI/2+rot);
draw_vertex_texture_color(ulcx, ulcy, left/tbw, top/tbh, c1, alpha);
draw_vertex_texture_color((ulcx + wcosrot), (ulcy - wsinrot), (left+width)/tbw, top/tbh, c2, alpha);
ulcx += h * cos(3*M_PI/2 + rot);
ulcy -= h * sin(3*M_PI/2 + rot);
draw_vertex_texture_color((ulcx + wcosrot), (ulcy - wsinrot), (left+width)/tbw, (top+height)/tbh, c4, alpha);
draw_vertex_texture_color(ulcx, ulcy, left/tbw, (top+height)/tbh, c3, alpha);
draw_primitive_end();
}
void draw_background_ext(int back, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale, double rot, int color, gs_scalar alpha)
{
alpha=clamp_alpha(alpha);
get_background(bck2d,back);
rot *= M_PI/180;
const gs_scalar tbw = bck2d->texturew, tbh = bck2d->textureh,
tbx = bck2d->texturex, tby = bck2d->texturey,
w = bck2d->width*xscale, h = bck2d->height*yscale,
wsinrot = w*sin(rot), wcosrot = w*cos(rot);
draw_primitive_begin_texture(pr_trianglestrip, bck2d->texture);
gs_scalar ulcx = x + xscale * cos(M_PI+rot) + yscale * cos(M_PI/2+rot),
ulcy = y - yscale * sin(M_PI+rot) - yscale * sin(M_PI/2+rot);
draw_vertex_texture_color(ulcx, ulcy, tbx, tby,color,alpha);
draw_vertex_texture_color(ulcx + wcosrot, ulcy - wsinrot, tbx+tbw, tby,color,alpha);
const double mpr = 3*M_PI/2 + rot;
ulcx += h * cos(mpr);
ulcy -= h * sin(mpr);
draw_vertex_texture_color(ulcx, ulcy, tbx, tby+tbh,color,alpha);
draw_vertex_texture_color(ulcx + wcosrot, ulcy - wsinrot, tbx+tbw, tby+tbh,color,alpha);
draw_primitive_end();
}
//Mind that health is 1-100
void draw_healthbar(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, float amount, int backcol, int mincol, int maxcol, int dir, bool showback, bool showborder)
{
if (x1>x2) { // Swap them
gs_scalar t = x2;
x2 = x1, x1 = t;
}
if (y1>y2) { // Swap them
gs_scalar t = y2;
y2 = y1, y1 = t;
}
amount = amount>=100 ? 1 : (amount<=0 ? 0 : amount/100);
gs_scalar alpha = draw_get_alpha();
if (showback) {
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1,y1,backcol,alpha);
draw_vertex_color(x2,y1,backcol,alpha);
draw_vertex_color(x1,y2,backcol,alpha);
draw_vertex_color(x2,y2,backcol,alpha);
draw_primitive_end();
}
switch (dir) {
case 1:x1=x2-(x2-x1)*amount;break;
case 2:y2=y1+(y2-y1)*amount;break;
case 3:y1=y2-(y2-y1)*amount;break;
default:x2=x1+(x2-x1)*amount;
}
int col = merge_color(mincol, maxcol, amount);
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1,y1,col,alpha);
draw_vertex_color(x2,y1,col,alpha);
draw_vertex_color(x1,y2,col,alpha);
draw_vertex_color(x2,y2,col,alpha);
draw_primitive_end();
if (showborder) {
draw_primitive_begin(pr_linestrip);
draw_vertex_color(x1,y1,0,alpha);
draw_vertex_color(x2,y1,0,alpha);
draw_vertex_color(x2,y2,0,alpha);
draw_vertex_color(x1,y2,0,alpha);
draw_vertex_color(x1,y1,0,alpha);
draw_primitive_end();
}
}
void draw_line_color(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, int c1, int c2)
{
gs_scalar alpha = draw_get_alpha();
draw_primitive_begin(pr_linestrip);
draw_vertex_color(x1, y1, c1, alpha);
draw_vertex_color(x2, y2, c2, alpha);
draw_primitive_end();
}
void draw_triangle(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, bool outline)
{
if (outline) {
draw_primitive_begin(pr_linestrip);
draw_vertex(x1, y1);
draw_vertex(x2, y2);
draw_vertex(x3, y3);
draw_vertex(x1, y1);
draw_primitive_end();
} else {
draw_primitive_begin(pr_trianglestrip);
draw_vertex(x1, y1);
draw_vertex(x2, y2);
draw_vertex(x3, y3);
draw_primitive_end();
}
}
void draw_polygon_end(bool outline, bool allowHoles)
{
std::list<enigma::PolyVertex>& currPoly = enigma::currComplexPoly;
if (outline) {
if (currPoly.size() >= 2) {
int color = draw_get_color();
gs_scalar alpha = draw_get_alpha();
//Close it, ensure the correct color.
currPoly.push_back(currPoly.front());
if (currPoly.back().color==-1) { currPoly.back().color = color; }
//Draw it.
draw_primitive_begin(pr_linestrip);
for (std::list<enigma::PolyVertex>::const_iterator it = currPoly.begin(); it!=currPoly.end(); it++) {
color = (it->color!=-1 ? it->color : color);
draw_vertex_color(it->x, it->y, color, alpha);
}
//Close it.
draw_primitive_end();
}
} else {
if (currPoly.size() >= 3) {
//Self-intersecting polygons makes this much harder than "outline" mode; we need to make a call
// to the platform-specific Graphics backend.
if (!enigma::fill_complex_polygon(currPoly, draw_get_color(), allowHoles)) {
//If drawing failed, try using a triangle fan as a backup. This will work for concave polygons only.
int color = draw_get_color();
gs_scalar alpha = draw_get_alpha();
//Draw it.
draw_primitive_begin(pr_trianglefan);
for (std::list<enigma::PolyVertex>::const_iterator it = currPoly.begin(); it!=currPoly.end(); it++) {
color = (it->color!=-1 ? it->color : color);
draw_vertex_color(it->x, it->y, color, alpha);
}
//Close it.
draw_primitive_end();
}
}
}
currPoly.clear();
}
void draw_spline4c(gs_scalar x1, gs_scalar y1, gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, gs_scalar x4, gs_scalar y4, gs_scalar x5, gs_scalar y5, gs_scalar x6, gs_scalar y6)
{
draw_primitive_begin(pr_curve_mode);
draw_spline_part(x1, y1, x2, y2, x3, y3, x4, y4);
draw_spline_part(x2, y2, x3, y3, x4, y4, x5, y5);
draw_spline_part(x3, y3, x4, y4, x5, y5, x6, y6);
draw_primitive_end();
}
void draw_spline4(gs_scalar x1, gs_scalar y1, gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, gs_scalar x4, gs_scalar y4)
{
draw_primitive_begin(pr_curve_mode);
draw_spline_part(x1, y1, x1, y1, x2, y2, x3, y3);
draw_spline_part(x1, y1, x2, y2, x3, y3, x4, y4);
draw_spline_part(x2, y2, x3, y3, x4, y4, x4, y4);
draw_primitive_end();
}
void draw_spline3c(gs_scalar x1, gs_scalar y1, gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, gs_scalar x4, gs_scalar y4, gs_scalar x5, gs_scalar y5)
{
draw_primitive_begin(pr_curve_mode);
//As I need 4 points to draw 1 line, then I will just take 2 control points from the existing ones
draw_spline_part(x1, y1, x2, y2, x3, y3, x4, y4);
draw_spline_part(x2, y2, x3, y3, x4, y4, x5, y5);
draw_primitive_end();
}
void draw_surface_stretched_ext(int id, gs_scalar x, gs_scalar y, gs_scalar w, gs_scalar h, int color, gs_scalar alpha)
{
draw_primitive_begin_texture(pr_trianglestrip, surface_get_texture(id));
draw_vertex_texture_color(x,y,0,0,color,alpha);
draw_vertex_texture_color(x+w,y,1,0,color,alpha);
draw_vertex_texture_color(x,y+h,0,1,color,alpha);
draw_vertex_texture_color(x+w,y+h,1,1,color,alpha);
draw_primitive_end();
}
void draw_triangle_color(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, int col1, int col2, int col3, bool outline)
{
gs_scalar alpha = draw_get_alpha();
if (outline) {
draw_primitive_begin(pr_linestrip);
draw_vertex_color(x1, y1, col1, alpha);
draw_vertex_color(x2, y2, col2, alpha);
draw_vertex_color(x3, y3, col3, alpha);
draw_vertex_color(x1, y1, col1, alpha);
draw_primitive_end();
} else {
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1, y1, col1, alpha);
draw_vertex_color(x2, y2, col2, alpha);
draw_vertex_color(x3, y3, col3, alpha);
draw_primitive_end();
}
}
void draw_surface_part_ext(int id, gs_scalar left, gs_scalar top, gs_scalar w, gs_scalar h, gs_scalar x, gs_scalar y, gs_scalar xscale, gs_scalar yscale,int color, gs_scalar alpha)
{
const gs_scalar tbw = surface_get_width(id), tbh = surface_get_height(id);
draw_primitive_begin_texture(pr_trianglestrip, surface_get_texture(id));
draw_vertex_texture_color(x,y,left/tbw,top/tbh,color,alpha);
draw_vertex_texture_color(x+w*xscale,y,(left+w)/tbw,top/tbh,color,alpha);
draw_vertex_texture_color(x,y+h*yscale,left/tbw,(top+h)/tbh,color,alpha);
draw_vertex_texture_color(x+w*xscale,y+h*yscale,(left+w)/tbw,(top+h)/tbh,color,alpha);
draw_primitive_end();
}
void draw_rectangle_color(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, int c1, int c2, int c3, int c4, bool outline)
{
gs_scalar alpha = draw_get_alpha();
if (outline) {
draw_primitive_begin(pr_linestrip);
draw_vertex_color(x1, y1, c1, alpha);
draw_vertex_color(x2, y1, c2, alpha);
draw_vertex_color(x2, y2, c3, alpha);
draw_vertex_color(x1, y2, c4, alpha);
draw_vertex_color(x1, y1, c1, alpha);
draw_primitive_end();
} else {
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x2, y1, c2, alpha);
draw_vertex_color(x2, y2, c3, alpha);
draw_vertex_color(x1, y1, c1, alpha);
draw_vertex_color(x1, y2, c4, alpha);
draw_primitive_end();
}
}
void draw_surface(int id, gs_scalar x, gs_scalar y, int color, gs_scalar alpha)
{
int w=surface_get_width(id);
int h=surface_get_height(id);
draw_primitive_begin_texture(pr_trianglestrip, surface_get_texture(id));
draw_vertex_texture_color(x,y,0,0,color,alpha);
draw_vertex_texture_color(x+w,y,1,0,color,alpha);
draw_vertex_texture_color(x,y+h,0,1,color,alpha);
draw_vertex_texture_color(x+w,y+h,1,1,color,alpha);
draw_primitive_end();
}
void draw_line_width(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, float width)
{
double dir = fmod(atan2(y1-y2,x2-x1)+2*M_PI,2*M_PI);
double cv = cos(dir-M_PI/2.0), sv = -sin(dir-M_PI/2.0);
double dw = width/2.0;
draw_primitive_begin(pr_trianglestrip);
draw_vertex(x1+dw*cv, y1+dw*sv);
draw_vertex(x1-dw*cv, y1-dw*sv);
draw_vertex(x2+dw*cv, y2+dw*sv);
draw_vertex(x2-dw*cv, y2-dw*sv);
draw_primitive_end();
}
//first and last point is used as control points, so they will not be drawn
void draw_bezier_quadratic_spline_end()
{
draw_primitive_begin(startedSplinesMode.top());
spline &arr = *startedSplines.top();
if (arr.size()>3)
for (unsigned i = 2; i < arr.size(); ++i)
draw_bezier_quadratic_spline_part(arr[i-2].x, arr[i-2].y, arr[i-1].x, arr[i-1].y, arr[i].x, arr[i].y, arr[i-2].col, arr[i-1].col, arr[i-2].al, arr[i-1].al);
draw_primitive_end();
delete &arr;
startedSplines.pop();
startedSplinesMode.pop();
}
void draw_spline_end()
{
draw_primitive_begin(startedSplinesMode.top());
spline &arr = *startedSplines.top();
if (arr.size()>4)
for (unsigned i = 3; i < arr.size(); ++i)
draw_spline_part_color(arr[i-3].x, arr[i-3].y, arr[i-2].x, arr[i-2].y, arr[i-1].x, arr[i-1].y, arr[i].x, arr[i].y, arr[i-2].col, arr[i-1].col, arr[i-2].al, arr[i-1].al);
draw_primitive_end();
delete &arr;
startedSplines.pop();
startedSplinesMode.pop();
}
void draw_spline3c_color(gs_scalar x1, gs_scalar y1, gs_scalar x2, gs_scalar y2, gs_scalar x3, gs_scalar y3, gs_scalar x4, gs_scalar y4, gs_scalar x5, gs_scalar y5, int c1, int c2, gs_scalar a1, gs_scalar a2)
{
int col1;
gs_scalar al1;
col1 = merge_color(c1, c2, 0.5);
al1 = a1 + (a2-a1)*0.5;
draw_primitive_begin(pr_curve_mode);
//As I need 4 points to draw 1 line, then I will just take 2 control points from the existing ones
//Color and alpha is interpolated in the middle for now (so it doesn't take into account length of each seperate segment)
draw_spline_part_color(x1, y1, x2, y2, x3, y3, x4, y4, c1, col1, a1, al1);
draw_spline_part_color(x2, y2, x3, y3, x4, y4, x5, y5, col1, c2, al1, a2);
draw_primitive_end();
}
void draw_line_width_color(gs_scalar x1, gs_scalar y1,gs_scalar x2, gs_scalar y2, float width, int c1, int c2)
{
gs_scalar alpha = draw_get_alpha();
double dir = fmod(atan2(y1-y2,x2-x1)+2*M_PI,2*M_PI);
double cv = cos(dir-M_PI/2.0), sv = -sin(dir-M_PI/2.0);
double dw = width/2.0;
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(x1+dw*cv, y1+dw*sv, c1, alpha);
draw_vertex_color(x1-dw*cv, y1-dw*sv, c1, alpha);
draw_vertex_color(x2+dw*cv, y2+dw*sv, c2, alpha);
draw_vertex_color(x2-dw*cv, y2-dw*sv, c2, alpha);
draw_primitive_end();
}
