// Identical to gluPerspective -- sets up a perspective projection matrix

double f = 1.0 / std::tan(fovY_deg * M_PI / 360.0);

double m[16] = {0};

m[0] = f / aspect;

m[5] = f;

m[10] = (zFar + zNear) / (zNear - zFar);

m[11] = -1.0;

m[14] = (2.0 * zFar * zNear) / (zNear - zFar);

glMultMatrixd(m);

double cx,double cy,double cz,

double ux,double uy,double uz) {

// Identical to gluLookAt

double fx=cx-ex, fy=cy-ey, fz=cz-ez;

double len=std::sqrt(fx*fx+fy*fy+fz*fz); fx/=len;fy/=len;fz/=len;

double rx=fy*uz-fz*uy, ry=fz*ux-fx*uz, rz=fx*uy-fy*ux;

len=std::sqrt(rx*rx+ry*ry+rz*rz); rx/=len;ry/=len;rz/=len;

double upx=ry*fz-rz*fy, upy=rz*fx-rx*fz, upz=rx*fy-ry*fx;

double m[16]={

rx, upx, -fx, 0,

ry, upy, -fy, 0,

rz, upz, -fz, 0,

0, 0, 0, 1

};

glMultMatrixd(m);

glTranslated(-ex,-ey,-ez);

#ifdef _WIN32

if (AllocConsole()) {

FILE* f;

freopen_s(&f, "CONOUT$", "w", stdout);

freopen_s(&f, "CONOUT$", "w", stderr);

freopen_s(&f, "CONIN$", "r", stdin);

fprintf(stderr, "[debug] processing-cpp debug console enabled\n");

}

#endif

// Java Processing seeds with a simple LCG and fills with rand values in [0,1)

// It uses its own random to not disturb the sketch's random()

uint32_t s = seed;

auto jrand = [&]() -> float {

s = s * 1664525u + 1013904223u; // LCG like Java's Random

return (s >> 8) / (float)(1 << 24);

};

for (int i = 0; i < PERLIN_SIZE + 1; i++)

perlinTable[i] = jrand();

perlinInit = true;

if (!perlinInit) initPerlin(0); // default seed 0 like Java

if (x < 0) x = -x;

if (y < 0) y = -y;

if (z < 0) z = -z;

int xi = (int)x, yi = (int)y, zi = (int)z;

float xf = x - xi, yf = y - yi, zf = z - zi;

float r = 0.0f, ampl = 0.5f;

for (int oct = 0; oct < noiseOctaves; oct++) {

int of = xi + (yi << PERLIN_YWRAPB) + (zi << PERLIN_ZWRAPB);

float rxf = noise_fsc(xf), ryf = noise_fsc(yf);

float n1 = perlinTable[of & PERLIN_SIZE];

n1 += rxf * (perlinTable[(of+1) & PERLIN_SIZE] - n1);

float n2 = perlinTable[(of + PERLIN_YWRAP) & PERLIN_SIZE];

n2 += rxf * (perlinTable[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n2);

n1 += ryf * (n2 - n1);

of += PERLIN_ZWRAP;

n2 = perlinTable[of & PERLIN_SIZE];

n2 += rxf * (perlinTable[(of+1) & PERLIN_SIZE] - n2);

float n3 = perlinTable[(of + PERLIN_YWRAP) & PERLIN_SIZE];

n3 += rxf * (perlinTable[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n3);

n2 += ryf * (n3 - n2);

n1 += noise_fsc(zf) * (n2 - n1);

r += n1 * ampl;

ampl *= noiseFalloff;

// Double frequency each octave

xi <<= 1; xf *= 2.0f; if (xf >= 1.0f) { xi++; xf--; }

yi <<= 1; yf *= 2.0f; if (yf >= 1.0f) { yi++; yf--; }

zi <<= 1; zf *= 2.0f; if (zf >= 1.0f) { zi++; zf--; }

}

return r;

static float spare; static bool has=false;

if(has){has=false;return spare;}

float u,v,s;

do{u=_rngDist(_rng)*2-1;v=_rngDist(_rng)*2-1;s=u*u+v*v;}while(s>=1||s==0);

s=std::sqrt(-2*std::log(s)/s);spare=v*s;has=true;return u*s;

// Normalise each channel to [0, 1]

h /= colorMaxH;

s /= colorMaxS;

b /= colorMaxB;

if (s == 0.0f) {

// Achromatic (grey): all channels equal brightness

outR = outG = outB = b;

return;

}

float sector = h * 6.0f; // which 60-degree sector of the hue wheel

int i = (int)sector;

float frac = sector - i; // fractional part within sector

float p = b * (1.0f - s);

float q = b * (1.0f - s * frac);

float t = b * (1.0f - s * (1.0f - frac));

switch (i % 6) {

case 0: outR = b; outG = t; outB = p; break;

case 1: outR = q; outG = b; outB = p; break;

case 2: outR = p; outG = b; outB = t; break;

case 3: outR = p; outG = q; outB = b; break;

case 4: outR = t; outG = p; outB = b; break;

default: outR = b; outG = p; outB = q; break;

}

float r = 0, g = 0, bv = 0, aa = 0;

if (colorModeVal == HSB) {

hsbToRgb(a, b, c, r, g, bv);

aa = d / colorMaxA;

} else {

r = a / colorMaxH;

g = b / colorMaxS;

bv = c / colorMaxB;

aa = d / colorMaxA;

}

return colorVal((int)(r*255), (int)(g*255), (int)(bv*255), (int)(aa*255));

// In HSB mode, a single-value gray maps to brightness only (hue=0, sat=0)

// matching Processing Java behavior -- background(v) in HSB gives gray

if(colorModeVal==HSB){

float br=gray/colorMaxB;

br=std::fmax(0.f,std::fmin(1.f,br));

int v=(int)(br*255);

unsigned int a=std::fmax(0.f,std::fmin(1.f,alpha/colorMaxA))*255;

return colorVal(v,v,v,(int)a);

}

return makeColor(gray,gray,gray,alpha);

unsigned int v=c.value;

float r=(v>>16&0xFF)/255.f, g=(v>>8&0xFF)/255.f, b=(v&0xFF)/255.f;

return max(r, max(g, b)) * colorMaxB;

unsigned int v = c.value;

float r = (v >> 16 & 0xFF) / 255.f;

float g = (v >> 8 & 0xFF) / 255.f;

float b = (v & 0xFF) / 255.f;

float mx = max(r, max(g, b));

float mn = min(r, min(g, b));

return (mx == 0 ? 0 : (mx - mn) / mx) * colorMaxS;

unsigned int v=c.value;

float r=(v>>16&0xFF)/255.f,g=(v>>8&0xFF)/255.f,b=(v&0xFF)/255.f;

float mx=max(r,max(g,b)),mn=min(r,min(g,b)),d=mx-mn;

if(d==0)return 0;

float h=(mx==r)?(g-b)/d:(mx==g)?2+(b-r)/d:4+(r-g)/d;

h*=60;if(h<0)h+=360;return h/360.0f*colorMaxH;

unsigned int v1 = c1.value;

unsigned int v2 = c2.value;

int r1 = (v1 >> 16) & 0xFF, r2 = (v2 >> 16) & 0xFF;

int g1 = (v1 >> 8) & 0xFF, g2 = (v2 >> 8) & 0xFF;

int b1 = v1 & 0xFF, b2 = v2 & 0xFF;

int a1 = (v1 >> 24) & 0xFF, a2 = (v2 >> 24) & 0xFF;

return colorVal(

(int)(r1 + t * (r2 - r1)),

(int)(g1 + t * (g2 - g1)),

(int)(b1 + t * (b2 - b1)),

(int)(a1 + t * (a2 - a1))

);

glColor4f(fillR, fillG, fillB, fillA);

// Always enable blend -- shapes with alpha need it, opaque shapes don't hurt

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

if (lightsEnabled) {

glDisable(GL_LIGHTING);

glDisable(GL_COLOR_MATERIAL);

}

glColor4f(strokeR, strokeG, strokeB, strokeA);

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

if (lightsEnabled) {

glEnable(GL_LIGHTING);

glEnable(GL_COLOR_MATERIAL);

glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);

// Reapply fill colour so the next lit shape uses the right material

glColor4f(fillR, fillG, fillB, fillA);

}

if(persistFBO){glDeleteFramebuffers(1,&persistFBO);glDeleteTextures(1,&persistTex);persistFBO=0;}

glGenFramebuffers(1,&persistFBO);

glGenTextures(1,&persistTex);

glBindTexture(GL_TEXTURE_2D,persistTex);

glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,fbW,fbH,0,GL_RGBA,GL_UNSIGNED_BYTE,nullptr);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);

glBindTexture(GL_TEXTURE_2D,0);

glBindFramebuffer(GL_FRAMEBUFFER,persistFBO);

glFramebufferTexture2D(GL_FRAMEBUFFER,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,persistTex,0);

glBindFramebuffer(GL_FRAMEBUFFER,0);

if(!persistFBO) initPersistFBO();

// Blit back buffer -> persist FBO

glBindFramebuffer(GL_READ_FRAMEBUFFER,0);

glBindFramebuffer(GL_DRAW_FRAMEBUFFER,persistFBO);

glBlitFramebuffer(0,0,fbW,fbH,0,0,fbW,fbH,GL_COLOR_BUFFER_BIT,GL_NEAREST);

glBindFramebuffer(GL_FRAMEBUFFER,0);

if(!persistFBO) return;

glBindFramebuffer(GL_READ_FRAMEBUFFER,persistFBO);

glBindFramebuffer(GL_DRAW_FRAMEBUFFER,0);

glBlitFramebuffer(0,0,fbW,fbH,0,0,fbW,fbH,GL_COLOR_BUFFER_BIT,GL_NEAREST);

glBindFramebuffer(GL_FRAMEBUFFER,0);

// Restore main window viewport and projection after PGraphics endDraw()

glViewport(0,0,fbW,fbH);

glMatrixMode(GL_PROJECTION);glLoadIdentity();

glOrtho(0,logicalW,logicalH,0,-1,1);

glMatrixMode(GL_MODELVIEW);glLoadIdentity();

glDisable(GL_DEPTH_TEST);

glDisable(GL_LIGHTING);

// Viewport = actual framebuffer size (handles HiDPI where fb > logical).

// Ortho = logical sketch size (coordinates always match what size() set).

if (gWindow) {

int fw=logicalW, fh=logicalH;

glfwGetFramebufferSize(gWindow, &fw, &fh);

if (fw > 0) fbW = fw;

if (fh > 0) fbH = fh;

}

glViewport(0, 0, fbW, fbH);

glMatrixMode(GL_PROJECTION);glLoadIdentity();

glOrtho(0, logicalW, logicalH, 0, -1, 1);

glMatrixMode(GL_MODELVIEW);glLoadIdentity();

glDisable(GL_DEPTH_TEST);

glDisable(GL_LIGHTING);

float sa,float ea,int segs){

if(segs < 0){

float maxR = rx > ry ? rx : ry;

segs = (int)(maxR * 2.5f);

if(segs < 64) segs = 64;

if(segs > 512) segs = 512;

}

float range=ea-sa;

bool isFullCircle = (std::fabs(range) >= TWO_PI - 0.001f);

if(doFill){

applyFill();

glBegin(GL_TRIANGLE_FAN);

glVertex2f(cx,cy); // center

for(int i=0;i<=segs;i++){

float a=sa+range*i/segs;

glVertex2f(cx+rx*std::cos(a),cy+ry*std::sin(a));

}

if(isFullCircle){

// close the circle back to the first arc point

glVertex2f(cx+rx*std::cos(sa),cy+ry*std::sin(sa));

}

glEnd();

}

if(doStroke){

applyStroke();glLineWidth(strokeW);

if(isFullCircle){

glBegin(GL_LINE_LOOP);

} else {

glBegin(GL_LINE_STRIP);

}

for(int i=0;i<=segs;i++){

float a=sa+range*i/segs;

glVertex2f(cx+rx*std::cos(a),cy+ry*std::sin(a));

}

glEnd();

}

if(currentRectMode==CENTER){x-=w*0.5f;y-=h*0.5f;}

else if(currentRectMode==RADIUS){x-=w;y-=h;w*=2;h*=2;}

else if(currentRectMode==CORNERS){w=w-x;h=h-y;}

if(currentEllipseMode==CORNER){cx+=rx;cy+=ry;}

else if(currentEllipseMode==CORNERS){float ex=rx,ey=ry;rx=(ex-cx)*0.5f;ry=(ey-cy)*0.5f;cx=(cx+ex)*0.5f;cy=(cy+ey)*0.5f;}

else if(currentEllipseMode==CENTER){rx*=0.5f;ry*=0.5f;}

unsigned int v = c.value;

fillR = (v >> 16 & 0xFF) / 255.f;

fillG = (v >> 8 & 0xFF) / 255.f;

fillB = (v & 0xFF) / 255.f;

fillA = (v >> 24 & 0xFF) / 255.f;

doFill = true;

unsigned int v = c.value;

strokeR = (v >> 16 & 0xFF) / 255.f;

strokeG = (v >> 8 & 0xFF) / 255.f;

strokeB = (v & 0xFF) / 255.f;

strokeA = (v >> 24 & 0xFF) / 255.f;

doStroke = true;

winWidth=w;winHeight=h;

logicalW=w;logicalH=h; // remember what the sketch requested

pixelWidth=w;pixelHeight=h;

if(gWindow){

glfwSetWindowSize(gWindow,w,h);

// Poll until the framebuffer is actually the requested size.

// glfwSetWindowSize is async; without this the window stays 100x100

// when setup() calls background() or draws anything.

// Poll until the window is actually resized (or timeout after 500ms)

for(int _wait=0; _wait<500; _wait++){

glfwPollEvents();

int fw=0,fh=0;

glfwGetFramebufferSize(gWindow,&fw,&fh);

// Accept exact match or close match (HiDPI scaling)

if(fw>0 && fh>0){

pixelWidth=fw; pixelHeight=fh;

// Check if the logical window size matches what we requested

int lw=0,lh=0;

glfwGetWindowSize(gWindow,&lw,&lh);

if(lw==w && lh==h) break; // exact match

}

if(_wait>=50){ // after 50ms, accept whatever we have

int fw2=0,fh2=0;

glfwGetFramebufferSize(gWindow,&fw2,&fh2);

if(fw2>0&&fh2>0){ pixelWidth=fw2; pixelHeight=fh2; }

break;

}

#ifdef _WIN32

Sleep(1);

#else

usleep(1000);

#endif

}

// Force coordinate system to requested size regardless of WM.

// logicalW/H are the sketch's coordinate space; viewport uses actual size.

logicalW = w; logicalH = h;

winWidth = w; winHeight = h;

setProjection(w,h);

}

defaultP3D=(renderer==P3D);

size(w,h);

// For P3D mode: set up depth test and apply default camera/perspective

// immediately so setup() draws with the correct projection.

if(defaultP3D && gWindow){

{int fw=logicalW,fh=logicalH;if(gWindow)glfwGetFramebufferSize(gWindow,&fw,&fh);if(fw>0)fbW=fw;if(fh>0)fbH=fh;}

glViewport(0,0,fbW,fbH);

glEnable(GL_DEPTH_TEST);

glDepthFunc(GL_LESS);

glDisable(GL_CULL_FACE);

glFrontFace(GL_CW);

glEnable(GL_NORMALIZE);

glClearColor(0.8f,0.8f,0.8f,1); // Java Processing default grey (204,204,204)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

applyDefaultCamera();

}

if (!gWindow) {

winWidth = displayWidth;

winHeight = displayHeight;

} else {

GLFWmonitor* m = glfwGetPrimaryMonitor();

const GLFWvidmode* v = glfwGetVideoMode(m);

glfwSetWindowMonitor(gWindow, m, 0, 0, v->width, v->height, v->refreshRate);

}

if (!gWindow) return "";

const char* cb = glfwGetClipboardString(gWindow);

return cb ? std::string(cb) : "";

if (!img || !gWindow) return;

// Convert ARGB pixels (Processing internal) to RGBA (GLFW wants RGBA)

std::vector<unsigned char> rgba(img->width * img->height * 4);

for (int p = 0; p < img->width * img->height; p++) {

unsigned int px = img->pixels[p];

rgba[p*4+0] = (px >> 16) & 0xFF; // R

rgba[p*4+1] = (px >> 8) & 0xFF; // G

rgba[p*4+2] = (px ) & 0xFF; // B

rgba[p*4+3] = (px >> 24) & 0xFF; // A

}

GLFWimage gi;

gi.width = img->width;

gi.height = img->height;

gi.pixels = rgba.data();

glfwSetWindowIcon(gWindow, 1, &gi);

// Use GLFW mods bitmask (reliable from callbacks) OR glfwGetKey (for polling)

if (g_currentMods & GLFW_MOD_CONTROL) return true;

if (!gWindow) return false;

return glfwGetKey(gWindow, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS

|| glfwGetKey(gWindow, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS;

if (g_currentMods & GLFW_MOD_SHIFT) return true;

if (!gWindow) return false;

return glfwGetKey(gWindow, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS

|| glfwGetKey(gWindow, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS;

if (g_currentMods & GLFW_MOD_ALT) return true;

if (!gWindow) return false;

return glfwGetKey(gWindow, GLFW_KEY_LEFT_ALT) == GLFW_PRESS

|| glfwGetKey(gWindow, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS;

// The MAIN window's actual MSAA sample count is fixed at window-creation

// time (GLFW_SAMPLES is a window hint, can't change after the window

// exists) -- so smooth(level) can't retroactively change the main

// canvas's hardware sample count the way real Processing's P2D/P3D

// renderers can. What we CAN do: store the requested level (used by

// PGraphics buffers below, which DO get to choose their own sample

// count fresh at creation time), and toggle the same smoothing flags

// smooth() always has, regardless of which level was requested.

smoothing = true;

smoothLevel = level;

glEnable(GL_LINE_SMOOTH);glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);

glEnable(GL_POINT_SMOOTH);glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);

glEnable(GL_MULTISAMPLE);

switch(which){

case ENABLE_DEPTH_TEST: glEnable(GL_DEPTH_TEST); break;

case DISABLE_DEPTH_TEST: glDisable(GL_DEPTH_TEST); break;

case ENABLE_DEPTH_SORT: glEnable(GL_DEPTH_TEST);glDepthFunc(GL_LEQUAL); break;

case DISABLE_DEPTH_SORT: glDepthFunc(GL_LESS); break;

default: break;

}

s = { fillR, fillG, fillB, fillA,

strokeR, strokeG, strokeB, strokeA, strokeW,

doFill, doStroke,

currentRectMode, currentEllipseMode, currentImageMode,

tintR, tintG, tintB, tintA, doTint,

colorModeVal, colorMaxH, colorMaxS, colorMaxB, colorMaxA };

fillR = s.fillR; fillG = s.fillG; fillB = s.fillB; fillA = s.fillA;

strokeR = s.strokeR; strokeG = s.strokeG; strokeB = s.strokeB;

strokeA = s.strokeA; strokeW = s.strokeW;

doFill = s.doFill; doStroke = s.doStroke;

currentRectMode = s.rectMode;

currentEllipseMode = s.ellipseMode;

currentImageMode = s.imageMode;

tintR = s.tintR; tintG = s.tintG; tintB = s.tintB; tintA = s.tintA;

doTint = s.doTint;

colorModeVal = s.colorMode;

colorMaxH = s.cmH; colorMaxS = s.cmS; colorMaxB = s.cmB; colorMaxA = s.cmA;

Style s;

captureStyle(s);

styleStack.push_back(s);

if (!styleStack.empty()) {

restoreStyle(styleStack.back());

styleStack.pop_back();

}

bgR=r;bgG=g;bgB=b;bgA=a;

glClearColor(r,g,b,a);

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

_backgroundCalledThisFrame = true;

color c = makeColor(gray, a);

unsigned int v = c.value;

setBg((v>>16&0xFF)/255.f, (v>>8&0xFF)/255.f, (v&0xFF)/255.f, (v>>24&0xFF)/255.f);

_backgroundCalledThisFrame = true;

color c = makeColor(r, g, b, a);

unsigned int v = c.value;

setBg((v>>16&0xFF)/255.f, (v>>8&0xFF)/255.f, (v&0xFF)/255.f, (v>>24&0xFF)/255.f);

_backgroundCalledThisFrame = true;

unsigned int v = c.value;

setBg((v>>16&0xFF)/255.f, (v>>8&0xFF)/255.f, (v&0xFF)/255.f, (v>>24&0xFF)/255.f);

_backgroundCalledThisFrame = true;

// Draw image as full-canvas background

if (img.width == 0 || img.height == 0) return;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity();

glOrtho(0, logicalW, logicalH, 0, -1, 1);

glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity();

glDisable(GL_DEPTH_TEST);

drawImageRect(const_cast<PImage&>(img), 0, 0, (float)logicalW, (float)logicalH);

glMatrixMode(GL_PROJECTION); glPopMatrix();

glMatrixMode(GL_MODELVIEW); glPopMatrix();

if (defaultP3D) glEnable(GL_DEPTH_TEST);

unsigned int v = c.value;

fillR = (v>>16&0xFF)/255.f;

fillG = (v>>8 &0xFF)/255.f;

fillB = (v &0xFF)/255.f;

fillA = std::min(255.f, std::max(0.f, a)) / 255.f;

doFill = true;

if (!doStroke) return;

applyStroke();

if (!smoothing && strokeW <= 1.0f) {

glPointSize(1.0f);

glBegin(GL_POINTS); glVertex2f(std::floor(x)+0.5f, std::floor(y)+0.5f); glEnd();

} else {

glPointSize(strokeW);

glBegin(GL_POINTS); glVertex2f(x, y); glEnd();

}

restoreLighting();

if (!doStroke) return;

applyStroke();

glPointSize(strokeW);

glBegin(GL_POINTS); glVertex3f(x, y, z); glEnd();

restoreLighting();

{

GLint mvDepth=0, projDepth=0;

glGetIntegerv(GL_MODELVIEW_STACK_DEPTH, &mvDepth);

glGetIntegerv(GL_PROJECTION_STACK_DEPTH, &projDepth);

double mv[16], proj[16];

glGetDoublev(GL_MODELVIEW_MATRIX, mv);

glGetDoublev(GL_PROJECTION_MATRIX, proj);

GLint vp[4]; glGetIntegerv(GL_VIEWPORT, vp);

GLint curFbo=0; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &curFbo);

PDEBUG("PApplet::line(%.1f,%.1f,%.1f,%.1f) ENTRY: mvDepth=%d projDepth=%d curFbo=%d viewport=(%d,%d,%d,%d)\n",

x1,y1,x2,y2, mvDepth, projDepth, curFbo, vp[0],vp[1],vp[2],vp[3]);

PDEBUG(" mv[0]=%.3f mv[5]=%.3f mv[12]=%.3f mv[13]=%.3f\n", mv[0],mv[5],mv[12],mv[13]);

PDEBUG(" proj[0]=%.6f proj[5]=%.6f proj[12]=%.6f proj[13]=%.6f\n", proj[0],proj[5],proj[12],proj[13]);

}

if (!doStroke) return;

applyStroke();

float w = strokeW;

if (w <= 1.0f) {

// Thin lines: use GL_LINES

glLineWidth(1.0f);

glBegin(GL_LINES); glVertex2f(x1,y1); glVertex2f(x2,y2); glEnd();

restoreLighting();

return;

}

// Thick line: quad body + round caps using stencil to prevent double-blend

float dx = x2-x1, dy = y2-y1;

float len = std::sqrt(dx*dx+dy*dy);

if(len < 0.0001f){ restoreLighting(); return; }

float ux = dx/len, uy = dy/len;

float r = w*0.5f;

float px2 = -uy*r, py2 = ux*r; // perpendicular

int segs = std::max(16, (int)(r*4.0f));

// Use stencil to draw all geometry, then fill once -- prevents double-blend

glEnable(GL_STENCIL_TEST);

glClearStencil(0);

glClear(GL_STENCIL_BUFFER_BIT);

glStencilFunc(GL_ALWAYS, 1, 0xFF);

glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);

// Draw body into stencil

glBegin(GL_QUADS);

glVertex2f(x1+px2,y1+py2); glVertex2f(x2+px2,y2+py2);

glVertex2f(x2-px2,y2-py2); glVertex2f(x1-px2,y1-py2);

glEnd();

// Draw end caps into stencil

for(int ep=0;ep<2;ep++){

float cx2=ep?x2:x1, cy2=ep?y2:y1;

glBegin(GL_TRIANGLE_FAN);

glVertex2f(cx2,cy2);

for(int s=0;s<=segs;s++){

float a=s*TWO_PI/segs;

glVertex2f(cx2+std::cos(a)*r, cy2+std::sin(a)*r);

}

glEnd();

}

// Now draw color only where stencil=1

glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);

glStencilFunc(GL_EQUAL, 1, 0xFF);

glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

// Fill bounding box with stroke color

float minx=std::min(x1,x2)-r, maxx=std::max(x1,x2)+r;

float miny=std::min(y1,y2)-r, maxy=std::max(y1,y2)+r;

glBegin(GL_QUADS);

glVertex2f(minx,miny); glVertex2f(maxx,miny);

glVertex2f(maxx,maxy); glVertex2f(minx,maxy);

glEnd();

glDisable(GL_STENCIL_TEST);

restoreLighting();

if (!doStroke) return;

applyStroke();

glLineWidth(strokeW);

glBegin(GL_LINES); glVertex3f(x1,y1,z1); glVertex3f(x2,y2,z2); glEnd();

restoreLighting();

float rx = w, ry = h;

resolveEllipse(cx, cy, rx, ry);

drawEllipseGeom(cx, cy, rx, ry);

float rx = w, ry = h;

resolveEllipse(cx, cy, rx, ry);

drawEllipseGeom(cx, cy, rx, ry, startAngle, endAngle);

resolveRect(x, y, w, h);

if (doFill) {

applyFill();

glBegin(GL_QUADS);

glVertex2f(x, y );

glVertex2f(x + w, y );

glVertex2f(x + w, y + h);

glVertex2f(x, y + h);

glEnd();

}

if (doStroke) {

// Real Processing centers the stroke ON the rectangle's boundary

// (half the weight extends inward over the fill, half extends

// outward) -- NOT entirely outside it. The previous version drew

// the stroke loop expanded fully outward, which meant increasing

// strokeWeight never visually shrank the filled interior (it

// does in real Processing, since the inward half of a thick

// stroke covers part of the fill), and glLineWidth-rendered

// GL_LINE_LOOP gives flat, unmitered corners at large widths

// (visible gaps/seams at corners instead of a clean joined

// outline). Drawing the stroke as actual filled quad geometry --

// matching real Processing's approach -- fixes both: correct

// centering AND clean mitered corners via overlapping quads.

applyStroke();

float half = strokeW * 0.5f;

float xo = x - half, yo = y - half; // outer edge

float xi = x + half, yi = y + half; // inner edge (top-left side)

float xow = x + w + half, yoh = y + h + half; // outer edge (bottom-right side)

float xiw = x + w - half, yih = y + h - half; // inner edge (bottom-right side)

glBegin(GL_QUADS);

// Top edge

glVertex2f(xo, yo); glVertex2f(xow, yo); glVertex2f(xow, yi); glVertex2f(xo, yi);

// Bottom edge

glVertex2f(xo, yih); glVertex2f(xow, yih); glVertex2f(xow, yoh); glVertex2f(xo, yoh);

// Left edge (between top and bottom strips already drawn)

glVertex2f(xo, yi); glVertex2f(xi, yi); glVertex2f(xi, yih); glVertex2f(xo, yih);

// Right edge

glVertex2f(xiw, yi); glVertex2f(xow, yi); glVertex2f(xow, yih); glVertex2f(xiw, yih);

glEnd();

restoreLighting();

}

resolveRect(x, y, w, h);

// Clamp radius so it never exceeds half the shortest side

r = min(r, min(w, h) * 0.5f);

const int cornerSegs = 8; // segments per 90-degree corner arc

// Emit a corner arc: center (cx,cy), from angle sa to ea

auto corner = [&](float cx, float cy, float sa, float ea) {

for (int i = 0; i <= cornerSegs; i++) {

float a = sa + (ea - sa) * i / cornerSegs;

glVertex2f(cx + r * std::cos(a), cy + r * std::sin(a));

}

};

if (doFill) {

applyFill();

glBegin(GL_TRIANGLE_FAN);

// Fan center at rect midpoint

glVertex2f(x + w * 0.5f, y + h * 0.5f);

// Four corners in CCW order, closing back to the first arc point

corner(x + r, y + r, PI, PI + HALF_PI); // top-left