Initial import.

1 files changed, 982 insertions, 0 deletions

diff --git a/src/mesa/drivers/verite/rlgl.c b/src/mesa/drivers/verite/rlgl.c
new file mode 100644
index 0000000..1da14f2
--- /dev/null
+++ b/src/mesa/drivers/verite/rlgl.c
@@ -0,0 +1,982 @@
+/*
+ * Copyright (c) 2026 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Radoslaw Kujawa.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "rlgl.h"
+#include "rlvec.h"
+
+int rlgl_force_rebind = 0;
+
+/*
+ * Line-bytes -> encoded stride nibble pair
+ */
+static uint32_t
+stride_code(uint32_t linebytes)
+{
+	static const struct { uint32_t bytes, s0, s1; } tab[] = {
+		{ 16, 0, 1 }, { 32, 0, 2 }, { 64, 0, 3 }, { 128, 0, 4 },
+		{ 256, 1, 0 }, { 512, 2, 0 }, { 1024, 3, 0 },
+		{ 2048, 0, 6 }, { 4096, 0, 7 },
+	};
+	unsigned i;
+
+	for (i = 0; i < sizeof(tab) / sizeof(tab[0]); i++)
+		if (tab[i].bytes == linebytes)
+			return (tab[i].s1 << 4) | tab[i].s0;
+	return (uint32_t)-1;
+}
+
+int
+rlgl_init(struct rlgl *rl, const char *ucpath)
+{
+	struct v3d *v = &rl->v;
+
+	memset(rl, 0, sizeof(*rl));
+	rlvec_init();
+	if (v3d_open(v, "/dev/verite3d", ucpath) != 0)
+		return -1;
+	if (v3d_mode(v, 16, 0) != 0)
+		return -1;
+	if (v3d_alloc(v, v->stride * v->height, 4096, &rl->fb[0]) != 0 ||
+	    v3d_alloc(v, v->stride * v->height, 4096, &rl->fb[1]) != 0 ||
+	    v3d_alloc(v, v->stride * v->height, 4096, &rl->zbuf) != 0)
+		return -1;
+	/* tiny throwaway surface for the glCopyPixels source-read seed
+	 * (128px * 8 rows * 2B = 2KB, addressed at a 256B stride) */
+	if (v3d_alloc(v, 128 * 8 * 2, 4096, &rl->scratch) != 0)
+		return -1;
+
+	/* constant state */
+	v3d_st(v, V3D_PE_DSTFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SCISSORX, v->width);
+	v3d_st(v, V3D_PE_SCISSORY, v->height);
+	v3d_st(v, V3D_PE_ALUMODE, 0xC);
+	v3d_st(v, V3D_PE_DSTRDDIS, 0);
+	v3d_st(v, V3D_PE_ZBASE, rl->zbuf);
+	/*
+	 * Zero every mode the GL microcode's context_init leaves
+	 * undefined 
+	 */
+	v3d_st(v, 69, 0);			/* YUV2RGB */
+	v3d_st(v, V3D_PE_DITHEREN, 0);		/* DitherEnable */
+	v3d_st(v, 72, 0);			/* FogEnable */
+	v3d_st(v, 73, 0);			/* DstColorNoPad */
+	v3d_st(v, 75, 0);			/* DstBGR */
+	v3d_st(v, 76, 0);			/* TranspReject */
+	v3d_st(v, 55, 0);			/* SrcBGR */
+	v3d_st(v, 81, 0);			/* PatEnable */
+	v3d_st(v, 83, 0);			/* SpecularEn */
+	v3d_st(v, 62, 0);			/* UClamp (wrap) */
+	v3d_st(v, 63, 0);			/* VClamp (wrap) */
+	v3d_st(v, V3D_PE_PMASK, 0xFFFFFFFF);	/* all planes */
+	/* dst + Z stride identical, src patched by tex_bind */
+	v3d_st(v, V3D_PE_STRIDE, v->pe_stride |
+	    ((v->pe_stride >> 8) << 16));
+	v3d_st(v, V3D_PE_DSTBASE, rl->fb[0]);
+	rl->cur_tex = (uint32_t)-1;
+	rl->cur_func = -1;
+	rl->env_mod = RLGL_ENV_REPLACE;
+	rl->fog_on = 0;
+	rlgl_depth_test(rl, 0);
+	rlgl_depth_mask(rl, 1);
+	rlgl_blend(rl, 0, 0, 0);
+	rlgl_alpha_test(rl, 0, 0);
+	rlgl_tex_bind(rl, NULL);
+
+	/*
+	 * Claim the glass: clear both color buffers + Z, then point
+	 * scanout at the FRONT buffer.
+	 */
+	v3d_clear(v, rl->fb[0], v->stride, v->width * 2, v->height, 0);
+	v3d_clear(v, rl->fb[1], v->stride, v->width * 2, v->height, 0);
+	v3d_clear(v, rl->zbuf, v->stride, v->width * 2, v->height,
+	    0xFFFFFFFFU);
+	if (v3d_sync(v) != 0)
+		return -1;
+	return v3d_flip(v, rl->fb[rl->back ^ 1]);
+}
+
+void
+rlgl_shutdown(struct rlgl *rl)
+{
+
+	rlgl_stats_print(rl);
+	v3d_close(&rl->v);
+}
+
+int
+rlgl_tex_init(struct rlgl_tex *t, int w, int h, uint32_t fmt)
+{
+	uint32_t code = stride_code((uint32_t)w * 2);
+
+	if (code == (uint32_t)-1 || (w & (w - 1)) || (h & (h - 1)))
+		return -1;
+	t->w = (uint16_t)w;
+	t->h = (uint16_t)h;
+	t->fmt = fmt;
+	t->srcstride = code;
+	t->addr = 0;
+	return 0;
+}
+
+static uint32_t
+tex_align(uint32_t w)
+{
+	uint32_t a = w * 2;
+
+	return a < 64 ? 64 : a;
+}
+
+int
+rlgl_tex_alloc(struct rlgl *rl, struct rlgl_tex *t)
+{
+
+	return v3d_alloc(&rl->v, (uint32_t)t->w * t->h * 2,
+	    tex_align(t->w), &t->addr);
+}
+
+/*
+ * Allocate a whole mip pyramid as ONE contiguous VRAM block,
+ * like 3dfx does.
+ */
+int
+rlgl_tex_pyramid(struct rlgl *rl, struct rlgl_tex *levs, int nlev)
+{
+	uint32_t total = 0, base;
+	int i;
+
+	for (i = 0; i < nlev; i++) {
+		uint32_t a = tex_align(levs[i].w);
+
+		total = (total + a - 1) & ~(a - 1);
+		total += (uint32_t)levs[i].w * (uint32_t)levs[i].h * 2;
+	}
+	if (v3d_alloc(&rl->v, total, tex_align(levs[0].w), &base) != 0)
+		return -1;
+	total = 0;
+	for (i = 0; i < nlev; i++) {
+		uint32_t a = tex_align(levs[i].w);
+
+		total = (total + a - 1) & ~(a - 1);
+		levs[i].addr = base + total;
+		total += (uint32_t)levs[i].w * (uint32_t)levs[i].h * 2;
+	}
+	return 0;
+}
+
+int
+rlgl_tex_create(struct rlgl *rl, struct rlgl_tex *t, int w, int h,
+    uint32_t fmt)
+{
+
+	if (rlgl_tex_init(t, w, h, fmt) != 0)
+		return -1;
+	return rlgl_tex_alloc(rl, t);
+}
+
+int
+rlgl_tex_upload_rows(struct rlgl *rl, struct rlgl_tex *t,
+    const uint16_t *texels, int y, int rows)
+{
+	static uint32_t buf[512 * 512 / 2];
+	uint32_t n = (uint32_t)t->w * (uint32_t)rows;
+	uint32_t base = (uint32_t)t->w * (uint32_t)y;
+	uint32_t i;
+
+	if (n / 2 > sizeof(buf) / 4)
+		return -1;
+	for (i = 0; i < n; i += 2)
+		buf[i / 2] = ((uint32_t)texels[base + i] << 16) |
+		    (uint32_t)texels[base + i + 1];
+	return v3d_upload(&rl->v, t->addr + base * 2, buf, n * 2);
+}
+
+int
+rlgl_tex_upload(struct rlgl *rl, struct rlgl_tex *t, const uint16_t *texels)
+{
+
+	return rlgl_tex_upload_rows(rl, t, texels, 0, t->h);
+}
+
+static void
+set_srcfunc(struct rlgl *rl, int func)
+{
+
+	if (rlgl_force_rebind || rl->cur_func != func) {
+		v3d_st(&rl->v, V3D_PE_SRCFUNC, (uint32_t)func << 4);
+		rl->cur_func = func;
+	}
+}
+
+void
+rlgl_tex_bind(struct rlgl *rl, const struct rlgl_tex *t)
+{
+	struct v3d *v = &rl->v;
+
+	if (t == NULL) {
+		set_srcfunc(rl, 0);		/* NOTEXTURE */
+		return;
+	}
+	if (rlgl_force_rebind || rl->cur_tex != t->addr) {
+		v3d_texbind(v, t->addr, t->srcstride, t->w, t->h,
+		    0x10000, 0x10000);
+		v3d_st(v, V3D_PE_SRCFMT, t->fmt);
+		rl->cur_tex = t->addr;
+	}
+	set_srcfunc(rl, rl->env_mod);
+}
+
+void
+rlgl_tex_env(struct rlgl *rl, int modulate)
+{
+
+	rlgl_tex_env_code(rl, modulate ? RLGL_ENV_MODULATE :
+	    RLGL_ENV_REPLACE);
+}
+
+void
+rlgl_tex_env_code(struct rlgl *rl, int code)
+{
+
+	rl->env_mod = code;
+	if (rl->cur_func != 0)		/* texturing active: apply now */
+		set_srcfunc(rl, code);
+}
+
+void
+rlgl_tex_wrap(struct rlgl *rl, int uclamp, int vclamp)
+{
+
+	v3d_st(&rl->v, 62, uclamp ? 1 << 15 : 0);	/* UClamp */
+	v3d_st(&rl->v, 63, vclamp ? 1 << 16 : 0);	/* VClamp */
+}
+
+void
+rlgl_tex_free(struct rlgl *rl, struct rlgl_tex *t)
+{
+	uint32_t addr = t->addr;
+
+	if (addr == 0)
+		return;
+	if (rl->cur_tex == addr)
+		rl->cur_tex = (uint32_t)-1;
+	(void)ioctl(rl->v.fd, V3D_FREE, &addr);
+	t->addr = 0;
+}
+
+void
+rlgl_tex_filter(struct rlgl *rl, int bilinear)
+{
+
+	v3d_st(&rl->v, V3D_PE_SRCFILTER, bilinear ? 1 << 7 : 0);
+}
+
+void
+rlgl_depth_test(struct rlgl *rl, int enable)
+{
+
+	/* LE keeps coplanar multi-pass (lightmaps) stable */
+	rlgl_depth_func(rl, enable, RLGL_Z_LE);
+}
+
+void
+rlgl_depth_func(struct rlgl *rl, int enable, int pe_code)
+{
+
+	v3d_st(&rl->v, V3D_PE_ZBUFMODE, enable ? pe_code << 12 : 0);
+}
+
+void
+rlgl_depth_mask(struct rlgl *rl, int write)
+{
+
+	v3d_st(&rl->v, V3D_PE_ZBUFWRMODE, write ? 1 << 16 : 0);
+}
+
+void
+rlgl_blend(struct rlgl *rl, int enable, uint32_t srcf, uint32_t dstf)
+{
+	struct v3d *v = &rl->v;
+
+	v3d_st(v, V3D_PE_BLENDENABLE, enable ? 1 << 19 : 0);
+	if (enable) {
+		v3d_st(v, V3D_PE_BLENDSRCFUNC, srcf << 4);
+		v3d_st(v, V3D_PE_BLENDDSTFUNC, dstf << 8);
+	}
+}
+
+void
+rlgl_alpha_test(struct rlgl *rl, int enable, uint32_t thresh8)
+{
+	struct v3d *v = &rl->v;
+
+	/* TranspReject: reject texel alpha <= AlphaThres */
+	v3d_st(v, 76, enable ? 1 << 25 : 0);
+	if (enable)
+		v3d_st(v, 29, thresh8);		/* AlphaThres */
+}
+
+/*
+ * Hardware scissor.
+ */
+void
+rlgl_scissor(struct rlgl *rl, int x, int y, int w, int h)
+{
+	struct v3d *v = &rl->v;
+	int W = v->width, H = v->height;
+	int left = x, right = x + w;
+	int top = H - (y + h), bottom = H - y;
+
+	if (left < 0) left = 0;		if (left > W) left = W;
+	if (right < 0) right = 0;	if (right > W) right = W;
+	if (top < 0) top = 0;		if (top > H) top = H;
+	if (bottom < 0) bottom = 0;	if (bottom > H) bottom = H;
+	if (right < left) right = left;		/* off-screen -> empty box */
+	if (bottom < top) bottom = top;
+	v3d_st(v, V3D_PE_SCISSORX, ((uint32_t)left << 16) | (uint32_t)right);
+	v3d_st(v, V3D_PE_SCISSORY, ((uint32_t)top << 16) | (uint32_t)bottom);
+}
+
+/*
+ * Hardware color mask
+ */
+void
+rlgl_color_mask(struct rlgl *rl, int r, int g, int b)
+{
+	uint32_t m = (r ? 0xF800u : 0) | (g ? 0x07E0u : 0) | (b ? 0x001Fu : 0);
+
+	v3d_st(&rl->v, V3D_PE_PMASK, m | (m << 16));
+}
+
+/*
+ * Hardware logic op (glLogicOp).
+ */
+void
+rlgl_logic_op(struct rlgl *rl, int enable, int code)
+{
+	v3d_st(&rl->v, V3D_PE_ALUMODE, enable ? (uint32_t)(code & 0xF) : 0xC);
+}
+
+/*
+ * Hardware dither (GL_DITHER).
+ */
+void
+rlgl_dither(struct rlgl *rl, int enable)
+{
+	v3d_st(&rl->v, V3D_PE_DITHEREN, enable ? (1u << 20) : 0);
+}
+
+/*
+ * Per-vertex fog (GL_FOG).
+ */
+void
+rlgl_fog(struct rlgl *rl, int enable, uint32_t rgb888)
+{
+	v3d_st(&rl->v, V3D_PE_FOGCOLOR, rgb888 & 0x00FFFFFFu);
+	v3d_st(&rl->v, V3D_PE_FOGEN, enable ? (1u << 21) : 0);
+	rl->fog_on = enable ? 1 : 0;
+}
+
+static int
+stride_codes(uint32_t bytes, uint32_t *s0code, uint32_t *s1code)
+{
+	static const struct { uint32_t code, bytes; } s0[] = {
+		{ 0, 0 }, { 4, 4 }, { 1, 256 }, { 2, 512 }, { 3, 1024 },
+	};
+	static const struct { uint32_t code, bytes; } s1[] = {
+		{ 0, 0 }, { 1, 16 }, { 2, 32 }, { 3, 64 }, { 4, 128 },
+		{ 5, 1024 }, { 6, 2048 }, { 7, 4096 },
+	};
+	unsigned i, j;
+
+	for (i = 0; i < sizeof(s0) / sizeof(s0[0]); i++)
+		for (j = 0; j < sizeof(s1) / sizeof(s1[0]); j++)
+			if (s0[i].bytes + s1[j].bytes == bytes) {
+				*s0code = s0[i].code;
+				*s1code = s1[j].code;
+				return 0;
+			}
+	return -1;
+}
+
+int
+rlgl_copy_rect(struct rlgl *rl, uint32_t src_base, int src_w,
+    uint32_t dst_base, int dst_w, int sx, int sy, int dx, int dy,
+    int w, int h)
+{
+	struct v3d *v = &rl->v;
+	uint32_t ss0, ss1, ds0, ds1, reg58, reg59, sbase, c[6], b[4];
+	static const float seed[3][9] = {
+		{ 255, 255, 255,  0, 0, 100,  0, 0, 1 },
+		{ 255, 255, 255,  2, 0, 100,  0, 0, 1 },
+		{ 255, 255, 255,  0, 2, 100,  0, 0, 1 },
+	};
+	int i, k;
+
+	if (w <= 0 || h <= 0)
+		return 0;
+	if (stride_codes((uint32_t)src_w * 2, &ss0, &ss1) != 0 ||
+	    stride_codes((uint32_t)dst_w * 2, &ds0, &ds1) != 0)
+		return -1;
+	reg58 = (ss1 << 4) | ss0;		/* SrcStride subfields */
+	reg59 = (ds1 << 12) | (ds0 << 8);	/* DstStride subfields */
+	sbase = src_base + (uint32_t)sy * ((uint32_t)src_w * 2) +
+	    (uint32_t)sx * 2;
+
+	c[0] = (4 << 12) | V3D_PE_SRCBASE;	/* class-4 texture bind */
+	c[1] = sbase;
+	c[2] = reg58;
+	c[3] = (0x7FFu << 16) | 0x7FFu;		/* UMask/VMask big (no wrap) */
+	c[4] = 0x10000;				/* uscale 1.0 */
+	c[5] = 0x10000;				/* vscale 1.0 */
+	v3d_emit(v, c, 6);
+	v3d_st(v, V3D_PE_SRCFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SRCFUNC, 1 << 4);	/* REPLACE (copy source) */
+	v3d_st(v, V3D_PE_SRCFILTER, 0);		/* point sample / BitBlt */
+	v3d_st(v, V3D_PE_DSTBASE, rl->scratch);
+	v3d_st(v, 59, 0x0100);			/* scratch DstStride 256B */
+	v3d_st(v, V3D_PE_DSTFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | 128);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | 8);
+	v3d_st(v, V3D_PE_ALUMODE, 0xC);
+	v3d_st(v, V3D_PE_ZBUFMODE, 0);
+	v3d_st(v, V3D_PE_ZBUFWRMODE, 0);
+	v3d_emit1(v, (20 << 16) | V3D_GL_TRIANGLE);	/* KXYZUVQ */
+	for (i = 0; i < 3; i++)
+		for (k = 0; k < 9; k++)
+			v3d_emitf(v, seed[i][k]);
+
+	v3d_st(v, V3D_PE_DSTBASE, dst_base);
+	v3d_st(v, 59, reg59);			/* DstStride dual-shift */
+	v3d_st(v, V3D_PE_DSTFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | (uint32_t)dst_w);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | (uint32_t)v->height);
+	v3d_st(v, V3D_PE_PMASK, 0xFFFFFFFF);
+	v3d_st(v, 62, 0);			/* UClamp off */
+	v3d_st(v, 63, 0);			/* VClamp off */
+	v3d_st(v, V3D_PE_ALUMODE, 0xC);
+	v3d_st(v, V3D_PE_BLENDENABLE, 0);
+	v3d_st(v, V3D_PE_DSTRDDIS, 0);
+	v3d_st(v, 76, 0);			/* TranspReject off */
+	b[0] = 30;				/* microcode bitblt */
+	b[1] = ((uint32_t)dx << 16) | (uint32_t)dy;
+	b[2] = ((uint32_t)w << 16) | (uint32_t)h;
+	b[3] = 0;				/* srcX=srcY=0 (base pre-offset) */
+	v3d_emit(v, b, 4);
+
+	v3d_st(v, V3D_PE_STRIDE, v->pe_stride | ((v->pe_stride >> 8) << 16));
+	v3d_st(v, V3D_PE_DSTBASE, rl->fb[rl->back]);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | v->width);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | v->height);
+	rl->cur_tex = (uint32_t)-1;
+	rl->cur_func = -1;
+	return 0;
+}
+
+int
+rlgl_copy_to_tex(struct rlgl *rl, uint32_t fb_base, int fb_h,
+    uint32_t tex_base, int tex_aw, int sx, int sy_gl, int dx, int dy,
+    int w, int h)
+{
+	struct v3d *v = &rl->v;
+	uint32_t fs0, fs1, ts0, ts1, reg58, reg59, c[6], b[4];
+	static const float seed[3][9] = {
+		{ 255, 255, 255,  0, 0, 100,  0, 0, 1 },
+		{ 255, 255, 255,  2, 0, 100,  0, 0, 1 },
+		{ 255, 255, 255,  0, 2, 100,  0, 0, 1 },
+	};
+	int i, k, j;
+
+	if (w <= 0 || h <= 0)
+		return 0;
+	if (stride_codes((uint32_t)v->width * 2, &fs0, &fs1) != 0 ||
+	    stride_codes((uint32_t)tex_aw * 2, &ts0, &ts1) != 0)
+		return -1;
+	reg58 = (fs1 << 4) | fs0;		/* fb SrcStride */
+	reg59 = (ts1 << 12) | (ts0 << 8);	/* texture DstStride */
+
+	c[0] = (4 << 12) | V3D_PE_SRCBASE;
+	c[1] = fb_base;
+	c[2] = reg58;
+	c[3] = (0x7FFu << 16) | 0x7FFu;
+	c[4] = 0x10000;
+	c[5] = 0x10000;
+	v3d_emit(v, c, 6);
+	v3d_st(v, V3D_PE_SRCFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SRCFUNC, 1 << 4);	/* REPLACE */
+	v3d_st(v, V3D_PE_SRCFILTER, 0);		/* point / BitBlt */
+	v3d_st(v, V3D_PE_DSTBASE, rl->scratch);
+	v3d_st(v, 59, 0x0100);			/* scratch DstStride 256B */
+	v3d_st(v, V3D_PE_DSTFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | 128);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | 8);
+	v3d_st(v, V3D_PE_ALUMODE, 0xC);
+	v3d_st(v, V3D_PE_ZBUFMODE, 0);
+	v3d_st(v, V3D_PE_ZBUFWRMODE, 0);
+	v3d_emit1(v, (20 << 16) | V3D_GL_TRIANGLE);
+	for (i = 0; i < 3; i++)
+		for (k = 0; k < 9; k++)
+			v3d_emitf(v, seed[i][k]);
+
+	/* dest state = the texture surface */
+	v3d_st(v, V3D_PE_DSTBASE, tex_base);
+	v3d_st(v, 59, reg59);
+	v3d_st(v, V3D_PE_DSTFMT, RLGL_FMT_565);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | (uint32_t)tex_aw);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | (uint32_t)(dy + h));
+	v3d_st(v, V3D_PE_PMASK, 0xFFFFFFFF);
+	v3d_st(v, 62, 0);
+	v3d_st(v, 63, 0);
+	v3d_st(v, V3D_PE_ALUMODE, 0xC);
+	v3d_st(v, V3D_PE_BLENDENABLE, 0);
+	v3d_st(v, V3D_PE_DSTRDDIS, 0);
+	v3d_st(v, 76, 0);
+
+	for (j = 0; j < h; j++) {
+		b[0] = 30;
+		b[1] = ((uint32_t)dx << 16) | (uint32_t)(dy + j);
+		b[2] = ((uint32_t)w << 16) | 1u;
+		b[3] = ((uint32_t)sx << 16) |
+		    (uint32_t)(fb_h - 1 - sy_gl - j);
+		v3d_emit(v, b, 4);
+	}
+
+	/* restore persistent draw state (see rlgl_copy_rect) */
+	v3d_st(v, V3D_PE_STRIDE, v->pe_stride | ((v->pe_stride >> 8) << 16));
+	v3d_st(v, V3D_PE_DSTBASE, rl->fb[rl->back]);
+	v3d_st(v, V3D_PE_SCISSORX, (0u << 16) | v->width);
+	v3d_st(v, V3D_PE_SCISSORY, (0u << 16) | v->height);
+	rl->cur_tex = (uint32_t)-1;
+	rl->cur_func = -1;
+	return 0;
+}
+
+void
+rlgl_clear(struct rlgl *rl, int color, uint32_t rgb565, int depth)
+{
+	struct v3d *v = &rl->v;
+	uint32_t val = rgb565 | (rgb565 << 16);
+
+	/* spec 2.8: clamps must be off for parallel-draw fills */
+	rlgl_tex_wrap(rl, 0, 0);
+	if (color)
+		v3d_clear(v, rl->fb[rl->back], v->stride, v->width * 2,
+		    v->height, val);
+	if (depth)
+		v3d_clear(v, rl->zbuf, v->stride, v->width * 2,
+		    v->height, 0xFFFFFFFFU);
+}
+
+/*
+ * Blit one row of w 565 pixels to the back buffer at window (x, wy).
+ */
+int
+rlgl_draw_row(struct rlgl *rl, int x, int wy, int w, const uint16_t *row565)
+{
+	struct v3d *v = &rl->v;
+	static uint32_t buf[2048 / 2];
+	uint32_t fbrow;
+	int i;
+
+	if ((x & 1) || (w & 1) || w <= 0 || w > 2048 ||
+	    wy < 0 || wy >= (int)v->height || x < 0 || x + w > (int)v->width)
+		return -1;
+	fbrow = (uint32_t)((int)v->height - 1 - wy);
+	for (i = 0; i < w; i += 2)
+		buf[i / 2] = ((uint32_t)row565[i] << 16) | (uint32_t)row565[i + 1];
+	return v3d_upload(v, rl->fb[rl->back] + fbrow * v->stride +
+	    (uint32_t)x * 2, buf, (uint32_t)w * 2);
+}
+
+void
+rlgl_tri(struct rlgl *rl, const struct rlgl_vtx *a,
+    const struct rlgl_vtx *b, const struct rlgl_vtx *c)
+{
+	struct v3d *v = &rl->v;
+	const struct rlgl_vtx *p[3];
+	int i;
+
+	p[0] = a; p[1] = b; p[2] = c;
+	rl->tris++;
+	/*
+	 * KXYZUVQ (type 20) normally, with fog on, KFXYZUVQ (type 23)
+	 */
+	v3d_emit1(v, ((rl->fog_on ? 23 : 20) << 16) | V3D_GL_TRIANGLE);
+	for (i = 0; i < 3; i++) {
+		v3d_emitf(v, p[i]->r);
+		v3d_emitf(v, p[i]->g);
+		v3d_emitf(v, p[i]->b);
+		if (rl->fog_on)
+			v3d_emitf(v, p[i]->f);
+		v3d_emitf(v, p[i]->x);
+		v3d_emitf(v, p[i]->y);
+		v3d_emitf(v, p[i]->z);
+		v3d_emitf(v, p[i]->u);
+		v3d_emitf(v, p[i]->v);
+		v3d_emitf(v, p[i]->q);
+	}
+}
+
+/*
+ * Native hardware lines.
+ */
+static void
+rlgl_emit_line(struct rlgl *rl, uint32_t cmd, const struct rlgl_vtx *a,
+    const struct rlgl_vtx *b)
+{
+	struct v3d *v = &rl->v;
+	const struct rlgl_vtx *p[2];
+	int i;
+
+	p[0] = a; p[1] = b;
+	v3d_emit1(v, (8 << 16) | cmd);		/* KXYZ (type 8) */
+	for (i = 0; i < 2; i++) {
+		v3d_emitf(v, p[i]->r);
+		v3d_emitf(v, p[i]->g);
+		v3d_emitf(v, p[i]->b);
+		v3d_emitf(v, p[i]->x);
+		v3d_emitf(v, p[i]->y);
+		v3d_emitf(v, p[i]->z);
+	}
+}
+
+void
+rlgl_line(struct rlgl *rl, const struct rlgl_vtx *a, const struct rlgl_vtx *b)
+{
+
+	rl->tris++;
+	rlgl_emit_line(rl, V3D_GL_LINE, a, b);
+}
+
+void
+rlgl_aaline(struct rlgl *rl, const struct rlgl_vtx *a, const struct rlgl_vtx *b)
+{
+
+	rl->tris++;
+	rlgl_emit_line(rl, V3D_GL_AALINE, a, b);
+}
+
+/*
+ * Anti-aliased points (GL_POINT_SMOOTH) via microcode aapoint (cmd 50).
+ */
+#define RLGL_PTTEX_DIM		32
+#define RLGL_PTTEX_USCALE	0x1F8000	/* ~31.5 in 16.16 -> span [0,1] */
+
+static int
+rlgl_pt_tex_ensure(struct rlgl *rl)
+{
+	static uint16_t tex[RLGL_PTTEX_DIM * RLGL_PTTEX_DIM];
+	const float c = RLGL_PTTEX_DIM / 2.0f - 0.5f;	/* texel centre */
+	const float rad = RLGL_PTTEX_DIM / 2.0f - 1.5f;	/* disc radius */
+	int x, y;
+
+	if (rl->pt_tex.addr != 0)
+		return 0;
+	if (rlgl_tex_create(rl, &rl->pt_tex, RLGL_PTTEX_DIM, RLGL_PTTEX_DIM,
+	    RLGL_FMT_4444) != 0)
+		return -1;
+	for (y = 0; y < RLGL_PTTEX_DIM; y++)
+		for (x = 0; x < RLGL_PTTEX_DIM; x++) {
+			float dx = (float)x - c, dy = (float)y - c;
+			float d2 = dx * dx + dy * dy;	/* no sqrt: compare r^2 */
+			int a;
+
+			/*
+			 * Radial alpha: opaque core, a several-texel linear
+			 * coverage ramp at the rim
+			 */
+			const float ramp = 3.0f;		/* rim width, texels */
+			if (d2 <= (rad - ramp) * (rad - ramp))
+				a = 15;				/* opaque core */
+			else if (d2 >= rad * rad)
+				a = 0;				/* transparent */
+			else {
+				/* linear in true distance across [rad-ramp,rad] */
+				float d = (d2 - (rad - ramp) * (rad - ramp)) /
+				    ((rad * rad) - (rad - ramp) * (rad - ramp));
+				a = (int)(15.0f * (1.0f - d) + 0.5f);
+				if (a < 0) a = 0;
+				if (a > 15) a = 15;
+			}
+			/* ARGB4444: alpha = coverage, RGB = white */
+			tex[y * RLGL_PTTEX_DIM + x] =
+			    (uint16_t)((a << 12) | 0x0FFF);
+		}
+	return rlgl_tex_upload(rl, &rl->pt_tex, tex);
+}
+
+void
+rlgl_aapoint_begin(struct rlgl *rl)
+{
+	struct v3d *v = &rl->v;
+	static const float seed[3][9] = {
+		{ 255, 255, 255,  1, 1, 100,  0, 0, 1 },
+		{ 255, 255, 255,  3, 1, 100,  0, 0, 1 },
+		{ 255, 255, 255,  1, 3, 100,  0, 0, 1 },
+	};
+	int i, k;
+
+	if (rlgl_pt_tex_ensure(rl) != 0)
+		return;
+	/* bind the coverage texture, uscale/vscale map [0,1] over any size */
+	v3d_texbind(v, rl->pt_tex.addr, rl->pt_tex.srcstride,
+	    rl->pt_tex.w, rl->pt_tex.h, RLGL_PTTEX_USCALE, RLGL_PTTEX_USCALE);
+	v3d_st(v, V3D_PE_SRCFMT, RLGL_FMT_4444);
+	v3d_st(v, V3D_PE_SRCFILTER, 1 << 7);	/* bilinear: smooth the rim */
+	rl->cur_tex = rl->pt_tex.addr;
+	set_srcfunc(rl, RLGL_ENV_MODULATE);	/* colour = FGColor x white tex,
+						 * SrcAlpha = TexAlpha (coverage)
+						 * x FGColor-alpha (0xff) */
+	v3d_st(v, V3D_PE_ZBUFMODE, 0);
+	v3d_st(v, V3D_PE_ZBUFWRMODE, 0);
+	v3d_emit1(v, (20 << 16) | V3D_GL_TRIANGLE);	/* KXYZUVQ */
+	for (i = 0; i < 3; i++)
+		for (k = 0; k < 9; k++)
+			v3d_emitf(v, seed[i][k]);
+}
+
+void
+rlgl_aapoint(struct rlgl *rl, const struct rlgl_vtx *a, float size)
+{
+	struct v3d *v = &rl->v;
+	int r = (int)(a->r + 0.5f), g = (int)(a->g + 0.5f);
+	int b = (int)(a->b + 0.5f);
+	uint32_t fg;
+
+	if (r < 0) r = 0; if (r > 255) r = 255;
+	if (g < 0) g = 0; if (g > 255) g = 255;
+	if (b < 0) b = 0; if (b > 255) b = 255;
+	/* FGColor 0xAARRGGBB: alpha 0xff so MODULATE SrcAlpha = TexAlpha */
+	fg = 0xFF000000u | ((uint32_t)r << 16) | ((uint32_t)g << 8) |
+	    (uint32_t)b;
+	rl->tris++;
+	v3d_st(v, V3D_PE_FGCOLOR, fg);
+	v3d_emit1(v, (8 << 16) | V3D_GL_AAPOINT);	/* KXYZ */
+	v3d_emitf(v, size);				/* diameter */
+	v3d_emitf(v, a->r); v3d_emitf(v, a->g); v3d_emitf(v, a->b);
+	v3d_emitf(v, a->x); v3d_emitf(v, a->y); v3d_emitf(v, a->z);
+}
+
+void
+rlgl_aapoint_end(struct rlgl *rl)
+{
+
+	/* release the coverage-texture bind: force the next textured draw to
+	 * rebind (which re-selects its own filter/env), and untextured draws
+	 * to re-select NOTEXTURE; drop the bilinear filter we forced. */
+	v3d_st(&rl->v, V3D_PE_SRCFILTER, 0);
+	rl->cur_tex = 0;
+	set_srcfunc(rl, 0);
+}
+
+/*
+ * Emit one KXYZUVQ (or KFXYZUVQ when fog_on) vertex record
+ */
+static void
+rlgl_emit_vtx(struct v3d *v, const struct rlgl_vtx *p, int fog_on)
+{
+
+	v3d_emitf(v, p->r);
+	v3d_emitf(v, p->g);
+	v3d_emitf(v, p->b);
+	if (fog_on)
+		v3d_emitf(v, p->f);
+	v3d_emitf(v, p->x);
+	v3d_emitf(v, p->y);
+	v3d_emitf(v, p->z);
+	v3d_emitf(v, p->u);
+	v3d_emitf(v, p->v);
+	v3d_emitf(v, p->q);
+}
+
+/*
+ * Native strip/fan common core.
+ */
+static void
+rlgl_emit_run(struct rlgl *rl, uint32_t startcmd, uint32_t contword,
+    const struct rlgl_vtx *v, int n)
+{
+	struct v3d *vv = &rl->v;
+	int i;
+
+	if (n < 3)
+		return;
+	v3d_emit1(vv, ((rl->fog_on ? 23 : 20) << 16) | startcmd);
+	rlgl_emit_vtx(vv, &v[0], rl->fog_on);
+	rlgl_emit_vtx(vv, &v[1], rl->fog_on);
+	rlgl_emit_vtx(vv, &v[2], rl->fog_on);
+	for (i = 3; i < n; i++) {
+		v3d_emit1(vv, contword);
+		rlgl_emit_vtx(vv, &v[i], rl->fog_on);
+	}
+	rl->tris += (uint64_t)(n - 2);
+}
+
+void
+rlgl_tristrip(struct rlgl *rl, const struct rlgl_vtx *v, int n)
+{
+
+	rlgl_emit_run(rl, V3D_GL_TRISTRIP, V3D_GL_STRIP_CONT, v, n);
+}
+
+void
+rlgl_trifan(struct rlgl *rl, const struct rlgl_vtx *v, int n)
+{
+
+	rlgl_emit_run(rl, V3D_GL_TRIFAN, V3D_GL_FAN_CONT, v, n);
+}
+
+void
+rlgl_tris_idx(struct rlgl *rl, const float *verts9, const uint8_t *idx,
+    int ntris)
+{
+	struct v3d *v = &rl->v;
+	uint32_t *p;
+
+	if (ntris <= 0)
+		return;
+	p = v3d_reserve(v, (uint32_t)ntris * 28);
+	if (p == NULL)
+		return;
+	(void)rlvec.emit_tris(p, verts9, idx, ntris,
+	    (20 << 16) | V3D_GL_TRIANGLE);		/* KXYZUVQ */
+	v3d_commit(v, (uint32_t)ntris * 28);
+	rl->tris += (uint64_t)ntris;
+}
+
+int
+rlgl_finish(struct rlgl *rl)
+{
+
+	return v3d_sync(&rl->v);
+}
+
+int
+rlgl_swap(struct rlgl *rl)
+{
+	struct v3d *v = &rl->v;
+
+	if (!v->opt_nosync) {
+		if (v3d_sync(v) != 0)
+			return -1;
+	}
+	if (v3d_flip(v, rl->fb[rl->back]) != 0)
+		return -1;
+	rl->back ^= 1;
+	v3d_st(v, V3D_PE_DSTBASE, rl->fb[rl->back]);
+	rl->frames++;
+
+	if (v->opt_stats) {
+		uint64_t now = v3d_now_ns();
+
+		if (rl->last_swap_ns != 0) {
+			uint64_t d = now - rl->last_swap_ns;
+
+			rl->frame_ns_tot += d;
+			if (rl->frame_ns_min == 0 || d < rl->frame_ns_min)
+				rl->frame_ns_min = d;
+			if (d > rl->frame_ns_max)
+				rl->frame_ns_max = d;
+		}
+		rl->last_swap_ns = now;
+		/*
+		 * Cumulative snapshot lines: diffing two RLGLSNAPs
+		 * isolates the demo window from load/console frames.
+		 */
+		if (v->opt_stats >= 2 && (rl->frames & 127) == 0)
+			printf("RLGLSNAP frames=%d ns=%llu submit_ns=%llu "
+			    "sync_ns=%llu flip_ns=%llu submits=%llu "
+			    "bytes=%llu tris=%llu uploads=%llu "
+			    "upl_bytes=%llu\n",
+			    rl->frames,
+			    (unsigned long long)rl->frame_ns_tot,
+			    (unsigned long long)v->st.submit_ns,
+			    (unsigned long long)v->st.sync_ns,
+			    (unsigned long long)v->st.flip_ns,
+			    (unsigned long long)v->st.submits,
+			    (unsigned long long)v->st.submit_bytes,
+			    (unsigned long long)rl->tris,
+			    (unsigned long long)v->st.uploads,
+			    (unsigned long long)v->st.upload_bytes);
+	}
+	return 0;
+}
+
+void
+rlgl_stats_print(struct rlgl *rl)
+{
+	struct v3d_stats *s = &rl->v.st;
+	double nf = rl->frames > 0 ? (double)rl->frames : 1.0;
+	double ms = 1e6;
+
+	if (rl->stats_printed)
+		return;
+	rl->stats_printed = 1;
+	printf("RLGL frames=%d tris=%llu submits=%llu syncs=%llu "
+	    "flips=%llu\n", rl->frames,
+	    (unsigned long long)rl->tris,
+	    (unsigned long long)s->submits,
+	    (unsigned long long)s->syncs,
+	    (unsigned long long)s->flips);
+	printf("RLGL words=%llu submit_bytes=%llu uploads=%llu "
+	    "upload_bytes=%llu st_calls=%llu texbinds=%llu\n",
+	    (unsigned long long)s->words,
+	    (unsigned long long)s->submit_bytes,
+	    (unsigned long long)s->uploads,
+	    (unsigned long long)s->upload_bytes,
+	    (unsigned long long)s->st_calls,
+	    (unsigned long long)s->texbinds);
+	printf("RLGL per_frame tris=%.1f submits=%.2f bytes=%.0f "
+	    "upload_bytes=%.0f\n", (double)rl->tris / nf,
+	    (double)s->submits / nf, (double)s->submit_bytes / nf,
+	    (double)s->upload_bytes / nf);
+	if (rl->v.opt_stats && rl->frames > 1) {
+		double blocked = (double)(s->submit_ns + s->sync_ns +
+		    s->flip_ns);
+		double tot = (double)rl->frame_ns_tot;
+		/* first swap has no predecessor: nf-1 timed frames */
+		double tf = (double)(rl->frames - 1);
+
+		printf("RLGL avg_frame_ms=%.2f min=%.2f max=%.2f\n",
+		    tot / tf / ms,
+		    (double)rl->frame_ns_min / ms,
+		    (double)rl->frame_ns_max / ms);
+		printf("RLGL avg_submit_ms=%.2f avg_sync_ms=%.2f "
+		    "avg_flip_ms=%.2f avg_blocked_ms=%.2f "
+		    "avg_build_ms=%.2f\n",
+		    (double)s->submit_ns / nf / ms,
+		    (double)s->sync_ns / nf / ms,
+		    (double)s->flip_ns / nf / ms,
+		    blocked / nf / ms,
+		    (tot / tf - blocked / nf) / ms);
+	}
+}