X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fnouveau%2Fnv20_state_tnl.c;h=f0acbed8560f5a7aa9aa6a5a990f704583a3fdc1;hb=092c73a7c32b240a26ffeab2ee475f6d590540b2;hp=43f8c7231226fc8712919f4e0a9d680690f1cf56;hpb=e5923a1240d8b32f5af080b0b4191d3b9299a630;p=mesa.git

diff --git a/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c b/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c
index 43f8c723122..f0acbed8560 100644
--- a/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c
+++ b/src/mesa/drivers/dri/nouveau/nv20_state_tnl.c
@@ -28,12 +28,34 @@
 #include "nouveau_context.h"
 #include "nouveau_gldefs.h"
 #include "nouveau_util.h"
-#include "nouveau_class.h"
+#include "nv20_3d.xml.h"
 #include "nv10_driver.h"
 #include "nv20_driver.h"
 
+#define LIGHT_MODEL_AMBIENT_R(side)			\
+	((side) ? NV20_3D_LIGHT_MODEL_BACK_AMBIENT_R :	\
+	 NV20_3D_LIGHT_MODEL_FRONT_AMBIENT_R)
+#define LIGHT_AMBIENT_R(side, i)			\
+	((side) ? NV20_3D_LIGHT_BACK_AMBIENT_R(i) :	\
+	 NV20_3D_LIGHT_FRONT_AMBIENT_R(i))
+#define LIGHT_DIFFUSE_R(side, i)			\
+	((side) ? NV20_3D_LIGHT_BACK_DIFFUSE_R(i) :	\
+	 NV20_3D_LIGHT_FRONT_DIFFUSE_R(i))
+#define LIGHT_SPECULAR_R(side, i)			\
+	((side) ? NV20_3D_LIGHT_BACK_SPECULAR_R(i) :	\
+	 NV20_3D_LIGHT_FRONT_SPECULAR_R(i))
+#define MATERIAL_FACTOR_R(side)				\
+	((side) ? NV20_3D_MATERIAL_FACTOR_BACK_R :	\
+	 NV20_3D_MATERIAL_FACTOR_FRONT_R)
+#define MATERIAL_FACTOR_A(side)				\
+	((side) ? NV20_3D_MATERIAL_FACTOR_BACK_A :	\
+	 NV20_3D_MATERIAL_FACTOR_FRONT_A)
+#define MATERIAL_SHININESS(side)			\
+	((side) ? NV20_3D_BACK_MATERIAL_SHININESS(0) :	\
+	 NV20_3D_FRONT_MATERIAL_SHININESS(0))
+
 void
-nv20_emit_clip_plane(GLcontext *ctx, int emit)
+nv20_emit_clip_plane(struct gl_context *ctx, int emit)
 {
 }
 
@@ -43,35 +65,34 @@ get_material_bitmask(unsigned m)
 	unsigned ret = 0;
 
 	if (m & MAT_BIT_FRONT_EMISSION)
-		ret |= NV20TCL_COLOR_MATERIAL_FRONT_EMISSION_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_FRONT_EMISSION_COL1;
 	if (m & MAT_BIT_FRONT_AMBIENT)
-		ret |= NV20TCL_COLOR_MATERIAL_FRONT_AMBIENT_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_FRONT_AMBIENT_COL1;
 	if (m & MAT_BIT_FRONT_DIFFUSE)
-		ret |= NV20TCL_COLOR_MATERIAL_FRONT_DIFFUSE_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_FRONT_DIFFUSE_COL1;
 	if (m & MAT_BIT_FRONT_SPECULAR)
-		ret |= NV20TCL_COLOR_MATERIAL_FRONT_SPECULAR_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_FRONT_SPECULAR_COL1;
 
 	if (m & MAT_BIT_BACK_EMISSION)
-		ret |= NV20TCL_COLOR_MATERIAL_BACK_EMISSION_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_BACK_EMISSION_COL1;
 	if (m & MAT_BIT_BACK_AMBIENT)
-		ret |= NV20TCL_COLOR_MATERIAL_BACK_AMBIENT_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_BACK_AMBIENT_COL1;
 	if (m & MAT_BIT_BACK_DIFFUSE)
-		ret |= NV20TCL_COLOR_MATERIAL_BACK_DIFFUSE_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_BACK_DIFFUSE_COL1;
 	if (m & MAT_BIT_BACK_SPECULAR)
-		ret |= NV20TCL_COLOR_MATERIAL_BACK_SPECULAR_COL1;
+		ret |= NV20_3D_COLOR_MATERIAL_BACK_SPECULAR_COL1;
 
 	return ret;
 }
 
 void
-nv20_emit_color_material(GLcontext *ctx, int emit)
+nv20_emit_color_material(struct gl_context *ctx, int emit)
 {
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
-	unsigned mask = get_material_bitmask(ctx->Light.ColorMaterialBitmask);
+	struct nouveau_pushbuf *push = context_push(ctx);
+	unsigned mask = get_material_bitmask(ctx->Light._ColorMaterialBitmask);
 
-	BEGIN_RING(chan, kelvin, NV20TCL_COLOR_MATERIAL, 1);
-	OUT_RING(chan, ctx->Light.ColorMaterialEnabled ? mask : 0);
+	BEGIN_NV04(push, NV20_3D(COLOR_MATERIAL), 1);
+	PUSH_DATA (push, ctx->Light.ColorMaterialEnabled ? mask : 0);
 }
 
 static unsigned
@@ -79,11 +100,11 @@ get_fog_mode_signed(unsigned mode)
 {
 	switch (mode) {
 	case GL_LINEAR:
-		return NV20TCL_FOG_MODE_LINEAR_SIGNED;
+		return NV20_3D_FOG_MODE_LINEAR_SIGNED;
 	case GL_EXP:
-		return NV20TCL_FOG_MODE_EXP_SIGNED;
+		return NV20_3D_FOG_MODE_EXP_SIGNED;
 	case GL_EXP2:
-		return NV20TCL_FOG_MODE_EXP2_SIGNED;
+		return NV20_3D_FOG_MODE_EXP2_SIGNED;
 	default:
 		assert(0);
 	}
@@ -94,35 +115,43 @@ get_fog_mode_unsigned(unsigned mode)
 {
 	switch (mode) {
 	case GL_LINEAR:
-		return NV20TCL_FOG_MODE_LINEAR_UNSIGNED;
+		return NV20_3D_FOG_MODE_LINEAR_UNSIGNED;
 	case GL_EXP:
-		return NV20TCL_FOG_MODE_EXP_UNSIGNED;
+		return NV20_3D_FOG_MODE_EXP_UNSIGNED;
 	case GL_EXP2:
-		return NV20TCL_FOG_MODE_EXP2_UNSIGNED;
+		return NV20_3D_FOG_MODE_EXP2_UNSIGNED;
 	default:
 		assert(0);
 	}
 }
 
 static unsigned
-get_fog_source(unsigned source)
+get_fog_source(unsigned source, unsigned distance_mode)
 {
 	switch (source) {
 	case GL_FOG_COORDINATE_EXT:
-		return NV20TCL_FOG_COORD_FOG;
+		return NV20_3D_FOG_COORD_FOG;
 	case GL_FRAGMENT_DEPTH_EXT:
-		return NV20TCL_FOG_COORD_DIST_ORTHOGONAL_ABS;
+		switch (distance_mode) {
+		case GL_EYE_PLANE_ABSOLUTE_NV:
+			return NV20_3D_FOG_COORD_DIST_ORTHOGONAL_ABS;
+		case GL_EYE_PLANE:
+			return NV20_3D_FOG_COORD_DIST_ORTHOGONAL;
+		case GL_EYE_RADIAL_NV:
+			return NV20_3D_FOG_COORD_DIST_RADIAL;
+		default:
+			assert(0);
+		}
 	default:
 		assert(0);
 	}
 }
 
 void
-nv20_emit_fog(GLcontext *ctx, int emit)
+nv20_emit_fog(struct gl_context *ctx, int emit)
 {
 	struct nouveau_context *nctx = to_nouveau_context(ctx);
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	struct gl_fog_attrib *f = &ctx->Fog;
 	unsigned source = nctx->fallback == HWTNL ?
 		f->FogCoordinateSource : GL_FOG_COORDINATE_EXT;
@@ -130,71 +159,62 @@ nv20_emit_fog(GLcontext *ctx, int emit)
 
 	nv10_get_fog_coeff(ctx, k);
 
-	BEGIN_RING(chan, kelvin, NV20TCL_FOG_MODE, 4);
-	OUT_RING(chan, (source == GL_FOG_COORDINATE_EXT ?
-			get_fog_mode_signed(f->Mode) :
-			get_fog_mode_unsigned(f->Mode)));
-	OUT_RING(chan, get_fog_source(source));
-	OUT_RING(chan, f->Enabled ? 1 : 0);
-	OUT_RING(chan, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color));
-
-	BEGIN_RING(chan, kelvin, NV20TCL_FOG_EQUATION_CONSTANT, 3);
-	OUT_RINGf(chan, k[0]);
-	OUT_RINGf(chan, k[1]);
-	OUT_RINGf(chan, k[2]);
+	BEGIN_NV04(push, NV20_3D(FOG_MODE), 4);
+	PUSH_DATA (push, ((source == GL_FRAGMENT_DEPTH_EXT &&
+			 f->FogDistanceMode == GL_EYE_PLANE_ABSOLUTE_NV) ?
+			get_fog_mode_unsigned(f->Mode) :
+			get_fog_mode_signed(f->Mode)));
+	PUSH_DATA (push, get_fog_source(source, f->FogDistanceMode));
+	PUSH_DATAb(push, f->Enabled);
+	PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_R8G8B8A8_UNORM, f->Color));
+
+	BEGIN_NV04(push, NV20_3D(FOG_COEFF(0)), 3);
+	PUSH_DATAp(push, k, 3);
 }
 
 void
-nv20_emit_light_model(GLcontext *ctx, int emit)
+nv20_emit_light_model(struct gl_context *ctx, int emit)
 {
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	struct gl_lightmodel *m = &ctx->Light.Model;
 
-	BEGIN_RING(chan, kelvin, NV20TCL_SEPARATE_SPECULAR_ENABLE, 1);
-	OUT_RING(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR ? 1 : 0);
+	BEGIN_NV04(push, NV20_3D(SEPARATE_SPECULAR_ENABLE), 1);
+	PUSH_DATAb(push, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR);
 
-	BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_MODEL, 1);
-	OUT_RING(chan, ((m->LocalViewer ?
-			 NV20TCL_LIGHT_MODEL_VIEWER_LOCAL :
-			 NV20TCL_LIGHT_MODEL_VIEWER_NONLOCAL) |
-			(NEED_SECONDARY_COLOR(ctx) ?
-			 NV20TCL_LIGHT_MODEL_SEPARATE_SPECULAR :
+	BEGIN_NV04(push, NV20_3D(LIGHT_MODEL), 1);
+	PUSH_DATA (push, ((m->LocalViewer ?
+			 NV20_3D_LIGHT_MODEL_VIEWER_LOCAL :
+			 NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL) |
+			(_mesa_need_secondary_color(ctx) ?
+			 NV20_3D_LIGHT_MODEL_SEPARATE_SPECULAR :
 			 0)));
 
-	BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_MODEL_TWO_SIDE_ENABLE, 1);
-	OUT_RING(chan, ctx->Light.Model.TwoSide ? 1 : 0);
+	BEGIN_NV04(push, NV20_3D(LIGHT_MODEL_TWO_SIDE_ENABLE), 1);
+	PUSH_DATAb(push, ctx->Light.Model.TwoSide);
 }
 
 void
-nv20_emit_light_source(GLcontext *ctx, int emit)
+nv20_emit_light_source(struct gl_context *ctx, int emit)
 {
 	const int i = emit - NOUVEAU_STATE_LIGHT_SOURCE0;
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	struct gl_light *l = &ctx->Light.Light[i];
 
 	if (l->_Flags & LIGHT_POSITIONAL) {
-		BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_POSITION_X(i), 3);
-		OUT_RINGf(chan, l->_Position[0]);
-		OUT_RINGf(chan, l->_Position[1]);
-		OUT_RINGf(chan, l->_Position[2]);
+		BEGIN_NV04(push, NV20_3D(LIGHT_POSITION_X(i)), 3);
+		PUSH_DATAp(push, l->_Position, 3);
 
-		BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_ATTENUATION_CONSTANT(i), 3);
-		OUT_RINGf(chan, l->ConstantAttenuation);
-		OUT_RINGf(chan, l->LinearAttenuation);
-		OUT_RINGf(chan, l->QuadraticAttenuation);
+		BEGIN_NV04(push, NV20_3D(LIGHT_ATTENUATION_CONSTANT(i)), 3);
+		PUSH_DATAf(push, l->ConstantAttenuation);
+		PUSH_DATAf(push, l->LinearAttenuation);
+		PUSH_DATAf(push, l->QuadraticAttenuation);
 
 	} else {
-		BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_DIRECTION_X(i), 3);
-		OUT_RINGf(chan, l->_VP_inf_norm[0]);
-		OUT_RINGf(chan, l->_VP_inf_norm[1]);
-		OUT_RINGf(chan, l->_VP_inf_norm[2]);
-
-		BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_HALF_VECTOR_X(i), 3);
-		OUT_RINGf(chan, l->_h_inf_norm[0]);
-		OUT_RINGf(chan, l->_h_inf_norm[1]);
-		OUT_RINGf(chan, l->_h_inf_norm[2]);
+		BEGIN_NV04(push, NV20_3D(LIGHT_DIRECTION_X(i)), 3);
+		PUSH_DATAp(push, l->_VP_inf_norm, 3);
+
+		BEGIN_NV04(push, NV20_3D(LIGHT_HALF_VECTOR_X(i)), 3);
+		PUSH_DATAp(push, l->_h_inf_norm, 3);
 	}
 
 	if (l->_Flags & LIGHT_SPOT) {
@@ -202,32 +222,21 @@ nv20_emit_light_source(GLcontext *ctx, int emit)
 
 		nv10_get_spot_coeff(l, k);
 
-		BEGIN_RING(chan, kelvin, NV20TCL_LIGHT_SPOT_CUTOFF_A(i), 7);
-		OUT_RINGf(chan, k[0]);
-		OUT_RINGf(chan, k[1]);
-		OUT_RINGf(chan, k[2]);
-		OUT_RINGf(chan, k[3]);
-		OUT_RINGf(chan, k[4]);
-		OUT_RINGf(chan, k[5]);
-		OUT_RINGf(chan, k[6]);
+		BEGIN_NV04(push, NV20_3D(LIGHT_SPOT_CUTOFF(i, 0)), 7);
+		PUSH_DATAp(push, k, 7);
 	}
 }
 
 #define USE_COLOR_MATERIAL(attr, side)					\
 	(ctx->Light.ColorMaterialEnabled &&				\
-	 ctx->Light.ColorMaterialBitmask & (1 << MAT_ATTRIB_##attr(side)))
+	 ctx->Light._ColorMaterialBitmask & (1 << MAT_ATTRIB_##attr(side)))
 
 void
-nv20_emit_material_ambient(GLcontext *ctx, int emit)
+nv20_emit_material_ambient(struct gl_context *ctx, int emit)
 {
 	const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT;
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	float (*mat)[4] = ctx->Light.Material.Attrib;
-	uint32_t m_scene[] = { NV20TCL_LIGHT_MODEL_FRONT_AMBIENT_R,
-			       NV20TCL_LIGHT_MODEL_BACK_AMBIENT_R };
-	uint32_t m_factor[] = { NV20TCL_MATERIAL_FACTOR_FRONT_R,
-			      NV20TCL_MATERIAL_FACTOR_BACK_R };
 	float c_scene[3], c_factor[3];
 	struct gl_light *l;
 
@@ -245,142 +254,113 @@ nv20_emit_material_ambient(GLcontext *ctx, int emit)
 		ZERO_3V(c_factor);
 	}
 
-	BEGIN_RING(chan, kelvin, m_scene[side], 3);
-	OUT_RINGf(chan, c_scene[0]);
-	OUT_RINGf(chan, c_scene[1]);
-	OUT_RINGf(chan, c_scene[2]);
+	BEGIN_NV04(push, SUBC_3D(LIGHT_MODEL_AMBIENT_R(side)), 3);
+	PUSH_DATAp(push, c_scene, 3);
 
 	if (ctx->Light.ColorMaterialEnabled) {
-		BEGIN_RING(chan, kelvin, m_factor[side], 3);
-		OUT_RINGf(chan, c_factor[0]);
-		OUT_RINGf(chan, c_factor[1]);
-		OUT_RINGf(chan, c_factor[2]);
+		BEGIN_NV04(push, SUBC_3D(MATERIAL_FACTOR_R(side)), 3);
+		PUSH_DATAp(push, c_factor, 3);
 	}
 
 	foreach(l, &ctx->Light.EnabledList) {
 		const int i = l - ctx->Light.Light;
-		uint32_t m_light[] = { NV20TCL_LIGHT_FRONT_AMBIENT_R(i),
-				      NV20TCL_LIGHT_BACK_AMBIENT_R(i) };
 		float *c_light = (USE_COLOR_MATERIAL(AMBIENT, side) ?
 				  l->Ambient :
 				  l->_MatAmbient[side]);
 
-		BEGIN_RING(chan, kelvin, m_light[side], 3);
-		OUT_RINGf(chan, c_light[0]);
-		OUT_RINGf(chan, c_light[1]);
-		OUT_RINGf(chan, c_light[2]);
+		BEGIN_NV04(push, SUBC_3D(LIGHT_AMBIENT_R(side, i)), 3);
+		PUSH_DATAp(push, c_light, 3);
 	}
 }
 
 void
-nv20_emit_material_diffuse(GLcontext *ctx, int emit)
+nv20_emit_material_diffuse(struct gl_context *ctx, int emit)
 {
 	const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_DIFFUSE;
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	GLfloat (*mat)[4] = ctx->Light.Material.Attrib;
-	uint32_t m_factor[] = { NV20TCL_MATERIAL_FACTOR_FRONT_A,
-				NV20TCL_MATERIAL_FACTOR_BACK_A };
 	struct gl_light *l;
 
-	BEGIN_RING(chan, kelvin, m_factor[side], 1);
-	OUT_RINGf(chan, mat[MAT_ATTRIB_DIFFUSE(side)][3]);
+	BEGIN_NV04(push, SUBC_3D(MATERIAL_FACTOR_A(side)), 1);
+	PUSH_DATAf(push, mat[MAT_ATTRIB_DIFFUSE(side)][3]);
 
 	foreach(l, &ctx->Light.EnabledList) {
 		const int i = l - ctx->Light.Light;
-		uint32_t m_light[] = { NV20TCL_LIGHT_FRONT_DIFFUSE_R(i),
-				       NV20TCL_LIGHT_BACK_DIFFUSE_R(i) };
 		float *c_light = (USE_COLOR_MATERIAL(DIFFUSE, side) ?
 				  l->Diffuse :
 				  l->_MatDiffuse[side]);
 
-		BEGIN_RING(chan, kelvin, m_light[side], 3);
-		OUT_RINGf(chan, c_light[0]);
-		OUT_RINGf(chan, c_light[1]);
-		OUT_RINGf(chan, c_light[2]);
+		BEGIN_NV04(push, SUBC_3D(LIGHT_DIFFUSE_R(side, i)), 3);
+		PUSH_DATAp(push, c_light, 3);
 	}
 }
 
 void
-nv20_emit_material_specular(GLcontext *ctx, int emit)
+nv20_emit_material_specular(struct gl_context *ctx, int emit)
 {
 	const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_SPECULAR;
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	struct gl_light *l;
 
 	foreach(l, &ctx->Light.EnabledList) {
 		const int i = l - ctx->Light.Light;
-		uint32_t m_light[] = { NV20TCL_LIGHT_FRONT_SPECULAR_R(i),
-				       NV20TCL_LIGHT_BACK_SPECULAR_R(i) };
 		float *c_light = (USE_COLOR_MATERIAL(SPECULAR, side) ?
 				  l->Specular :
 				  l->_MatSpecular[side]);
 
-		BEGIN_RING(chan, kelvin, m_light[side], 3);
-		OUT_RINGf(chan, c_light[0]);
-		OUT_RINGf(chan, c_light[1]);
-		OUT_RINGf(chan, c_light[2]);
+		BEGIN_NV04(push, SUBC_3D(LIGHT_SPECULAR_R(side, i)), 3);
+		PUSH_DATAp(push, c_light, 3);
 	}
 }
 
 void
-nv20_emit_material_shininess(GLcontext *ctx, int emit)
+nv20_emit_material_shininess(struct gl_context *ctx, int emit)
 {
 	const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_SHININESS;
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	float (*mat)[4] = ctx->Light.Material.Attrib;
-	uint32_t mthd[] = { NV20TCL_FRONT_MATERIAL_SHININESS(0),
-			    NV20TCL_BACK_MATERIAL_SHININESS(0) };
 	float k[6];
 
 	nv10_get_shininess_coeff(
 		CLAMP(mat[MAT_ATTRIB_SHININESS(side)][0], 0, 1024),
 		k);
 
-	BEGIN_RING(chan, kelvin, mthd[side], 6);
-	OUT_RINGf(chan, k[0]);
-	OUT_RINGf(chan, k[1]);
-	OUT_RINGf(chan, k[2]);
-	OUT_RINGf(chan, k[3]);
-	OUT_RINGf(chan, k[4]);
-	OUT_RINGf(chan, k[5]);
+	BEGIN_NV04(push, SUBC_3D(MATERIAL_SHININESS(side)), 6);
+	PUSH_DATAp(push, k, 6);
 }
 
 void
-nv20_emit_modelview(GLcontext *ctx, int emit)
+nv20_emit_modelview(struct gl_context *ctx, int emit)
 {
 	struct nouveau_context *nctx = to_nouveau_context(ctx);
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	GLmatrix *m = ctx->ModelviewMatrixStack.Top;
 
 	if (nctx->fallback != HWTNL)
 		return;
 
-	if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled) {
-		BEGIN_RING(chan, kelvin, NV20TCL_MODELVIEW0_MATRIX(0), 16);
-		OUT_RINGm(chan, m->m);
+	if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled ||
+	    (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
+		BEGIN_NV04(push, NV20_3D(MODELVIEW_MATRIX(0, 0)), 16);
+		PUSH_DATAm(push, m->m);
 	}
 
-	if (ctx->Light.Enabled) {
+	if (ctx->Light.Enabled ||
+	    (ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
 		int i, j;
 
-		BEGIN_RING(chan, kelvin,
-			   NV20TCL_INVERSE_MODELVIEW0_MATRIX(0), 12);
+		BEGIN_NV04(push, NV20_3D(INVERSE_MODELVIEW_MATRIX(0, 0)), 12);
 		for (i = 0; i < 3; i++)
 			for (j = 0; j < 4; j++)
-				OUT_RINGf(chan, m->inv[4*i + j]);
+				PUSH_DATAf(push, m->inv[4*i + j]);
 	}
 }
 
 void
-nv20_emit_projection(GLcontext *ctx, int emit)
+nv20_emit_projection(struct gl_context *ctx, int emit)
 {
 	struct nouveau_context *nctx = to_nouveau_context(ctx);
-	struct nouveau_channel *chan = context_chan(ctx);
-	struct nouveau_grobj *kelvin = context_eng3d(ctx);
+	struct nouveau_pushbuf *push = context_push(ctx);
 	GLmatrix m;
 
 	_math_matrix_ctr(&m);
@@ -389,8 +369,8 @@ nv20_emit_projection(GLcontext *ctx, int emit)
 	if (nctx->fallback == HWTNL)
 		_math_matrix_mul_matrix(&m, &m, &ctx->_ModelProjectMatrix);
 
-	BEGIN_RING(chan, kelvin, NV20TCL_PROJECTION_MATRIX(0), 16);
-	OUT_RINGm(chan, m.m);
+	BEGIN_NV04(push, NV20_3D(PROJECTION_MATRIX(0)), 16);
+	PUSH_DATAm(push, m.m);
 
 	_math_matrix_dtr(&m);
 }