Initial import.

1 files changed, 1085 insertions, 0 deletions

diff --git a/src/mesa/drivers/verite/vrtris.c b/src/mesa/drivers/verite/vrtris.c
new file mode 100644
index 0000000..48c270f
--- /dev/null
+++ b/src/mesa/drivers/verite/vrtris.c
@@ -0,0 +1,1085 @@
+/*
+ * 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.
+ */
+
+/*
+ * veritemesa hardware triangles.
+ */
+
+#include <math.h>
+#include <stdlib.h>
+
+#include "vrdrv.h"
+
+#include "context.h"
+#include "imports.h"
+#include "macros.h"
+#include "colormac.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "swrast_setup/ss_context.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+
+static unsigned long g_vr_nat_polys, g_vr_nat_tris;
+static unsigned long g_vr_pt_polys, g_vr_pt_tris;
+static unsigned long g_vr_cb_tris;
+
+static int g_vr_nocache;
+static int g_vr_noblendfan;
+static float g_vr_zbias;
+
+/*
+ * Window-Z finalizer.
+ */
+#define VR_ZSCALE	(65000.0F / 65535.0F)
+
+static GLfloat
+vr_winz(GLfloat mesa_z)
+{
+	GLfloat z = mesa_z * VR_ZSCALE;
+
+	if (z < 0.0F)
+		return 0.0F;
+	if (z > 65000.0F)
+		return 65000.0F;
+	return z;
+}
+
+static void
+vr_emit_at(vrmesa_context *vmesa, GLfloat wx, GLfloat wy,
+    const SWvertex *v, const GLchan color[4], struct rlgl_vtx *o)
+{
+	const GLfloat w = (GLfloat)vmesa->rl.v.width;
+	const GLfloat h = (GLfloat)vmesa->rl.v.height;
+	GLfloat x = wx, y;
+
+	o->r = (GLfloat)color[0];
+	o->g = (GLfloat)color[1];
+	o->b = (GLfloat)color[2];
+
+	if (x < 0.0F) x = 0.0F;
+	if (x > w) x = w;
+	o->x = x;
+	y = h - wy;
+	if (y < 0.0F) y = 0.0F;
+	if (y > h) y = h;
+	o->y = y;
+	o->z = vr_winz(v->win[2]);	/* rescale 65535->65000, see vr_winz */
+	/*
+	 * u/v in texels, q = 1/w
+	 */
+	if (vmesa->tex_on) {
+		o->u = v->texcoord[0][0] * vmesa->tex_w - vmesa->tex_off;
+		o->v = v->texcoord[0][1] * vmesa->tex_h - vmesa->tex_off;
+	} else {
+		o->u = 0.0F;
+		o->v = 0.0F;
+	}
+	o->q = v->win[3];
+	/*
+	 * Fog factor for the KFXYZUVQ path.
+	 */
+	o->f = CLAMP(v->fog, 0.0F, 1.0F) * 255.0F;
+}
+
+static void
+vr_emit_vtx(vrmesa_context *vmesa, const SWvertex *v,
+    const GLchan color[4], struct rlgl_vtx *o)
+{
+
+	vr_emit_at(vmesa, v->win[0], v->win[1], v, color, o);
+}
+
+/*
+ * PE blend factor mapping
+ */
+static GLboolean
+vr_blend_factor(GLenum f, GLboolean is_src, GLuint *code,
+    GLboolean *needs_alpha)
+{
+
+	switch (f) {
+	case GL_ZERO:			*code = RLGL_BL_ZERO; break;
+	case GL_ONE:			*code = RLGL_BL_ONE; break;
+	case GL_DST_ALPHA:		*code = RLGL_BL_ONE; break;
+	case GL_ONE_MINUS_DST_ALPHA:	*code = RLGL_BL_ZERO; break;
+	case GL_SRC_ALPHA:
+		*code = RLGL_BL_SRCALPHA;
+		*needs_alpha = GL_TRUE;
+		break;
+	case GL_ONE_MINUS_SRC_ALPHA:
+		*code = RLGL_BL_INVSRCALPHA;
+		*needs_alpha = GL_TRUE;
+		break;
+	/*
+	 * Color-factor codes are SIDE-RELATIVE
+	 */
+	case GL_SRC_COLOR:
+		*code = is_src ? RLGL_BL_OWNCOLOR : RLGL_BL_OTHERCOLOR;
+		break;
+	case GL_ONE_MINUS_SRC_COLOR:
+		*code = is_src ? RLGL_BL_INVOWNCOLOR :
+		    RLGL_BL_INVOTHERCOLOR;
+		break;
+	case GL_DST_COLOR:
+		*code = is_src ? RLGL_BL_OTHERCOLOR : RLGL_BL_OWNCOLOR;
+		break;
+	case GL_ONE_MINUS_DST_COLOR:
+		*code = is_src ? RLGL_BL_INVOTHERCOLOR :
+		    RLGL_BL_INVOWNCOLOR;
+		break;
+	default:
+		return GL_FALSE;
+	}
+	return GL_TRUE;
+}
+
+GLboolean
+vrBlendMap(const GLcontext *ctx, GLuint *srcf, GLuint *dstf,
+    GLboolean *needs_alpha)
+{
+
+	*needs_alpha = GL_FALSE;
+	if (ctx->Color.BlendEquationRGB != GL_FUNC_ADD)
+		return GL_FALSE;
+	if (!vr_blend_factor(ctx->Color.BlendSrcRGB, GL_TRUE, srcf,
+	    needs_alpha))
+		return GL_FALSE;
+	if (!vr_blend_factor(ctx->Color.BlendDstRGB, GL_FALSE, dstf,
+	    needs_alpha))
+		return GL_FALSE;
+	return GL_TRUE;
+}
+
+/*
+ * Clamp a Mesa-space window Z
+ */
+static GLfloat
+vr_clampz(GLfloat z)
+{
+
+	if (z < 0.0F)
+		return 0.0F;
+	if (z > 65535.0F)
+		return 65535.0F;
+	return z;
+}
+
+/*
+ * Polygon offset (glPolygonOffset) computed exactly as swrast does at
+ * setup
+ */
+static GLfloat
+vr_poly_offset(GLcontext *ctx, const SWvertex *v0, const SWvertex *v1,
+    const SWvertex *v2)
+{
+	GLfloat ex = v0->win[0] - v2->win[0], ey = v0->win[1] - v2->win[1];
+	GLfloat fx = v1->win[0] - v2->win[0], fy = v1->win[1] - v2->win[1];
+	GLfloat cc = ex * fy - ey * fx;
+	GLfloat off = ctx->Polygon.OffsetUnits;		/* * MRD (= 1) */
+
+	if (cc * cc > 1e-16F) {
+		GLfloat ez = v0->win[2] - v2->win[2];
+		GLfloat fz = v1->win[2] - v2->win[2];
+		GLfloat ooa = 1.0F / cc;
+		GLfloat dzdx = (ey * fz - ez * fy) * ooa;
+		GLfloat dzdy = (ez * fx - ex * fz) * ooa;
+		GLfloat m, nz;
+
+		if (dzdx < 0.0F) dzdx = -dzdx;
+		if (dzdy < 0.0F) dzdy = -dzdy;
+		m = dzdx > dzdy ? dzdx : dzdy;
+		off += m * ctx->Polygon.OffsetFactor;
+		/* clamp so no vertex Z goes below 0 (matches swrast) */
+		nz = -v0->win[2]; if (off < nz) off = nz;
+		nz = -v1->win[2]; if (off < nz) off = nz;
+		nz = -v2->win[2]; if (off < nz) off = nz;
+	}
+	return off;
+}
+
+static void
+vr_tri(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2, GLuint eprov)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	const SWvertex *v0 = &verts[e0], *v1 = &verts[e1], *v2 = &verts[e2];
+	struct rlgl_vtx a, b, c;
+	const GLboolean flat = (ctx->Light.ShadeModel == GL_FLAT);
+	const GLchan *pc = verts[eprov].color;
+
+	if (vmesa->blend_alpha || vmesa->atest_alpha) {
+		GLuint a8 = flat ? pc[3] : v0->color[3];
+
+		if (!flat && (v1->color[3] != a8 || v2->color[3] != a8)) {
+			VRP_FALLBACK_HOT(VRP_FB_TRI_ALPHAGRAD);
+			_swrast_Triangle(ctx, v0, v1, v2);
+			return;
+		}
+		if (a8 != vmesa->fg_alpha) {
+			v3d_st(&vmesa->rl.v, V3D_PE_FGCOLOR, a8 << 24);
+			vmesa->fg_alpha = a8;
+			VRP_HOT(fgcolor_writes);
+		}
+	}
+
+	if (ctx->Polygon.CullFlag) {
+		/* window y is flipped on the PE: GL-CCW = negative area */
+		GLfloat area =
+		    (v1->win[0] - v0->win[0]) * (v0->win[1] - v2->win[1]) -
+		    (v2->win[0] - v0->win[0]) * (v0->win[1] - v1->win[1]);
+		GLboolean front = (area < 0.0F) ^
+		    (ctx->Polygon.FrontFace == GL_CW);
+
+		if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
+			return;
+		if (ctx->Polygon.CullFaceMode == GL_BACK && !front)
+			return;
+		if (ctx->Polygon.CullFaceMode == GL_FRONT && front)
+			return;
+	}
+
+	/*
+	 * Per-polygon mipmapping
+	 */
+	if (vmesa->tex_on && vmesa->tex_mip) {
+		const GLfloat bw = vmesa->tex_base_w;
+		const GLfloat bh = vmesa->tex_base_h;
+		GLfloat du1 = (v1->texcoord[0][0] - v0->texcoord[0][0]) * bw;
+		GLfloat dv1 = (v1->texcoord[0][1] - v0->texcoord[0][1]) * bh;
+		GLfloat du2 = (v2->texcoord[0][0] - v0->texcoord[0][0]) * bw;
+		GLfloat dv2 = (v2->texcoord[0][1] - v0->texcoord[0][1]) * bh;
+		GLfloat auv = du1 * dv2 - du2 * dv1;
+		GLfloat axy =
+		    (v1->win[0] - v0->win[0]) * (v2->win[1] - v0->win[1]) -
+		    (v2->win[0] - v0->win[0]) * (v1->win[1] - v0->win[1]);
+		GLfloat rho2;
+		GLint level = 0, nl = vrTexNumLevels(vmesa->tex_cur);
+		GLint bilin;
+		GLint lw, lh;
+
+		if (auv < 0.0F) auv = -auv;
+		if (axy < 0.0F) axy = -axy;
+		rho2 = (axy > 1e-12F) ? auv / axy : 0.0F;
+		if (rho2 > 1.0F) {
+			GLfloat lod = 0.5F * LOG2(rho2);
+
+			level = (GLint)(lod + 0.5F);
+			if (level >= nl)
+				level = nl - 1;
+		}
+		bilin = (level == 0 && rho2 <= 1.0F) ?
+		    vmesa->tex_mag_bilin : vmesa->tex_min_bilin;
+		if (g_vr_nocache || level != vmesa->cur_level) {
+			rlgl_tex_bind(&vmesa->rl,
+			    vrTexLevel(vmesa->tex_cur, level));
+			vmesa->cur_level = level;
+			VRP_HOT(mip_binds);
+		}
+		if (g_vr_nocache || bilin != vmesa->cur_bilin) {
+			rlgl_tex_filter(&vmesa->rl, bilin);
+			vmesa->cur_bilin = bilin;
+			VRP_HOT(filt_changes);
+		}
+		lw = (GLint)bw >> level;
+		lh = (GLint)bh >> level;
+		vmesa->tex_w = (GLfloat)(lw > 0 ? lw : 1);
+		vmesa->tex_h = (GLfloat)(lh > 0 ? lh : 1);
+		vmesa->tex_off = bilin ? 0.5F : 0.0F;
+	}
+
+	VRP_ZE3(VRP_Z_TRI_EMIT);
+	vr_emit_vtx(vmesa, v0, flat ? pc : v0->color, &a);
+	vr_emit_vtx(vmesa, v1, flat ? pc : v1->color, &b);
+	vr_emit_vtx(vmesa, v2, flat ? pc : v2->color, &c);
+	/* polygon offset: per-poly window-Z bias over the emitted z */
+	if (ctx->Polygon.OffsetFill) {
+		GLfloat off = vr_poly_offset(ctx, v0, v1, v2);
+
+		a.z = vr_winz(v0->win[2] + off);
+		b.z = vr_winz(v1->win[2] + off);
+		c.z = vr_winz(v2->win[2] + off);
+	}
+	rlgl_tri(&vmesa->rl, &a, &b, &c);
+	vmesa->engine_dirty = GL_TRUE;
+	VRP_ZX3(VRP_Z_TRI_EMIT);
+}
+
+static void
+vr_triangle(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2)
+{
+
+	g_vr_cb_tris++;			/* clipped path / any Render.Triangle caller */
+	vr_tri(ctx, e0, e1, e2, e2);
+}
+
+static void
+vr_quad(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2, GLuint e3)
+{
+
+	vr_tri(ctx, e0, e1, e2, e3);
+	vr_tri(ctx, e0, e2, e3, e3);
+}
+
+/* longest run collapsed to one native fan/strip, larger falls to per-tri */
+#define VR_MAX_RUN	128
+
+static void
+vr_strip_stat(void)
+{
+
+	if (_mesa_getenv("VRMESA_STRIPSTAT"))
+		_mesa_printf("VRSTRIP native_polys=%lu native_tris=%lu "
+		    "pertri_polys=%lu pertri_tris=%lu clipped_tris=%lu\n",
+		    g_vr_nat_polys, g_vr_nat_tris, g_vr_pt_polys, g_vr_pt_tris,
+		    g_vr_cb_tris);
+}
+
+static GLuint
+vidx(const GLuint *elt, GLuint j)
+{
+
+	return elt ? elt[j] : j;
+}
+
+static GLboolean
+vr_native_run(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count,
+    GLboolean cull_uniform, GLuint flat_prov)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	const GLchan *fc = (flat_prov != ~0U) ?
+	    verts[vidx(elt, flat_prov)].color : NULL;
+	struct rlgl_vtx buf[VR_MAX_RUN];
+	GLuint n = count - start, i;
+
+	if (n < 3 || n > VR_MAX_RUN)
+		return GL_FALSE;
+	if (ctx->Polygon.CullFlag) {
+		const SWvertex *v0, *v1, *v2;
+		GLfloat area;
+		GLboolean front;
+
+		/*
+		 * A tri-strip's winding alternates per triangle, and a
+		 * non-convex tri-fan's can flip
+		 */
+		if (!cull_uniform)
+			return GL_FALSE;
+		v0 = &verts[vidx(elt, start)];
+		v1 = &verts[vidx(elt, start + 1)];
+		v2 = &verts[vidx(elt, start + 2)];
+		area = (v1->win[0] - v0->win[0]) * (v0->win[1] - v2->win[1]) -
+		    (v2->win[0] - v0->win[0]) * (v0->win[1] - v1->win[1]);
+		front = (area < 0.0F) ^ (ctx->Polygon.FrontFace == GL_CW);
+		if (ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
+			return GL_TRUE;			/* whole run culled */
+		if (ctx->Polygon.CullFaceMode == GL_BACK && !front)
+			return GL_TRUE;
+		if (ctx->Polygon.CullFaceMode == GL_FRONT && front)
+			return GL_TRUE;
+	}
+	for (i = 0; i < n; i++) {
+		const SWvertex *v = &verts[vidx(elt, start + i)];
+
+		vr_emit_vtx(vmesa, v, fc ? fc : v->color, &buf[i]);
+		if (g_vr_zbias != 0.0F) {
+			buf[i].z -= g_vr_zbias;
+			if (buf[i].z < 0.0F)
+				buf[i].z = 0.0F;
+		}
+	}
+	rlgl_trifan(&vmesa->rl, buf, (int)n);
+	g_vr_nat_polys++;
+	g_vr_nat_tris += n - 2;
+	vmesa->engine_dirty = GL_TRUE;
+	return GL_TRUE;
+}
+
+static void
+vr_c_triangles(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	GLuint j;
+
+	for (j = start + 2; j < count; j += 3)
+		vr_tri(ctx, vidx(elt, j - 2), vidx(elt, j - 1), vidx(elt, j),
+		    vidx(elt, j));
+}
+
+static void
+vr_c_tri_strip(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	GLuint j, parity = 0;
+
+	for (j = start + 2; j < count; j++, parity ^= 1)
+		vr_tri(ctx, vidx(elt, j - 2 + parity), vidx(elt, j - 1 - parity),
+		    vidx(elt, j), vidx(elt, j));
+}
+
+static void
+vr_c_tri_fan(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	GLuint j;
+
+	if (vmesa->strips_ok && ctx->Light.ShadeModel == GL_SMOOTH &&
+	    vr_native_run(ctx, elt, start, count, GL_FALSE, ~0U))
+		return;
+	g_vr_pt_polys++;
+	g_vr_pt_tris += count - start - 2;
+	for (j = start + 2; j < count; j++)
+		vr_tri(ctx, vidx(elt, start), vidx(elt, j - 1), vidx(elt, j),
+		    vidx(elt, j));
+}
+
+static void
+vr_c_poly(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	GLboolean flat = (ctx->Light.ShadeModel == GL_FLAT);
+	GLuint j;
+
+	if (vmesa->strips_ok && vr_native_run(ctx, elt, start, count,
+	    GL_TRUE, flat ? start : ~0U))		/* cull_uniform: convex */
+		return;
+	g_vr_pt_polys++;
+	g_vr_pt_tris += count - start - 2;
+	for (j = start + 2; j < count; j++)
+		vr_tri(ctx, vidx(elt, j - 1), vidx(elt, j), vidx(elt, start),
+		    vidx(elt, start));
+}
+
+static void
+vr_c_quads(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	GLuint j;
+
+	for (j = start + 3; j < count; j += 4)
+		vr_quad(ctx, vidx(elt, j - 3), vidx(elt, j - 2),
+		    vidx(elt, j - 1), vidx(elt, j));
+}
+
+static void
+vr_c_quad_strip(GLcontext *ctx, const GLuint *elt, GLuint start, GLuint count)
+{
+	GLuint j;
+
+	for (j = start + 3; j < count; j += 2)
+		vr_quad(ctx, vidx(elt, j - 1), vidx(elt, j - 3),
+		    vidx(elt, j - 2), vidx(elt, j));
+}
+
+/* generate the {verts,elts} PrimTab wrappers around each run core */
+#define VR_TAB(core)							\
+static void core##_verts(GLcontext *ctx, GLuint s, GLuint c, GLuint f)	\
+{									\
+	(void)f;							\
+	core(ctx, NULL, s, c);						\
+}									\
+static void core##_elts(GLcontext *ctx, GLuint s, GLuint c, GLuint f)	\
+{									\
+	(void)f;							\
+	core(ctx, TNL_CONTEXT(ctx)->vb.Elts, s, c);			\
+}
+
+VR_TAB(vr_c_triangles)
+VR_TAB(vr_c_tri_strip)
+VR_TAB(vr_c_tri_fan)
+VR_TAB(vr_c_poly)
+VR_TAB(vr_c_quads)
+VR_TAB(vr_c_quad_strip)
+
+static tnl_render_func vr_tab_verts[GL_POLYGON + 2];
+static tnl_render_func vr_tab_elts[GL_POLYGON + 2];
+static GLboolean vr_tab_ready = GL_FALSE;
+
+static void
+vr_build_tables(TNLcontext *tnl)
+{
+	GLuint i;
+
+	if (vr_tab_ready)
+		return;
+	for (i = 0; i < GL_POLYGON + 2; i++) {
+		vr_tab_verts[i] = tnl->Driver.Render.PrimTabVerts[i];
+		vr_tab_elts[i] = tnl->Driver.Render.PrimTabElts[i];
+	}
+	vr_tab_verts[GL_TRIANGLES] = vr_c_triangles_verts;
+	vr_tab_verts[GL_TRIANGLE_STRIP] = vr_c_tri_strip_verts;
+	vr_tab_verts[GL_TRIANGLE_FAN] = vr_c_tri_fan_verts;
+	vr_tab_verts[GL_POLYGON] = vr_c_poly_verts;
+	vr_tab_verts[GL_QUADS] = vr_c_quads_verts;
+	vr_tab_verts[GL_QUAD_STRIP] = vr_c_quad_strip_verts;
+	vr_tab_elts[GL_TRIANGLES] = vr_c_triangles_elts;
+	vr_tab_elts[GL_TRIANGLE_STRIP] = vr_c_tri_strip_elts;
+	vr_tab_elts[GL_TRIANGLE_FAN] = vr_c_tri_fan_elts;
+	vr_tab_elts[GL_POLYGON] = vr_c_poly_elts;
+	vr_tab_elts[GL_QUADS] = vr_c_quads_elts;
+	vr_tab_elts[GL_QUAD_STRIP] = vr_c_quad_strip_elts;
+	vr_tab_ready = GL_TRUE;
+}
+
+/*
+ * Line as a perpendicular-offset quad (2 tris), width = Line._Width.
+ */
+static void
+vr_line(GLcontext *ctx, GLuint e0, GLuint e1)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	const SWvertex *v0 = &verts[e0], *v1 = &verts[e1];
+	const GLboolean flat = (ctx->Light.ShadeModel == GL_FLAT);
+	const GLchan *c0 = flat ? v1->color : v0->color;
+	const GLchan *c1 = v1->color;		/* provoking = last vertex */
+	GLfloat dx = v1->win[0] - v0->win[0];
+	GLfloat dy = v1->win[1] - v0->win[1];
+	GLfloat len = (GLfloat)sqrt(dx * dx + dy * dy);
+	GLfloat hw = ctx->Line._Width * 0.5F;
+	GLfloat px, py;
+	struct rlgl_vtx a, b, c, d;
+
+	if (len < 1e-4F)
+		return;				/* degenerate */
+	if (hw < 0.75F) {
+		GLfloat adx = dx < 0.0F ? -dx : dx;
+		GLfloat ady = dy < 0.0F ? -dy : dy;
+
+		if (adx > 0.5F && ady > 0.5F)
+			hw = 0.75F;
+	}
+	px = -dy / len * hw;			/* perpendicular * half-width */
+	py = dx / len * hw;
+	vr_emit_at(vmesa, v0->win[0] + px, v0->win[1] + py, v0, c0, &a);
+	vr_emit_at(vmesa, v0->win[0] - px, v0->win[1] - py, v0, c0, &b);
+	vr_emit_at(vmesa, v1->win[0] - px, v1->win[1] - py, v1, c1, &c);
+	vr_emit_at(vmesa, v1->win[0] + px, v1->win[1] + py, v1, c1, &d);
+	rlgl_tri(&vmesa->rl, &a, &b, &c);
+	rlgl_tri(&vmesa->rl, &a, &c, &d);
+	vmesa->engine_dirty = GL_TRUE;
+}
+
+/*
+ * Native hardware line via the microcode's own line drawers
+ */
+static void
+vr_line_native(GLcontext *ctx, GLuint e0, GLuint e1, GLboolean aa)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	const SWvertex *v0 = &verts[e0], *v1 = &verts[e1];
+	const GLboolean flat = (ctx->Light.ShadeModel == GL_FLAT);
+	const GLchan *c0 = flat ? v1->color : v0->color;
+	const GLchan *c1 = v1->color;		/* provoking = last vertex */
+	struct rlgl_vtx a, b;
+
+	vr_emit_vtx(vmesa, v0, c0, &a);
+	vr_emit_vtx(vmesa, v1, c1, &b);
+	a.x -= 0.5F; a.y -= 0.5F;
+	b.x -= 0.5F; b.y -= 0.5F;
+	if (aa)
+		rlgl_aaline(&vmesa->rl, &a, &b);
+	else
+		rlgl_line(&vmesa->rl, &a, &b);
+	vmesa->engine_dirty = GL_TRUE;
+}
+
+static void
+vr_hwline(GLcontext *ctx, GLuint e0, GLuint e1)
+{
+
+	vr_line_native(ctx, e0, e1, GL_FALSE);
+}
+
+static void
+vr_aaline(GLcontext *ctx, GLuint e0, GLuint e1)
+{
+
+	vr_line_native(ctx, e0, e1, GL_TRUE);
+}
+
+/* One point as a centered square (2 tris), half-side hs = Point._Size/2. */
+static void
+vr_point_emit(vrmesa_context *vmesa, const SWvertex *v, GLfloat hs)
+{
+	struct rlgl_vtx a, b, c, d;
+	GLfloat x = v->win[0], y = v->win[1];
+
+	vr_emit_at(vmesa, x - hs, y - hs, v, v->color, &a);
+	vr_emit_at(vmesa, x + hs, y - hs, v, v->color, &b);
+	vr_emit_at(vmesa, x + hs, y + hs, v, v->color, &c);
+	vr_emit_at(vmesa, x - hs, y + hs, v, v->color, &d);
+	rlgl_tri(&vmesa->rl, &a, &b, &c);
+	rlgl_tri(&vmesa->rl, &a, &c, &d);
+}
+
+static void
+vr_points(GLcontext *ctx, GLuint first, GLuint last)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+	const GLfloat hs = ctx->Point._Size * 0.5F;
+	GLuint i;
+
+	for (i = first; i < last; i++) {
+		GLuint j = VB->Elts ? VB->Elts[i] : i;
+
+		if (VB->ClipMask[j])
+			continue;
+		vr_point_emit(vmesa, &verts[j], hs);
+	}
+	vmesa->engine_dirty = GL_TRUE;
+}
+
+/*
+ * Native anti-aliased points (GL_POINT_SMOOTH)
+ */
+static void
+vr_aapoints(GLcontext *ctx, GLuint first, GLuint last)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	const SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
+	const GLfloat sz = ctx->Point._Size;
+	GLuint i;
+
+	rlgl_aapoint_begin(&vmesa->rl);
+	for (i = first; i < last; i++) {
+		GLuint j = VB->Elts ? VB->Elts[i] : i;
+		struct rlgl_vtx a;
+
+		if (VB->ClipMask[j])
+			continue;
+		vr_emit_vtx(vmesa, &verts[j], verts[j].color, &a);
+		rlgl_aapoint(&vmesa->rl, &a, sz);
+	}
+	rlgl_aapoint_end(&vmesa->rl);
+	rlgl_depth_func(&vmesa->rl,
+	    ctx->Depth.Test && ctx->Depth.Func != GL_ALWAYS,
+	    ctx->Depth.Func == GL_LESS ? RLGL_Z_LT : RLGL_Z_LE);
+	/* Z-write only with the test enabled (see vr_update_state) */
+	rlgl_depth_mask(&vmesa->rl, ctx->Depth.Test && ctx->Depth.Mask);
+	vmesa->engine_dirty = GL_TRUE;
+}
+
+/*
+ * Unfilled triangle (glPolygonMode GL_LINE / GL_POINT).
+ */
+static void
+vr_unfilled_tri(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	SWvertex *verts = SWSETUP_CONTEXT(ctx)->verts;
+	SWvertex *v0 = &verts[e0], *v1 = &verts[e1], *v2 = &verts[e2];
+	const GLubyte *ef = TNL_CONTEXT(ctx)->vb.EdgeFlag;
+	GLfloat ex = v0->win[0] - v2->win[0], ey = v0->win[1] - v2->win[1];
+	GLfloat fx = v1->win[0] - v2->win[0], fy = v1->win[1] - v2->win[1];
+	GLfloat cc = ex * fy - ey * fx;
+	GLuint facing = (cc < 0.0F) ^ ctx->Polygon._FrontBit;
+	GLenum mode = facing ? ctx->Polygon.BackMode : ctx->Polygon.FrontMode;
+	GLchan s0[4], s1[4];
+	GLfloat z0 = 0, z1 = 0, z2 = 0;
+	GLboolean flat, offed = GL_FALSE;
+
+	if (mode == GL_FILL) {			/* mixed modes: fill this face */
+		vr_tri(ctx, e0, e1, e2, e2);
+		return;
+	}
+	if (ctx->Polygon.CullFlag) {		/* whole-face cull, per swsetup */
+		if (facing == 1 && ctx->Polygon.CullFaceMode != GL_FRONT)
+			return;
+		if (facing == 0 && ctx->Polygon.CullFaceMode != GL_BACK)
+			return;
+	}
+
+	flat = (ctx->Light.ShadeModel == GL_FLAT);
+	if (flat) {
+		COPY_CHAN4(s0, v0->color);
+		COPY_CHAN4(s1, v1->color);
+		COPY_CHAN4(v0->color, v2->color);
+		COPY_CHAN4(v1->color, v2->color);
+	}
+	if ((mode == GL_LINE && ctx->Polygon.OffsetLine) ||
+	    (mode == GL_POINT && ctx->Polygon.OffsetPoint)) {
+		GLfloat off = vr_poly_offset(ctx, v0, v1, v2);
+
+		z0 = v0->win[2]; z1 = v1->win[2]; z2 = v2->win[2];
+		v0->win[2] = vr_clampz(z0 + off);
+		v1->win[2] = vr_clampz(z1 + off);
+		v2->win[2] = vr_clampz(z2 + off);
+		offed = GL_TRUE;
+	}
+
+	if (mode == GL_POINT) {
+		GLfloat hs = ctx->Point._Size * 0.5F;
+
+		if (ef[e0]) vr_point_emit(vmesa, v0, hs);
+		if (ef[e1]) vr_point_emit(vmesa, v1, hs);
+		if (ef[e2]) vr_point_emit(vmesa, v2, hs);
+	} else {				/* GL_LINE */
+		if (ef[e0]) vr_line(ctx, e0, e1);
+		if (ef[e1]) vr_line(ctx, e1, e2);
+		if (ef[e2]) vr_line(ctx, e2, e0);
+	}
+	vmesa->engine_dirty = GL_TRUE;
+
+	if (offed) {
+		v0->win[2] = z0;
+		v1->win[2] = z1;
+		v2->win[2] = z2;
+	}
+	if (flat) {
+		COPY_CHAN4(v0->color, s0);
+		COPY_CHAN4(v1->color, s1);
+	}
+}
+
+/*
+ * Unfilled quad
+ */
+static void
+vr_unfilled_quad(GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+	GLubyte *ef = TNL_CONTEXT(ctx)->vb.EdgeFlag;
+	GLubyte ef1 = ef[v1], ef3 = ef[v3];
+
+	ef[v1] = 0;
+	vr_unfilled_tri(ctx, v0, v1, v3);
+	ef[v1] = ef1;
+	ef[v3] = 0;
+	vr_unfilled_tri(ctx, v1, v2, v3);
+	ef[v3] = ef3;
+}
+
+/*
+ * State gate for the v1 hardware path.
+ */
+void
+vrCheckHwRender(GLcontext *ctx)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	GLboolean hw = GL_TRUE;
+
+	vmesa->blend_alpha = GL_FALSE;
+	vmesa->atest_alpha = GL_FALSE;
+	if (ctx->Texture._EnabledUnits != 0 && !vrTexHwOk(ctx)) {
+		hw = GL_FALSE;
+		VRP_FALLBACK(VRP_FB_TEX_HWOK);
+	}
+	if (ctx->Color.BlendEnabled) {
+		GLuint srcf, dstf;
+		GLboolean na;
+
+		if (!vrBlendMap(ctx, &srcf, &dstf, &na)) {
+			hw = GL_FALSE;
+			VRP_FALLBACK(VRP_FB_BLEND);
+		} else
+			vmesa->blend_alpha = na;
+	}
+	if (ctx->Color.AlphaEnabled) {
+		/*
+		 * TranspReject rejects SrcAlpha <= AlphaThres, and
+		 * v_TranspReject is enable-only (redline), DUH.
+		 */
+		GLenum f = ctx->Color.AlphaFunc;
+
+		if (f != GL_GREATER && f != GL_GEQUAL &&
+		    f != GL_NEVER && f != GL_ALWAYS) {
+			hw = GL_FALSE;
+			VRP_FALLBACK(VRP_FB_ALPHAFUNC);
+		} else if (f != GL_ALWAYS &&
+		    !(ctx->Texture._EnabledUnits == 0x1 &&
+		    ctx->Texture.Unit[0].EnvMode == GL_REPLACE))
+			vmesa->atest_alpha = GL_TRUE;
+	}
+	/* fog now rides the KFXYZUVQ per-vertex f term + PE FogColor/En */
+	if (ctx->Depth.Test && ctx->Depth.Func != GL_LESS &&
+	    ctx->Depth.Func != GL_LEQUAL && ctx->Depth.Func != GL_ALWAYS) {
+		hw = GL_FALSE;
+		VRP_FALLBACK(VRP_FB_DEPTHFUNC);
+	}
+	if (ctx->_TriangleCaps & (DD_TRI_STIPPLE | DD_TRI_SMOOTH |
+	    DD_TRI_LIGHT_TWOSIDE | DD_SEPARATE_SPECULAR)) {
+		hw = GL_FALSE;		/* offset rides a per-tri Z bias now */
+		/* split the mask so the histogram shows which cap gated */
+		if (ctx->_TriangleCaps & DD_TRI_STIPPLE)
+			VRP_FALLBACK(VRP_FB_STIPPLE);
+		if (ctx->_TriangleCaps & DD_TRI_SMOOTH)
+			VRP_FALLBACK(VRP_FB_SMOOTH);
+		if (ctx->_TriangleCaps & DD_TRI_LIGHT_TWOSIDE)
+			VRP_FALLBACK(VRP_FB_TWOSIDE);
+		if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
+			VRP_FALLBACK(VRP_FB_SPECULAR);
+	}
+	if ((ctx->_TriangleCaps & DD_TRI_UNFILLED) &&
+	    (ctx->Line.SmoothFlag || ctx->Line.StippleFlag ||
+	    ctx->Point.SmoothFlag || ctx->Point._Attenuated ||
+	    ctx->Point.PointSprite)) {
+		hw = GL_FALSE;
+		VRP_FALLBACK(VRP_FB_UNFILLED_SUB);
+	}
+	if (ctx->RenderMode != GL_RENDER) {
+		hw = GL_FALSE;
+		VRP_FALLBACK(VRP_FB_RENDERMODE);
+	}
+
+	vmesa->hw_tris = hw;
+}
+
+static void
+vr_build_vertices(GLcontext *ctx, GLuint start, GLuint end, GLuint newinputs)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	TNLcontext *tnl = TNL_CONTEXT(ctx);
+	struct vertex_buffer *VB = &tnl->vb;
+	struct tnl_clipspace *vtx = &tnl->clipspace;
+	const GLfloat *m = ctx->Viewport._WindowMap.m;
+	SWvertex *vbuf;
+	const GLubyte *pin, *cin, *tin = NULL, *fin = NULL;
+	GLuint pstr, cstr, tstr = 0, fstr = 0, csize, tsize = 0, g;
+
+	if (!vmesa->fastbuild_ok) {
+		vmesa->ss_build_vertices(ctx, start, end, newinputs);
+		return;
+	}
+
+	newinputs |= vtx->new_inputs;
+	vtx->new_inputs = 0;
+	if (!newinputs)
+		return;
+
+	vbuf = (SWvertex *)vtx->vertex_buf;
+
+	pin = (const GLubyte *)VB->NdcPtr->data;
+	pstr = VB->NdcPtr->stride;
+	cin = (const GLubyte *)VB->ColorPtr[0]->data;
+	cstr = VB->ColorPtr[0]->stride;
+	csize = VB->ColorPtr[0]->size;
+	if (vmesa->fb_tex) {
+		tin = (const GLubyte *)VB->TexCoordPtr[0]->data;
+		tstr = VB->TexCoordPtr[0]->stride;
+		tsize = VB->TexCoordPtr[0]->size;
+	}
+	if (vmesa->fb_fog) {
+		fin = (const GLubyte *)VB->FogCoordPtr->data;
+		fstr = VB->FogCoordPtr->stride;
+	}
+
+	for (g = start; g < end; g++) {
+		SWvertex *o = &vbuf[g];
+		const GLfloat *ndc = (const GLfloat *)(pin + g * pstr);
+		const GLfloat *col = (const GLfloat *)(cin + g * cstr);
+
+		/* POS: EMIT_4F_VIEWPORT */
+		o->win[0] = m[0]  * ndc[0] + m[12];
+		o->win[1] = m[5]  * ndc[1] + m[13];
+		o->win[2] = m[10] * ndc[2] + m[14];
+		o->win[3] = ndc[3];
+
+		/* COLOR0: EMIT_4CHAN_4F_RGBA */
+		UNCLAMPED_FLOAT_TO_CHAN(o->color[0], col[0]);
+		UNCLAMPED_FLOAT_TO_CHAN(o->color[1], col[1]);
+		UNCLAMPED_FLOAT_TO_CHAN(o->color[2], col[2]);
+		if (csize == 4)
+			UNCLAMPED_FLOAT_TO_CHAN(o->color[3], col[3]);
+		else
+			o->color[3] = CHAN_MAX;
+
+		/* TEX0: EMIT_4F (insert_4f_{4,3,2,1} padding) */
+		if (vmesa->fb_tex) {
+			const GLfloat *t = (const GLfloat *)(tin + g * tstr);
+
+			o->texcoord[0][0] = t[0];
+			o->texcoord[0][1] = tsize >= 2 ? t[1] : 0.0F;
+			o->texcoord[0][2] = tsize >= 3 ? t[2] : 0.0F;
+			o->texcoord[0][3] = tsize >= 4 ? t[3] : 1.0F;
+		}
+
+		/* FOG: EMIT_1F */
+		if (vmesa->fb_fog)
+			o->fog = *(const GLfloat *)(fin + g * fstr);
+	}
+}
+
+static void
+vr_render_start(GLcontext *ctx)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+	VRP_ZE(VRP_Z_RENDER_START);
+
+	/* swsetup validation: builds vertices, may re-choose funcs */
+	vmesa->ss_render_start(ctx);
+
+	{
+		const GLuint ri = tnl->render_inputs;
+		const GLuint allowed = _TNL_BIT_POS | _TNL_BIT_COLOR0 |
+		    _TNL_BIT_FOG | _TNL_BIT_TEX(0);
+
+		vmesa->fb_tex = (ri & _TNL_BIT_TEX(0)) != 0;
+		vmesa->fb_fog = (ri & _TNL_BIT_FOG) != 0;
+		vmesa->fastbuild_ok = vmesa->use_fastbuild &&
+		    (ri & _TNL_BIT_POS) && (ri & _TNL_BIT_COLOR0) &&
+		    (ri & ~allowed) == 0 &&
+		    tnl->clipspace.vertex_size == sizeof(SWvertex) &&
+		    tnl->vb.NdcPtr != NULL &&
+		    (tnl->vb.ColorPtr[0]->size == 3 ||
+		    tnl->vb.ColorPtr[0]->size == 4);
+	}
+
+	if (_mesa_getenv("VRMESA_DEBUG"))
+		_mesa_printf("vr_render_start: hw=%d texen=%x mip=%d "
+		    "texw=%.0f\n", vmesa->hw_tris,
+		    ctx->Texture._EnabledUnits, vmesa->tex_mip,
+		    vmesa->tex_w);
+
+	if (tnl->Driver.Render.Triangle != vr_triangle &&
+	    tnl->Driver.Render.Triangle != vr_unfilled_tri) {
+		vmesa->ss_triangle = tnl->Driver.Render.Triangle;
+		vmesa->ss_quad = tnl->Driver.Render.Quad;
+	}
+	if (tnl->Driver.Render.Line != vr_line &&
+	    tnl->Driver.Render.Line != vr_hwline &&
+	    tnl->Driver.Render.Line != vr_aaline)
+		vmesa->ss_line = tnl->Driver.Render.Line;
+	if (tnl->Driver.Render.Points != vr_points &&
+	    tnl->Driver.Render.Points != vr_aapoints)
+		vmesa->ss_points = tnl->Driver.Render.Points;
+
+	if (vmesa->hw_tris) {
+		if (ctx->Texture._EnabledUnits != 0) {
+			/* gate passed, but residency can still fail */
+			if (!vrTexValidate(ctx)) {
+				vmesa->tex_on = GL_FALSE;
+				VRP_FALLBACK(VRP_FB_TEX_RESIDENCY);
+				goto fallback;
+			}
+			vmesa->tex_on = GL_TRUE;
+		} else {
+			rlgl_tex_bind(&vmesa->rl, NULL);
+			vmesa->tex_on = GL_FALSE;
+		}
+		if (ctx->_TriangleCaps & DD_TRI_UNFILLED) {
+			tnl->Driver.Render.Triangle = vr_unfilled_tri;
+			tnl->Driver.Render.Quad = vr_unfilled_quad;
+			tnl->Driver.Render.PrimTabVerts = vmesa->ss_prim_verts;
+			tnl->Driver.Render.PrimTabElts = vmesa->ss_prim_elts;
+			vmesa->strips_ok = GL_FALSE;
+		} else {
+			tnl->Driver.Render.Triangle = vr_triangle;
+			tnl->Driver.Render.Quad = vr_quad;
+			tnl->Driver.Render.PrimTabVerts = vr_tab_verts;
+			tnl->Driver.Render.PrimTabElts = vr_tab_elts;
+			vmesa->strips_ok = vmesa->use_strips &&
+			    !vmesa->tex_mip &&
+			    !vmesa->blend_alpha && !vmesa->atest_alpha &&
+			    !ctx->Polygon.OffsetFill &&
+			    !(g_vr_noblendfan && ctx->Color.BlendEnabled);
+		}
+		/*
+		 * Line dispatch:
+		 *  - stippled            -> swrast
+		 *  - smooth + narrow +   -> vr_aaline
+		 *    blending enabled       
+		 *  - smooth + wide/      -> swrast (HW AA line is ~1px)
+		 *    no blend
+		 *  - plain + narrow      -> vr_hwline
+		 *  - plain + wide        -> vr_line thin-quad
+		 */
+		if (ctx->Line.StippleFlag)
+			tnl->Driver.Render.Line = vmesa->ss_line;
+		else if (ctx->Line.SmoothFlag)
+			tnl->Driver.Render.Line =
+			    (ctx->Color.BlendEnabled &&
+			    ctx->Line._Width <= 1.5F) ?
+			    vr_aaline : vmesa->ss_line;
+		else
+			tnl->Driver.Render.Line =
+			    (ctx->Line._Width <= 1.5F) ? vr_hwline : vr_line;
+		/*
+		 * Points: native AA point
+		 */
+		if (ctx->Point.SmoothFlag && ctx->Color.BlendEnabled &&
+		    ctx->Texture._EnabledUnits == 0 &&
+		    !ctx->Point._Attenuated && !ctx->Point.PointSprite)
+			tnl->Driver.Render.Points = vr_aapoints;
+		else if (!ctx->Point.SmoothFlag && !ctx->Point._Attenuated &&
+		    !ctx->Point.PointSprite)
+			tnl->Driver.Render.Points = vr_points;
+		else
+			tnl->Driver.Render.Points = vmesa->ss_points;
+		VRP_ZX(VRP_Z_RENDER_START);
+		return;
+	}
+fallback:
+	tnl->Driver.Render.Triangle = vmesa->ss_triangle;
+	tnl->Driver.Render.Quad = vmesa->ss_quad;
+	tnl->Driver.Render.Line = vmesa->ss_line;
+	tnl->Driver.Render.Points = vmesa->ss_points;
+	/* swrast fallback: everything dispatches through the restored funcs */
+	tnl->Driver.Render.PrimTabVerts = vmesa->ss_prim_verts;
+	tnl->Driver.Render.PrimTabElts = vmesa->ss_prim_elts;
+	vmesa->strips_ok = GL_FALSE;
+	VRP_ZX(VRP_Z_RENDER_START);
+}
+
+void
+vrInitTriFuncs(GLcontext *ctx)
+{
+	vrmesa_context *vmesa = VRMESA_CONTEXT(ctx);
+	TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+	/* capture swsetup's Start (installed by _swsetup_Wakeup) */
+	vmesa->ss_render_start = tnl->Driver.Render.Start;
+	tnl->Driver.Render.Start = vr_render_start;
+
+	vmesa->ss_build_vertices = tnl->Driver.Render.BuildVertices;
+	tnl->Driver.Render.BuildVertices = vr_build_vertices;
+	vmesa->use_fastbuild = (_mesa_getenv("VRMESA_NOFASTBUILD") == NULL);
+
+	/*
+	 * Capture swsetup's default per-mode render tables, then
+	 * build our batch tables from them. 
+	 */
+	vmesa->ss_prim_verts = tnl->Driver.Render.PrimTabVerts;
+	vmesa->ss_prim_elts = tnl->Driver.Render.PrimTabElts;
+	vr_build_tables(tnl);
+	vmesa->use_strips = (_mesa_getenv("VRMESA_STRIPS") != NULL);
+	g_vr_nocache = (_mesa_getenv("VRMESA_NOCACHE") != NULL);
+	rlgl_force_rebind = g_vr_nocache;
+	g_vr_noblendfan = (_mesa_getenv("VRMESA_NOBLENDFAN") != NULL);
+	{
+		const char *zb = _mesa_getenv("VRMESA_ZBIAS");
+		g_vr_zbias = zb ? (float)atoi(zb) : 0.0F;
+	}
+	atexit(vr_strip_stat);		/* VRMESA_STRIPSTAT fire-rate report */
+
+	vrCheckHwRender(ctx);
+}