static void
setup_hierz_buffer(struct gl_context *ctx)
{
struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_grobj *celsius = context_eng3d(ctx);
struct nouveau_bo_context *bctx = context_bctx(ctx, HIERZ);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(fb);
unsigned pitch = align(fb->Width, 128),
height = align(fb->Height, 2),
size = pitch * height;
if (!nfb->hierz.bo || nfb->hierz.bo->size != size) {
nouveau_bo_ref(NULL, &nfb->hierz.bo);
nouveau_bo_new_tile(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size,
0, NOUVEAU_BO_TILE_ZETA, &nfb->hierz.bo);
}
nouveau_bo_markl(bctx, celsius, NV17_3D_HIERZ_OFFSET,
nfb->hierz.bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
WAIT_RING(chan, 9);
BEGIN_RING(chan, celsius, NV17_3D_HIERZ_WINDOW_X, 4);
OUT_RINGf(chan, - 1792);
OUT_RINGf(chan, - 2304 + fb->Height);
OUT_RINGf(chan, fb->_DepthMaxF / 2);
OUT_RINGf(chan, 0);
BEGIN_RING(chan, celsius, NV17_3D_HIERZ_PITCH, 1);
OUT_RING(chan, pitch);
BEGIN_RING(chan, celsius, NV17_3D_HIERZ_ENABLE, 1);
OUT_RING(chan, 1);
}
static void
emit_b64_2(struct nouveau_channel *chan, void *data)
{
double *v = data;
OUT_RINGf(chan, v[0]);
OUT_RINGf(chan, v[1]);
}
void
nv50_clear(struct pipe_context *pipe, unsigned buffers,
const float *rgba, double depth, unsigned stencil)
{
struct nv50_context *nv50 = nv50_context(pipe);
struct nouveau_channel *chan = nv50->screen->base.channel;
struct pipe_framebuffer_state *fb = &nv50->framebuffer;
unsigned i;
const unsigned dirty = nv50->dirty;
uint32_t mode = 0;
/* don't need NEW_BLEND, COLOR_MASK doesn't affect CLEAR_BUFFERS */
nv50->dirty &= NV50_NEW_FRAMEBUFFER;
if (!nv50_state_validate(nv50, 9 + (fb->nr_cbufs * 2)))
return;
if (buffers & PIPE_CLEAR_COLOR && fb->nr_cbufs) {
BEGIN_RING(chan, RING_3D(CLEAR_COLOR(0)), 4);
OUT_RINGf (chan, rgba[0]);
OUT_RINGf (chan, rgba[1]);
OUT_RINGf (chan, rgba[2]);
OUT_RINGf (chan, rgba[3]);
mode =
NV50_3D_CLEAR_BUFFERS_R | NV50_3D_CLEAR_BUFFERS_G |
NV50_3D_CLEAR_BUFFERS_B | NV50_3D_CLEAR_BUFFERS_A;
}
if (buffers & PIPE_CLEAR_DEPTH) {
BEGIN_RING(chan, RING_3D(CLEAR_DEPTH), 1);
OUT_RING (chan, fui(depth));
mode |= NV50_3D_CLEAR_BUFFERS_Z;
}
if (buffers & PIPE_CLEAR_STENCIL) {
BEGIN_RING(chan, RING_3D(CLEAR_STENCIL), 1);
OUT_RING (chan, stencil & 0xff);
mode |= NV50_3D_CLEAR_BUFFERS_S;
}
BEGIN_RING(chan, RING_3D(CLEAR_BUFFERS), 1);
OUT_RING (chan, mode);
for (i = 1; i < fb->nr_cbufs; i++) {
BEGIN_RING(chan, RING_3D(CLEAR_BUFFERS), 1);
OUT_RING (chan, (i << 6) | 0x3c);
}
nv50->dirty = dirty & ~NV50_NEW_FRAMEBUFFER;
}
void
nv10_emit_polygon_offset(GLcontext *ctx, int emit)
{
struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_grobj *celsius = context_eng3d(ctx);
BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
OUT_RING(chan, ctx->Polygon.OffsetPoint ? 1 : 0);
OUT_RING(chan, ctx->Polygon.OffsetLine ? 1 : 0);
OUT_RING(chan, ctx->Polygon.OffsetFill ? 1 : 0);
BEGIN_RING(chan, celsius, NV10TCL_POLYGON_OFFSET_FACTOR, 2);
OUT_RINGf(chan, ctx->Polygon.OffsetFactor);
OUT_RINGf(chan, ctx->Polygon.OffsetUnits);
}
static void
nv50_clear_render_target(struct pipe_context *pipe,
struct pipe_surface *dst,
const float *rgba,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
struct nv50_context *nv50 = nv50_context(pipe);
struct nv50_screen *screen = nv50->screen;
struct nouveau_channel *chan = screen->base.channel;
struct nv50_miptree *mt = nv50_miptree(dst->texture);
struct nv50_surface *sf = nv50_surface(dst);
struct nouveau_bo *bo = mt->base.bo;
BEGIN_RING(chan, RING_3D(CLEAR_COLOR(0)), 4);
OUT_RINGf (chan, rgba[0]);
OUT_RINGf (chan, rgba[1]);
OUT_RINGf (chan, rgba[2]);
OUT_RINGf (chan, rgba[3]);
if (MARK_RING(chan, 18, 2))
return;
BEGIN_RING(chan, RING_3D(RT_CONTROL), 1);
OUT_RING (chan, 1);
BEGIN_RING(chan, RING_3D(RT_ADDRESS_HIGH(0)), 5);
OUT_RELOCh(chan, bo, sf->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
OUT_RELOCl(chan, bo, sf->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
OUT_RING (chan, nv50_format_table[dst->format].rt);
OUT_RING (chan, mt->level[sf->base.u.tex.level].tile_mode << 4);
OUT_RING (chan, 0);
BEGIN_RING(chan, RING_3D(RT_HORIZ(0)), 2);
OUT_RING (chan, sf->width);
OUT_RING (chan, sf->height);
BEGIN_RING(chan, RING_3D(RT_ARRAY_MODE), 1);
OUT_RING (chan, 1);
/* NOTE: only works with D3D clear flag (5097/0x143c bit 4) */
BEGIN_RING(chan, RING_3D(VIEWPORT_HORIZ(0)), 2);
OUT_RING (chan, (width << 16) | dstx);
OUT_RING (chan, (height << 16) | dsty);
BEGIN_RING(chan, RING_3D(CLEAR_BUFFERS), 1);
OUT_RING (chan, 0x3c);
nv50->dirty |= NV50_NEW_FRAMEBUFFER;
}
static void
NV20VPUpdateConst(GLcontext *ctx, nouveauShader *nvs, int id)
{
nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
/* Worth checking if the value *actually* changed? Mesa doesn't tell us this
* as far as I know..
*/
BEGIN_RING_SIZE(NvSub3D, NV30_TCL_PRIMITIVE_3D_VP_UPLOAD_CONST_ID, 1);
OUT_RING (id);
BEGIN_RING_SIZE(NvSub3D, NV20_TCL_PRIMITIVE_3D_VP_UPLOAD_CONST_X, 4);
OUT_RINGf(nvs->params[id].source_val[0]);
OUT_RINGf(nvs->params[id].source_val[1]);
OUT_RINGf(nvs->params[id].source_val[2]);
OUT_RINGf(nvs->params[id].source_val[3]);
}
static void
nv50_clear_depth_stencil(struct pipe_context *pipe,
struct pipe_surface *dst,
unsigned clear_flags,
double depth,
unsigned stencil,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
struct nv50_context *nv50 = nv50_context(pipe);
struct nv50_screen *screen = nv50->screen;
struct nouveau_channel *chan = screen->base.channel;
struct nv50_miptree *mt = nv50_miptree(dst->texture);
struct nv50_surface *sf = nv50_surface(dst);
struct nouveau_bo *bo = mt->base.bo;
uint32_t mode = 0;
if (clear_flags & PIPE_CLEAR_DEPTH) {
BEGIN_RING(chan, RING_3D(CLEAR_DEPTH), 1);
OUT_RINGf (chan, depth);
mode |= NV50_3D_CLEAR_BUFFERS_Z;
}
if (clear_flags & PIPE_CLEAR_STENCIL) {
BEGIN_RING(chan, RING_3D(CLEAR_STENCIL), 1);
OUT_RING (chan, stencil & 0xff);
mode |= NV50_3D_CLEAR_BUFFERS_S;
}
if (MARK_RING(chan, 17, 2))
return;
BEGIN_RING(chan, RING_3D(ZETA_ADDRESS_HIGH), 5);
OUT_RELOCh(chan, bo, sf->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
OUT_RELOCl(chan, bo, sf->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
OUT_RING (chan, nv50_format_table[dst->format].rt);
OUT_RING (chan, mt->level[sf->base.u.tex.level].tile_mode << 4);
OUT_RING (chan, 0);
BEGIN_RING(chan, RING_3D(ZETA_ENABLE), 1);
OUT_RING (chan, 1);
BEGIN_RING(chan, RING_3D(ZETA_HORIZ), 3);
OUT_RING (chan, sf->width);
OUT_RING (chan, sf->height);
OUT_RING (chan, (1 << 16) | 1);
BEGIN_RING(chan, RING_3D(VIEWPORT_HORIZ(0)), 2);
OUT_RING (chan, (width << 16) | dstx);
OUT_RING (chan, (height << 16) | dsty);
BEGIN_RING(chan, RING_3D(CLEAR_BUFFERS), 1);
OUT_RING (chan, mode);
nv50->dirty |= NV50_NEW_FRAMEBUFFER;
}
void
nv20_emit_point_mode(GLcontext *ctx, int emit)
{
struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_grobj *kelvin = context_eng3d(ctx);
BEGIN_RING(chan, kelvin, NV20TCL_POINT_SIZE, 1);
if (context_chipset(ctx) >= 0x25)
OUT_RINGf(chan, ctx->Point.Size);
else
OUT_RING(chan, (uint32_t)(ctx->Point.Size * 8));
}
void
nv10_emit_zclear(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_grobj *celsius = context_eng3d(ctx);
struct nouveau_framebuffer *nfb =
to_nouveau_framebuffer(ctx->DrawBuffer);
if (nfb->hierz.bo) {
BEGIN_RING(chan, celsius, NV17_3D_ZCLEAR_ENABLE, 2);
OUT_RINGb(chan, !nctx->hierz.clear_blocked);
OUT_RING(chan, nfb->hierz.clear_value |
(nctx->hierz.clear_seq & 0xff));
} else {
BEGIN_RING(chan, celsius, NV10_3D_DEPTH_RANGE_NEAR, 2);
OUT_RINGf(chan, nv10_transform_depth(ctx, 0));
OUT_RINGf(chan, nv10_transform_depth(ctx, 1));
context_dirty(ctx, VIEWPORT);
}
}
/* Initialise any card-specific non-GL related state */
static GLboolean nv20InitCard(nouveauContextPtr nmesa)
{
nouveauObjectOnSubchannel(nmesa, NvSub3D, Nv3D);
BEGIN_RING_SIZE(NvSub3D, NV20_TCL_PRIMITIVE_3D_SET_OBJECT1, 2);
OUT_RING(NvDmaFB); /* 184 dma_object1 */
OUT_RING(NvDmaFB); /* 188 dma_object2 */
BEGIN_RING_SIZE(NvSub3D, NV20_TCL_PRIMITIVE_3D_SET_OBJECT3, 2);
OUT_RING(NvDmaFB); /* 194 dma_object3 */
OUT_RING(NvDmaFB); /* 198 dma_object4 */
BEGIN_RING_SIZE(NvSub3D, NV20_TCL_PRIMITIVE_3D_SET_OBJECT8, 1);
OUT_RING(NvDmaFB); /* 1a8 dma_object8 */
BEGIN_RING_SIZE(NvSub3D, 0x17e0, 3);
OUT_RINGf(0.0);
OUT_RINGf(0.0);
OUT_RINGf(1.0);
BEGIN_RING_SIZE(NvSub3D, 0x1e6c, 1);
OUT_RING(0x0db6);
BEGIN_RING_SIZE(NvSub3D, 0x0290, 1);
OUT_RING(0x00100001);
BEGIN_RING_SIZE(NvSub3D, 0x09fc, 1);
OUT_RING(0);
BEGIN_RING_SIZE(NvSub3D, 0x1d80, 1);
OUT_RING(1);
BEGIN_RING_SIZE(NvSub3D, 0x09f8, 1);
OUT_RING(4);
BEGIN_RING_SIZE(NvSub3D, 0x17ec, 3);
OUT_RINGf(0.0);
OUT_RINGf(1.0);
OUT_RINGf(0.0);
BEGIN_RING_SIZE(NvSub3D, 0x1d88, 1);
OUT_RING(3);
/* FIXME: More dma objects to setup ? */
BEGIN_RING_SIZE(NvSub3D, 0x1e98, 1);
OUT_RING(0);
BEGIN_RING_SIZE(NvSub3D, 0x120, 3);
OUT_RING(0);
OUT_RING(1);
OUT_RING(2);
return GL_TRUE;
}
static inline void
emit_vertex(NVPtr pNv, int i, PictVector pos[],
PictVector tex0[], PictVector tex1[])
{
struct nouveau_channel *chan = pNv->chan;
BEGIN_NV04(chan, NV10_3D(VERTEX_TX0_2F_S), 2);
OUT_RINGi (chan, tex0[i], 0);
OUT_RINGi (chan, tex0[i], 1);
if (tex1) {
BEGIN_NV04(chan, NV10_3D(VERTEX_TX1_2F_S), 2);
OUT_RINGi (chan, tex1[i], 0);
OUT_RINGi (chan, tex1[i], 1);
}
BEGIN_NV04(chan, NV10_3D(VERTEX_POS_3F_X), 3);
OUT_RINGi (chan, pos[i], 0);
OUT_RINGi (chan, pos[i], 1);
OUT_RINGf (chan, 0);
}
static inline void
emit_vertex(NVPtr pNv, int i, PictVector pos[],
PictVector tex0[], PictVector tex1[])
{
struct nouveau_channel *chan = pNv->chan;
struct nouveau_grobj *celsius = pNv->Nv3D;
BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX0_2F_S, 2);
OUT_RINGi (chan, tex0[i], 0);
OUT_RINGi (chan, tex0[i], 1);
if (tex1) {
BEGIN_RING(chan, celsius, NV10TCL_VERTEX_TX1_2F_S, 2);
OUT_RINGi (chan, tex1[i], 0);
OUT_RINGi (chan, tex1[i], 1);
}
BEGIN_RING(chan, celsius, NV10TCL_VERTEX_POS_3F_X, 3);
OUT_RINGi (chan, pos[i], 0);
OUT_RINGi (chan, pos[i], 1);
OUT_RINGf (chan, 0);
}
static void
nv50_resource_resolve(struct pipe_context *pipe,
const struct pipe_resolve_info *info)
{
struct nv50_context *nv50 = nv50_context(pipe);
struct nv50_screen *screen = nv50->screen;
struct nv50_blitctx *blit = screen->blitctx;
struct nouveau_channel *chan = screen->base.channel;
struct pipe_resource *src = info->src.res;
struct pipe_resource *dst = info->dst.res;
float x0, x1, y0, y1, z;
float x_range, y_range;
nv50_blitctx_get_color_mask_and_fp(blit, dst->format, info->mask);
blit->filter = util_format_is_depth_or_stencil(dst->format) ? 0 : 1;
nv50_blitctx_pre_blit(blit, nv50);
nv50_blit_set_dst(nv50, dst, info->dst.level, info->dst.layer);
nv50_blit_set_src(nv50, src, 0, info->src.layer);
nv50_blitctx_prepare_state(blit);
nv50_state_validate(nv50, 36);
x_range =
(float)(info->src.x1 - info->src.x0) /
(float)(info->dst.x1 - info->dst.x0);
y_range =
(float)(info->src.y1 - info->src.y0) /
(float)(info->dst.y1 - info->dst.y0);
x0 = (float)info->src.x0 - x_range * (float)info->dst.x0;
y0 = (float)info->src.y0 - y_range * (float)info->dst.y0;
x1 = x0 + 16384.0f * x_range;
y1 = y0 + 16384.0f * y_range;
x0 *= (float)(1 << nv50_miptree(src)->ms_x);
x1 *= (float)(1 << nv50_miptree(src)->ms_x);
y0 *= (float)(1 << nv50_miptree(src)->ms_y);
y1 *= (float)(1 << nv50_miptree(src)->ms_y);
z = (float)info->src.layer;
BEGIN_RING(chan, RING_3D(FP_START_ID), 1);
OUT_RING (chan,
blit->fp.code_base + blit->fp_offset);
BEGIN_RING(chan, RING_3D(VIEWPORT_TRANSFORM_EN), 1);
OUT_RING (chan, 0);
/* Draw a large triangle in screen coordinates covering the whole
* render target, with scissors defining the destination region.
* The vertex is supplied with non-normalized texture coordinates
* arranged in a way to yield the desired offset and scale.
*/
BEGIN_RING(chan, RING_3D(SCISSOR_HORIZ(0)), 2);
OUT_RING (chan, (info->dst.x1 << 16) | info->dst.x0);
OUT_RING (chan, (info->dst.y1 << 16) | info->dst.y0);
BEGIN_RING(chan, RING_3D(VERTEX_BEGIN_GL), 1);
OUT_RING (chan, NV50_3D_VERTEX_BEGIN_GL_PRIMITIVE_TRIANGLES);
BEGIN_RING(chan, RING_3D(VTX_ATTR_3F_X(1)), 3);
OUT_RINGf (chan, x0);
OUT_RINGf (chan, y0);
OUT_RINGf (chan, z);
BEGIN_RING(chan, RING_3D(VTX_ATTR_2F_X(0)), 2);
OUT_RINGf (chan, 0.0f);
OUT_RINGf (chan, 0.0f);
BEGIN_RING(chan, RING_3D(VTX_ATTR_3F_X(1)), 3);
OUT_RINGf (chan, x1);
OUT_RINGf (chan, y0);
OUT_RINGf (chan, z);
BEGIN_RING(chan, RING_3D(VTX_ATTR_2F_X(0)), 2);
OUT_RINGf (chan, 16384 << nv50_miptree(dst)->ms_x);
OUT_RINGf (chan, 0.0f);
BEGIN_RING(chan, RING_3D(VTX_ATTR_3F_X(1)), 3);
OUT_RINGf (chan, x0);
OUT_RINGf (chan, y1);
OUT_RINGf (chan, z);
BEGIN_RING(chan, RING_3D(VTX_ATTR_2F_X(0)), 2);
OUT_RINGf (chan, 0.0f);
OUT_RINGf (chan, 16384 << nv50_miptree(dst)->ms_y);
BEGIN_RING(chan, RING_3D(VERTEX_END_GL), 1);
OUT_RING (chan, 0);
/* re-enable normally constant state */
BEGIN_RING(chan, RING_3D(VIEWPORT_TRANSFORM_EN), 1);
OUT_RING (chan, 1);
nv50_blitctx_post_blit(nv50, blit);
}
void
nvfx_state_viewport_validate(struct nvfx_context *nvfx)
{
struct nouveau_channel *chan = nvfx->screen->base.channel;
struct nouveau_grobj *eng3d = nvfx->screen->eng3d;
struct pipe_viewport_state *vpt = &nvfx->viewport;
if(nvfx->render_mode == HW) {
BEGIN_RING(chan, eng3d, NV30_3D_VIEWPORT_TRANSLATE_X, 8);
OUT_RINGf(chan, vpt->translate[0]);
OUT_RINGf(chan, vpt->translate[1]);
OUT_RINGf(chan, vpt->translate[2]);
OUT_RINGf(chan, vpt->translate[3]);
OUT_RINGf(chan, vpt->scale[0]);
OUT_RINGf(chan, vpt->scale[1]);
OUT_RINGf(chan, vpt->scale[2]);
OUT_RINGf(chan, vpt->scale[3]);
BEGIN_RING(chan, eng3d, 0x1d78, 1);
OUT_RING(chan, 1);
} else {
BEGIN_RING(chan, eng3d, NV30_3D_VIEWPORT_TRANSLATE_X, 8);
OUT_RINGf(chan, 0.0f);
OUT_RINGf(chan, 0.0f);
OUT_RINGf(chan, 0.0f);
OUT_RINGf(chan, 0.0f);
OUT_RINGf(chan, 1.0f);
OUT_RINGf(chan, 1.0f);
OUT_RINGf(chan, 1.0f);
OUT_RINGf(chan, 1.0f);
BEGIN_RING(chan, eng3d, 0x1d78, 1);
OUT_RING(chan, nvfx->is_nv4x ? 0x110 : 1);
}
}
static void
nv10_hwctx_init(struct gl_context *ctx)
{
struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_grobj *celsius = context_eng3d(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
int i;
BEGIN_RING(chan, celsius, NV10_3D_DMA_NOTIFY, 1);
OUT_RING(chan, hw->ntfy->handle);
BEGIN_RING(chan, celsius, NV10_3D_DMA_TEXTURE0, 3);
OUT_RING(chan, chan->vram->handle);
OUT_RING(chan, chan->gart->handle);
OUT_RING(chan, chan->gart->handle);
BEGIN_RING(chan, celsius, NV10_3D_DMA_COLOR, 2);
OUT_RING(chan, chan->vram->handle);
OUT_RING(chan, chan->vram->handle);
BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_RT_HORIZ, 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(0), 1);
OUT_RING(chan, 0x7ff << 16 | 0x800);
BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(0), 1);
OUT_RING(chan, 0x7ff << 16 | 0x800);
for (i = 1; i < 8; i++) {
BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(i), 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(i), 1);
OUT_RING(chan, 0);
}
BEGIN_RING(chan, celsius, 0x290, 1);
OUT_RING(chan, 0x10 << 16 | 1);
BEGIN_RING(chan, celsius, 0x3f4, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
OUT_RING(chan, 0);
if (context_chipset(ctx) >= 0x17) {
BEGIN_RING(chan, celsius, NV17_3D_UNK01AC, 2);
OUT_RING(chan, chan->vram->handle);
OUT_RING(chan, chan->vram->handle);
BEGIN_RING(chan, celsius, 0xd84, 1);
OUT_RING(chan, 0x3);
BEGIN_RING(chan, celsius, NV17_3D_COLOR_MASK_ENABLE, 1);
OUT_RING(chan, 1);
}
if (context_chipset(ctx) >= 0x11) {
BEGIN_RING(chan, celsius, 0x120, 3);
OUT_RING(chan, 0);
OUT_RING(chan, 1);
OUT_RING(chan, 2);
BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
OUT_RING(chan, 0);
}
BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
OUT_RING(chan, 0);
/* Set state */
BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_FUNC, 2);
OUT_RING(chan, 0x207);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(0), 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_DITHER_ENABLE, 2);
OUT_RING(chan, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_WEIGHT_ENABLE, 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_SRC, 4);
OUT_RING(chan, 1);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
OUT_RING(chan, 0x8006);
BEGIN_RING(chan, celsius, NV10_3D_STENCIL_MASK, 8);
OUT_RING(chan, 0xff);
OUT_RING(chan, 0x207);
OUT_RING(chan, 0);
OUT_RING(chan, 0xff);
OUT_RING(chan, 0x1e00);
OUT_RING(chan, 0x1e00);
OUT_RING(chan, 0x1e00);
OUT_RING(chan, 0x1d01);
BEGIN_RING(chan, celsius, NV10_3D_NORMALIZE_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_SEPARATE_SPECULAR_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_ENABLED_LIGHTS, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_POINT_ENABLE, 3);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_DEPTH_FUNC, 1);
OUT_RING(chan, 0x201);
BEGIN_RING(chan, celsius, NV10_3D_DEPTH_WRITE_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_DEPTH_TEST_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_FACTOR, 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_POINT_SIZE, 1);
OUT_RING(chan, 8);
BEGIN_RING(chan, celsius, NV10_3D_POINT_PARAMETERS_ENABLE, 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_LINE_WIDTH, 1);
OUT_RING(chan, 8);
BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_POLYGON_MODE_FRONT, 2);
OUT_RING(chan, 0x1b02);
OUT_RING(chan, 0x1b02);
BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE, 2);
OUT_RING(chan, 0x405);
OUT_RING(chan, 0x901);
BEGIN_RING(chan, celsius, NV10_3D_POLYGON_SMOOTH_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE_ENABLE, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(0, 0), 8);
for (i = 0; i < 8; i++)
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(0), 2);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_FOG_COEFF(0), 3);
OUT_RING(chan, 0x3fc00000); /* -1.50 */
OUT_RING(chan, 0xbdb8aa0a); /* -0.09 */
OUT_RING(chan, 0); /* 0.00 */
BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_FOG_MODE, 2);
OUT_RING(chan, 0x802);
OUT_RING(chan, 2);
/* for some reason VIEW_MATRIX_ENABLE need to be 6 instead of 4 when
* using texturing, except when using the texture matrix
*/
BEGIN_RING(chan, celsius, NV10_3D_VIEW_MATRIX_ENABLE, 1);
OUT_RING(chan, 6);
BEGIN_RING(chan, celsius, NV10_3D_COLOR_MASK, 1);
OUT_RING(chan, 0x01010101);
/* Set vertex component */
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_COL_4F_R, 4);
OUT_RINGf(chan, 1.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 1.0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_COL2_3F_R, 3);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_NOR_3F_X, 3);
OUT_RING(chan, 0);
OUT_RING(chan, 0);
OUT_RINGf(chan, 1.0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_TX0_4F_S, 4);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 1.0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_TX1_4F_S, 4);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 1.0);
BEGIN_RING(chan, celsius, NV10_3D_VERTEX_FOG_1F, 1);
OUT_RINGf(chan, 0.0);
BEGIN_RING(chan, celsius, NV10_3D_EDGEFLAG_ENABLE, 1);
OUT_RING(chan, 1);
BEGIN_RING(chan, celsius, NV10_3D_DEPTH_RANGE_NEAR, 2);
OUT_RINGf(chan, 0.0);
OUT_RINGf(chan, 16777216.0);
FIRE_RING(chan);
}
static void nv20_init_hwctx(struct nv20_context *nv20)
{
struct nv20_screen *screen = nv20->screen;
struct nouveau_channel *chan = screen->base.channel;
int i;
float projectionmatrix[16];
const boolean is_nv25tcl = (nv20->screen->kelvin->grclass == NV25TCL);
BEGIN_RING(kelvin, NV20TCL_DMA_NOTIFY, 1);
OUT_RING (screen->sync->handle);
BEGIN_RING(kelvin, NV20TCL_DMA_TEXTURE0, 2);
OUT_RING (chan->vram->handle);
OUT_RING (chan->gart->handle); /* TEXTURE1 */
BEGIN_RING(kelvin, NV20TCL_DMA_COLOR, 2);
OUT_RING (chan->vram->handle);
OUT_RING (chan->vram->handle); /* ZETA */
BEGIN_RING(kelvin, NV20TCL_DMA_QUERY, 1);
OUT_RING (0); /* renouveau: beef0351, unique */
BEGIN_RING(kelvin, NV20TCL_RT_HORIZ, 2);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_CLIP_HORIZ(0), 1);
OUT_RING ((0xfff << 16) | 0x0);
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_CLIP_VERT(0), 1);
OUT_RING ((0xfff << 16) | 0x0);
for (i = 1; i < NV20TCL_VIEWPORT_CLIP_HORIZ__SIZE; i++) {
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_CLIP_HORIZ(i), 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_CLIP_VERT(i), 1);
OUT_RING (0);
}
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_CLIP_MODE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, 0x17e0, 3);
OUT_RINGf (0.0);
OUT_RINGf (0.0);
OUT_RINGf (1.0);
if (is_nv25tcl) {
BEGIN_RING(kelvin, NV20TCL_TX_RCOMP, 1);
OUT_RING (NV20TCL_TX_RCOMP_LEQUAL | 0xdb0);
} else {
BEGIN_RING(kelvin, 0x1e68, 1);
OUT_RING (0x4b800000); /* 16777216.000000 */
BEGIN_RING(kelvin, NV20TCL_TX_RCOMP, 1);
OUT_RING (NV20TCL_TX_RCOMP_LEQUAL);
}
BEGIN_RING(kelvin, 0x290, 1);
OUT_RING ((0x10 << 16) | 1);
BEGIN_RING(kelvin, 0x9fc, 1);
OUT_RING (0);
BEGIN_RING(kelvin, 0x1d80, 1);
OUT_RING (1);
BEGIN_RING(kelvin, 0x9f8, 1);
OUT_RING (4);
BEGIN_RING(kelvin, 0x17ec, 3);
OUT_RINGf (0.0);
OUT_RINGf (1.0);
OUT_RINGf (0.0);
if (is_nv25tcl) {
BEGIN_RING(kelvin, 0x1d88, 1);
OUT_RING (3);
BEGIN_RING(kelvin, NV25TCL_DMA_IN_MEMORY9, 1);
OUT_RING (chan->vram->handle);
BEGIN_RING(kelvin, NV25TCL_DMA_IN_MEMORY8, 1);
OUT_RING (chan->vram->handle);
}
BEGIN_RING(kelvin, NV20TCL_DMA_FENCE, 1);
OUT_RING (0); /* renouveau: beef1e10 */
BEGIN_RING(kelvin, 0x1e98, 1);
OUT_RING (0);
#if 0
if (is_nv25tcl) {
BEGIN_RING(NvSub3D, NV25TCL_DMA_IN_MEMORY4, 2);
OUT_RING (NvDmaTT); /* renouveau: beef0202 */
OUT_RING (NvDmaFB); /* renouveau: beef0201 */
BEGIN_RING(NvSub3D, NV20TCL_DMA_TEXTURE1, 1);
OUT_RING (NvDmaTT); /* renouveau: beef0202 */
}
#endif
BEGIN_RING(kelvin, NV20TCL_NOTIFY, 1);
OUT_RING (0);
BEGIN_RING(kelvin, 0x120, 3);
OUT_RING (0);
OUT_RING (1);
OUT_RING (2);
/* error: ILLEGAL_MTHD, PROTECTION_FAULT
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_TRANSLATE_X, 4);
OUT_RINGf (0.0);
OUT_RINGf (512.0);
OUT_RINGf (0.0);
OUT_RINGf (0.0);
*/
if (is_nv25tcl) {
BEGIN_RING(kelvin, 0x022c, 2);
OUT_RING (0x280);
OUT_RING (0x07d28000);
}
/* * illegal method, protection fault
BEGIN_RING(NvSub3D, 0x1c2c, 1);
OUT_RING (0); */
if (is_nv25tcl) {
BEGIN_RING(kelvin, 0x1da4, 1);
OUT_RING (0);
}
/* * crashes with illegal method, protection fault
BEGIN_RING(NvSub3D, 0x1c18, 1);
OUT_RING (0x200); */
BEGIN_RING(kelvin, NV20TCL_RT_HORIZ, 2);
OUT_RING ((0 << 16) | 0);
OUT_RING ((0 << 16) | 0);
/* *** Set state *** */
BEGIN_RING(kelvin, NV20TCL_ALPHA_FUNC_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_ALPHA_FUNC_FUNC, 2);
OUT_RING (NV20TCL_ALPHA_FUNC_FUNC_ALWAYS);
OUT_RING (0); /* NV20TCL_ALPHA_FUNC_REF */
for (i = 0; i < NV20TCL_TX_ENABLE__SIZE; ++i) {
BEGIN_RING(kelvin, NV20TCL_TX_ENABLE(i), 1);
OUT_RING (0);
}
BEGIN_RING(kelvin, NV20TCL_TX_SHADER_OP, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_TX_SHADER_CULL_MODE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_IN_ALPHA(0), 4);
OUT_RING (0x30d410d0);
OUT_RING (0);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_OUT_RGB(0), 4);
OUT_RING (0x00000c00);
OUT_RING (0);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_ENABLE, 1);
OUT_RING (0x00011101);
BEGIN_RING(kelvin, NV20TCL_RC_FINAL0, 2);
OUT_RING (0x130e0300);
OUT_RING (0x0c091c80);
BEGIN_RING(kelvin, NV20TCL_RC_OUT_ALPHA(0), 4);
OUT_RING (0x00000c00);
OUT_RING (0);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_IN_RGB(0), 4);
OUT_RING (0x20c400c0);
OUT_RING (0);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_COLOR0, 2);
OUT_RING (0);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_RC_CONSTANT_COLOR0(0), 4);
OUT_RING (0x035125a0);
OUT_RING (0);
OUT_RING (0x40002000);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_MULTISAMPLE_CONTROL, 1);
OUT_RING (0xffff0000);
BEGIN_RING(kelvin, NV20TCL_BLEND_FUNC_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_DITHER_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_STENCIL_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_BLEND_FUNC_SRC, 4);
OUT_RING (NV20TCL_BLEND_FUNC_SRC_ONE);
OUT_RING (NV20TCL_BLEND_FUNC_DST_ZERO);
OUT_RING (0); /* NV20TCL_BLEND_COLOR */
OUT_RING (NV20TCL_BLEND_EQUATION_FUNC_ADD);
BEGIN_RING(kelvin, NV20TCL_STENCIL_MASK, 7);
OUT_RING (0xff);
OUT_RING (NV20TCL_STENCIL_FUNC_FUNC_ALWAYS);
OUT_RING (0); /* NV20TCL_STENCIL_FUNC_REF */
OUT_RING (0xff); /* NV20TCL_STENCIL_FUNC_MASK */
OUT_RING (NV20TCL_STENCIL_OP_FAIL_KEEP);
OUT_RING (NV20TCL_STENCIL_OP_ZFAIL_KEEP);
OUT_RING (NV20TCL_STENCIL_OP_ZPASS_KEEP);
BEGIN_RING(kelvin, NV20TCL_COLOR_LOGIC_OP_ENABLE, 2);
OUT_RING (0);
OUT_RING (NV20TCL_COLOR_LOGIC_OP_OP_COPY);
BEGIN_RING(kelvin, 0x17cc, 1);
OUT_RING (0);
if (is_nv25tcl) {
BEGIN_RING(kelvin, 0x1d84, 1);
OUT_RING (1);
}
BEGIN_RING(kelvin, NV20TCL_LIGHTING_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_LIGHT_CONTROL, 1);
OUT_RING (0x00020000);
BEGIN_RING(kelvin, NV20TCL_SEPARATE_SPECULAR_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_LIGHT_MODEL_TWO_SIDE_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_ENABLED_LIGHTS, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_NORMALIZE_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_POLYGON_STIPPLE_PATTERN(0),
NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE);
for (i = 0; i < NV20TCL_POLYGON_STIPPLE_PATTERN__SIZE; ++i) {
OUT_RING(0xffffffff);
}
BEGIN_RING(kelvin, NV20TCL_POLYGON_OFFSET_POINT_ENABLE, 3);
OUT_RING (0);
OUT_RING (0); /* NV20TCL.POLYGON_OFFSET_LINE_ENABLE */
OUT_RING (0); /* NV20TCL.POLYGON_OFFSET_FILL_ENABLE */
BEGIN_RING(kelvin, NV20TCL_DEPTH_FUNC, 1);
OUT_RING (NV20TCL_DEPTH_FUNC_LESS);
BEGIN_RING(kelvin, NV20TCL_DEPTH_WRITE_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_DEPTH_TEST_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_POLYGON_OFFSET_FACTOR, 2);
OUT_RINGf (0.0);
OUT_RINGf (0.0); /* NV20TCL.POLYGON_OFFSET_UNITS */
BEGIN_RING(kelvin, NV20TCL_DEPTH_UNK17D8, 1);
OUT_RING (1);
if (!is_nv25tcl) {
BEGIN_RING(kelvin, 0x1d84, 1);
OUT_RING (3);
}
BEGIN_RING(kelvin, NV20TCL_POINT_SIZE, 1);
if (!is_nv25tcl) {
OUT_RING (8);
} else {
OUT_RINGf (1.0);
}
if (!is_nv25tcl) {
BEGIN_RING(kelvin, NV20TCL_POINT_PARAMETERS_ENABLE, 2);
OUT_RING (0);
OUT_RING (0); /* NV20TCL.POINT_SMOOTH_ENABLE */
} else {
BEGIN_RING(kelvin, NV20TCL_POINT_PARAMETERS_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, 0x0a1c, 1);
OUT_RING (0x800);
}
BEGIN_RING(kelvin, NV20TCL_LINE_WIDTH, 1);
OUT_RING (8);
BEGIN_RING(kelvin, NV20TCL_LINE_SMOOTH_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_POLYGON_MODE_FRONT, 2);
OUT_RING (NV20TCL_POLYGON_MODE_FRONT_FILL);
OUT_RING (NV20TCL_POLYGON_MODE_BACK_FILL);
BEGIN_RING(kelvin, NV20TCL_CULL_FACE, 2);
OUT_RING (NV20TCL_CULL_FACE_BACK);
OUT_RING (NV20TCL_FRONT_FACE_CCW);
BEGIN_RING(kelvin, NV20TCL_POLYGON_SMOOTH_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_CULL_FACE_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_SHADE_MODEL, 1);
OUT_RING (NV20TCL_SHADE_MODEL_SMOOTH);
BEGIN_RING(kelvin, NV20TCL_POLYGON_STIPPLE_ENABLE, 1);
OUT_RING (0);
BEGIN_RING(kelvin, NV20TCL_TX_GEN_S(0), 4 * NV20TCL_TX_GEN_S__SIZE);
for (i=0; i < 4 * NV20TCL_TX_GEN_S__SIZE; ++i) {
OUT_RING(0);
}
BEGIN_RING(kelvin, NV20TCL_FOG_EQUATION_CONSTANT, 3);
OUT_RINGf (1.5);
OUT_RINGf (-0.090168); /* NV20TCL.FOG_EQUATION_LINEAR */
OUT_RINGf (0.0); /* NV20TCL.FOG_EQUATION_QUADRATIC */
BEGIN_RING(kelvin, NV20TCL_FOG_MODE, 2);
OUT_RING (NV20TCL_FOG_MODE_EXP_2);
OUT_RING (NV20TCL_FOG_COORD_DIST_COORD_FOG);
BEGIN_RING(kelvin, NV20TCL_FOG_ENABLE, 2);
OUT_RING (0);
OUT_RING (0); /* NV20TCL.FOG_COLOR */
BEGIN_RING(kelvin, NV20TCL_ENGINE, 1);
OUT_RING (NV20TCL_ENGINE_FIXED);
for (i = 0; i < NV20TCL_TX_MATRIX_ENABLE__SIZE; ++i) {
BEGIN_RING(kelvin, NV20TCL_TX_MATRIX_ENABLE(i), 1);
OUT_RING (0);
}
BEGIN_RING(kelvin, NV20TCL_VTX_ATTR_4F_X(1), 4 * 15);
OUT_RINGf(1.0); OUT_RINGf(0.0); OUT_RINGf(0.0); OUT_RINGf(1.0);
OUT_RINGf(0.0); OUT_RINGf(0.0); OUT_RINGf(1.0); OUT_RINGf(1.0);
OUT_RINGf(1.0); OUT_RINGf(1.0); OUT_RINGf(1.0); OUT_RINGf(1.0);
for (i = 4; i < 16; ++i) {
OUT_RINGf(0.0); OUT_RINGf(0.0); OUT_RINGf(0.0); OUT_RINGf(1.0);
}
BEGIN_RING(kelvin, NV20TCL_EDGEFLAG_ENABLE, 1);
OUT_RING (1);
BEGIN_RING(kelvin, NV20TCL_COLOR_MASK, 1);
OUT_RING (0x00010101);
BEGIN_RING(kelvin, NV20TCL_CLEAR_VALUE, 1);
OUT_RING (0);
memset(projectionmatrix, 0, sizeof(projectionmatrix));
projectionmatrix[0*4+0] = 1.0;
projectionmatrix[1*4+1] = 1.0;
projectionmatrix[2*4+2] = 16777215.0;
projectionmatrix[3*4+3] = 1.0;
BEGIN_RING(kelvin, NV20TCL_PROJECTION_MATRIX(0), 16);
for (i = 0; i < 16; i++) {
OUT_RINGf (projectionmatrix[i]);
}
BEGIN_RING(kelvin, NV20TCL_DEPTH_RANGE_NEAR, 2);
OUT_RINGf (0.0);
OUT_RINGf (16777216.0); /* [0, 1] scaled approx to [0, 2^24] */
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_TRANSLATE_X, 4);
OUT_RINGf (0.0); /* x-offset, w/2 + 1.031250 */
OUT_RINGf (0.0); /* y-offset, h/2 + 0.030762 */
OUT_RINGf (0.0);
OUT_RINGf (16777215.0);
BEGIN_RING(kelvin, NV20TCL_VIEWPORT_SCALE_X, 4);
OUT_RINGf (0.0); /* no effect?, w/2 */
OUT_RINGf (0.0); /* no effect?, h/2 */
OUT_RINGf (16777215.0 * 0.5);
OUT_RINGf (65535.0);
FIRE_RING (NULL);
}
