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